diff --git a/README.md b/README.md index 578949925..06cd4cfbf 100644 --- a/README.md +++ b/README.md @@ -84,6 +84,7 @@ Options: --enable-eddsa Enable support for EDDSA (default detect) --enable-mldsa Enable support for ML-DSA (default detect) --enable-mlkem Enable support for ML-KEM (default detect) + --enable-sha3 Enable support for SHA3 (default detect) --disable-visibility Disable hidden visibilty link mode [enabled] --with-crypto-backend Select crypto backend (openssl|botan) --with-openssl=PATH Specify prefix of path of OpenSSL diff --git a/cmake/modules/CompilerOptions.cmake b/cmake/modules/CompilerOptions.cmake index 0ee2aa05d..47b4023e1 100644 --- a/cmake/modules/CompilerOptions.cmake +++ b/cmake/modules/CompilerOptions.cmake @@ -239,6 +239,11 @@ if(WITH_CRYPTO_BACKEND STREQUAL "botan") message(STATUS "Botan: Support for GOST is disabled") endif(ENABLE_GOST) + # Botan has supported SHA3 since well before its minimum required + # version, so no version detection is needed. + set(WITH_SHA3 1) + message(STATUS "Botan: SHA3 is supported") + if(ENABLE_FIPS) message(FATAL_ERROR "Botan does not support FIPS 140-2 mode") endif(ENABLE_FIPS) @@ -412,6 +417,22 @@ elseif(WITH_CRYPTO_BACKEND STREQUAL "openssl") message(STATUS "OpenSSL: Support for ML-KEM is disabled") endif(ENABLE_MLKEM) + # acx_openssl_sha3.m4 + set(testfile ${CMAKE_SOURCE_DIR}/cmake/modules/tests/test_openssl_sha3.c) + try_run(RUN_SHA3 COMPILE_RESULT + "${CMAKE_BINARY_DIR}/prebuild_santity_tests" ${testfile} + LINK_LIBRARIES ${CRYPTO_LIBS} + CMAKE_FLAGS + "-DINCLUDE_DIRECTORIES=${CRYPTO_INCLUDES}" + ) + if(COMPILE_RESULT AND RUN_SHA3 EQUAL 0) + set(WITH_SHA3 1) + message(STATUS "OpenSSL: Found SHA3") + else() + set(error_msg "OpenSSL: Cannot find SHA3! OpenSSL library has no SHA3 support (requires OpenSSL >= 1.1.1 or LibreSSL >= 3.8.0)!") + message(FATAL_ERROR ${error_msg}) + endif() + # acx_openssl_gost.m4 if(ENABLE_GOST) set(testfile ${CMAKE_SOURCE_DIR}/cmake/modules/tests/test_openssl_gost.c) diff --git a/cmake/modules/tests/test_openssl_sha3.c b/cmake/modules/tests/test_openssl_sha3.c new file mode 100644 index 000000000..bb55f89fc --- /dev/null +++ b/cmake/modules/tests/test_openssl_sha3.c @@ -0,0 +1,16 @@ +/* + * Copyright (c) 2026 SoftHSMv2 contributors + * + * SPDX-License-Identifier: BSD-2-Clause + */ +#include +int main() +{ + const EVP_MD *md224 = EVP_sha3_224(); + const EVP_MD *md256 = EVP_sha3_256(); + const EVP_MD *md384 = EVP_sha3_384(); + const EVP_MD *md512 = EVP_sha3_512(); + if (md224 == NULL || md256 == NULL || md384 == NULL || md512 == NULL) + return 1; + return 0; +} diff --git a/config.h.in.cmake b/config.h.in.cmake index 10137d4c1..0ebec812c 100644 --- a/config.h.in.cmake +++ b/config.h.in.cmake @@ -157,6 +157,9 @@ /* Compile with ML-KEM support */ #cmakedefine WITH_ML_KEM @WITH_ML_KEM@ +/* Compile with SHA3 support */ +#cmakedefine WITH_SHA3 @WITH_SHA3@ + /* Compile with FIPS 140-2 mode */ #cmakedefine WITH_FIPS @WITH_FIPS@ diff --git a/m4/acx_crypto_backend.m4 b/m4/acx_crypto_backend.m4 index 41d5226bb..88f54852b 100644 --- a/m4/acx_crypto_backend.m4 +++ b/m4/acx_crypto_backend.m4 @@ -48,6 +48,16 @@ AC_DEFUN([ACX_CRYPTO_BACKEND],[ [enable_mlkem="detect"] ) + # Add SHA3 check + + AC_ARG_ENABLE(sha3, + AS_HELP_STRING([--enable-sha3], + [Enable support for SHA3 (default detect)] + ), + [enable_sha3="${enableval}"], + [enable_sha3="detect"] + ) + # Second check for the FIPS 140-2 mode AC_ARG_ENABLE(fips, @@ -138,6 +148,14 @@ AC_DEFUN([ACX_CRYPTO_BACKEND],[ detect-no) enable_mlkem="no";; esac + case "${enable_sha3}" in + yes|detect) ACX_OPENSSL_SHA3;; + esac + case "${enable_sha3}-${have_lib_openssl_sha3_support}" in + yes-no) AC_MSG_ERROR([OpenSSL library has no SHA3 support (requires OpenSSL >= 1.1.1 or LibreSSL >= 3.8.0)]);; + detect-*) enable_sha3="${have_lib_openssl_sha3_support}";; + esac + case "${enable_gost}-${enable_fips}" in yes-yes) AC_MSG_ERROR([GOST is not FIPS approved]);; yes-no|detect-no) ACX_OPENSSL_GOST;; @@ -212,6 +230,12 @@ AC_DEFUN([ACX_CRYPTO_BACKEND],[ AC_MSG_ERROR([Botan does not support ML-KEM]) fi + # Botan has supported SHA3 since well before its minimum required + # version, so no version detection is needed. + case "${enable_sha3}" in + detect) enable_sha3="yes";; + esac + case "${enable_gost}" in yes|detect) ACX_BOTAN_GOST;; esac @@ -303,6 +327,19 @@ AC_DEFUN([ACX_CRYPTO_BACKEND],[ fi AM_CONDITIONAL([WITH_ML_KEM], [test "x${enable_mlkem}" = "xyes"]) + AC_MSG_CHECKING(for SHA3 support) + if test "x${enable_sha3}" = "xyes"; then + AC_MSG_RESULT(yes) + AC_DEFINE_UNQUOTED( + [WITH_SHA3], + [], + [Compile with SHA3 support] + ) + else + AC_MSG_RESULT(no) + fi + AM_CONDITIONAL([WITH_SHA3], [test "x${enable_sha3}" = "xyes"]) + AC_SUBST(CRYPTO_INCLUDES) AC_SUBST(CRYPTO_LIBS) diff --git a/m4/acx_openssl_sha3.m4 b/m4/acx_openssl_sha3.m4 new file mode 100644 index 000000000..ca68df4b1 --- /dev/null +++ b/m4/acx_openssl_sha3.m4 @@ -0,0 +1,36 @@ +AC_DEFUN([ACX_OPENSSL_SHA3],[ + tmp_CPPFLAGS=$CPPFLAGS + tmp_LIBS=$LIBS + + CPPFLAGS="$CPPFLAGS $CRYPTO_INCLUDES" + LIBS="$CRYPTO_LIBS $LIBS" + + AC_LANG_PUSH([C]) + AC_CACHE_CHECK([for OpenSSL SHA3 support], [acx_cv_lib_openssl_sha3_support],[ + acx_cv_lib_openssl_sha3_support=no + AC_LINK_IFELSE([ + AC_LANG_SOURCE([[ + #include + int main() + { + const EVP_MD *md224 = EVP_sha3_224(); + const EVP_MD *md256 = EVP_sha3_256(); + const EVP_MD *md384 = EVP_sha3_384(); + const EVP_MD *md512 = EVP_sha3_512(); + if (md224 == NULL || md256 == NULL || md384 == NULL || md512 == NULL) + return 1; + return 0; + } + ]]) + ],[ + acx_cv_lib_openssl_sha3_support=yes + ],[ + acx_cv_lib_openssl_sha3_support=no + ]) + ]) + AC_LANG_POP([C]) + + CPPFLAGS=$tmp_CPPFLAGS + LIBS=$tmp_LIBS + have_lib_openssl_sha3_support="${acx_cv_lib_openssl_sha3_support}" +]) diff --git a/src/bin/dump/tables.h b/src/bin/dump/tables.h index 1a4505341..e104f8e97 100644 --- a/src/bin/dump/tables.h +++ b/src/bin/dump/tables.h @@ -178,6 +178,10 @@ void fill_CKM_table(std::map &t) t[CKM_DSA_SHA256] = "CKM_DSA_SHA256"; t[CKM_DSA_SHA384] = "CKM_DSA_SHA384"; t[CKM_DSA_SHA512] = "CKM_DSA_SHA512"; + t[CKM_DSA_SHA3_224] = "CKM_DSA_SHA3_224"; + t[CKM_DSA_SHA3_256] = "CKM_DSA_SHA3_256"; + t[CKM_DSA_SHA3_384] = "CKM_DSA_SHA3_384"; + t[CKM_DSA_SHA3_512] = "CKM_DSA_SHA3_512"; t[CKM_DH_PKCS_KEY_PAIR_GEN] = "CKM_DH_PKCS_KEY_PAIR_GEN"; t[CKM_DH_PKCS_DERIVE] = "CKM_DH_PKCS_DERIVE"; t[CKM_X9_42_DH_KEY_PAIR_GEN] = "CKM_X9_42_DH_KEY_PAIR_GEN"; @@ -192,6 +196,14 @@ void fill_CKM_table(std::map &t) t[CKM_SHA512_RSA_PKCS_PSS] = "CKM_SHA512_RSA_PKCS_PSS"; t[CKM_SHA224_RSA_PKCS] = "CKM_SHA224_RSA_PKCS"; t[CKM_SHA224_RSA_PKCS_PSS] = "CKM_SHA224_RSA_PKCS_PSS"; + t[CKM_SHA3_224_RSA_PKCS] = "CKM_SHA3_224_RSA_PKCS"; + t[CKM_SHA3_256_RSA_PKCS] = "CKM_SHA3_256_RSA_PKCS"; + t[CKM_SHA3_384_RSA_PKCS] = "CKM_SHA3_384_RSA_PKCS"; + t[CKM_SHA3_512_RSA_PKCS] = "CKM_SHA3_512_RSA_PKCS"; + t[CKM_SHA3_224_RSA_PKCS_PSS] = "CKM_SHA3_224_RSA_PKCS_PSS"; + t[CKM_SHA3_256_RSA_PKCS_PSS] = "CKM_SHA3_256_RSA_PKCS_PSS"; + t[CKM_SHA3_384_RSA_PKCS_PSS] = "CKM_SHA3_384_RSA_PKCS_PSS"; + t[CKM_SHA3_512_RSA_PKCS_PSS] = "CKM_SHA3_512_RSA_PKCS_PSS"; t[CKM_SHA512_224] = "CKM_SHA512_224"; t[CKM_SHA512_224_HMAC] = "CKM_SHA512_224_HMAC"; t[CKM_SHA512_224_HMAC_GENERAL] = "CKM_SHA512_224_HMAC_GENERAL"; @@ -262,8 +274,16 @@ void fill_CKM_table(std::map &t) t[CKM_SHA384_HMAC] = "CKM_SHA384_HMAC"; t[CKM_SHA384_HMAC_GENERAL] = "CKM_SHA384_HMAC_GENERAL"; t[CKM_SHA512] = "CKM_SHA512"; + t[CKM_SHA3_224] = "CKM_SHA3_224"; + t[CKM_SHA3_256] = "CKM_SHA3_256"; + t[CKM_SHA3_384] = "CKM_SHA3_384"; + t[CKM_SHA3_512] = "CKM_SHA3_512"; t[CKM_SHA512_HMAC] = "CKM_SHA512_HMAC"; t[CKM_SHA512_HMAC_GENERAL] = "CKM_SHA512_HMAC_GENERAL"; + t[CKM_SHA3_224_HMAC] = "CKM_SHA3_224_HMAC"; + t[CKM_SHA3_256_HMAC] = "CKM_SHA3_256_HMAC"; + t[CKM_SHA3_384_HMAC] = "CKM_SHA3_384_HMAC"; + t[CKM_SHA3_512_HMAC] = "CKM_SHA3_512_HMAC"; t[CKM_SECURID_KEY_GEN] = "CKM_SECURID_KEY_GEN"; t[CKM_SECURID] = "CKM_SECURID"; t[CKM_HOTP_KEY_GEN] = "CKM_HOTP_KEY_GEN"; @@ -413,6 +433,10 @@ void fill_CKM_table(std::map &t) t[CKM_ECDSA_SHA256] = "CKM_ECDSA_SHA256"; t[CKM_ECDSA_SHA384] = "CKM_ECDSA_SHA384"; t[CKM_ECDSA_SHA512] = "CKM_ECDSA_SHA512"; + t[CKM_ECDSA_SHA3_224] = "CKM_ECDSA_SHA3_224"; + t[CKM_ECDSA_SHA3_256] = "CKM_ECDSA_SHA3_256"; + t[CKM_ECDSA_SHA3_384] = "CKM_ECDSA_SHA3_384"; + t[CKM_ECDSA_SHA3_512] = "CKM_ECDSA_SHA3_512"; t[CKM_ECDH1_DERIVE] = "CKM_ECDH1_DERIVE"; t[CKM_ECDH1_COFACTOR_DERIVE] = "CKM_ECDH1_COFACTOR_DERIVE"; t[CKM_ECMQV_DERIVE] = "CKM_ECMQV_DERIVE"; diff --git a/src/lib/P11Attributes.cpp b/src/lib/P11Attributes.cpp index 29d0ac50a..e2fd8117f 100644 --- a/src/lib/P11Attributes.cpp +++ b/src/lib/P11Attributes.cpp @@ -873,6 +873,10 @@ CK_RV P11AttrCheckValue::updateAttr(Token *token, bool isPrivate, CK_VOID_PTR pV case CKK_SHA256_HMAC: case CKK_SHA384_HMAC: case CKK_SHA512_HMAC: + case CKK_SHA3_224_HMAC: + case CKK_SHA3_256_HMAC: + case CKK_SHA3_384_HMAC: + case CKK_SHA3_512_HMAC: key.setKeyBits(keybits); key.setBitLen(keybits.size() * 8); checkValue = key.getKeyCheckValue(); @@ -1031,6 +1035,10 @@ CK_RV P11AttrValue::updateAttr(Token *token, bool isPrivate, CK_VOID_PTR pValue, case CKK_SHA256_HMAC: case CKK_SHA384_HMAC: case CKK_SHA512_HMAC: + case CKK_SHA3_224_HMAC: + case CKK_SHA3_256_HMAC: + case CKK_SHA3_384_HMAC: + case CKK_SHA3_512_HMAC: key.setKeyBits(plaintext); key.setBitLen(plaintext.size() * 8); checkValue = key.getKeyCheckValue(); diff --git a/src/lib/SoftHSM.cpp b/src/lib/SoftHSM.cpp index e5cd0cab5..1f4fdf15a 100644 --- a/src/lib/SoftHSM.cpp +++ b/src/lib/SoftHSM.cpp @@ -197,7 +197,11 @@ static CK_RV newP11Object(CK_OBJECT_CLASS objClass, CK_KEY_TYPE keyType, CK_CERT (keyType == CKK_SHA224_HMAC) || (keyType == CKK_SHA256_HMAC) || (keyType == CKK_SHA384_HMAC) || - (keyType == CKK_SHA512_HMAC)) + (keyType == CKK_SHA512_HMAC) || + (keyType == CKK_SHA3_224_HMAC) || + (keyType == CKK_SHA3_256_HMAC) || + (keyType == CKK_SHA3_384_HMAC) || + (keyType == CKK_SHA3_512_HMAC)) { P11GenericSecretKeyObj* key = new P11GenericSecretKeyObj(); *p11object = key; @@ -771,6 +775,12 @@ void SoftHSM::prepareSupportedMechanisms(std::mapulMinKeySize = 0; pInfo->ulMaxKeySize = 0; @@ -1155,6 +1201,28 @@ CK_RV SoftHSM::C_GetMechanismInfo(CK_SLOT_ID slotID, CK_MECHANISM_TYPE type, CK_ pInfo->ulMaxKeySize = 512; pInfo->flags = CKF_SIGN | CKF_VERIFY; break; +#ifdef WITH_SHA3 + case CKM_SHA3_224_HMAC: + pInfo->ulMinKeySize = 28; + pInfo->ulMaxKeySize = 512; + pInfo->flags = CKF_SIGN | CKF_VERIFY; + break; + case CKM_SHA3_256_HMAC: + pInfo->ulMinKeySize = 32; + pInfo->ulMaxKeySize = 512; + pInfo->flags = CKF_SIGN | CKF_VERIFY; + break; + case CKM_SHA3_384_HMAC: + pInfo->ulMinKeySize = 48; + pInfo->ulMaxKeySize = 512; + pInfo->flags = CKF_SIGN | CKF_VERIFY; + break; + case CKM_SHA3_512_HMAC: + pInfo->ulMinKeySize = 64; + pInfo->ulMaxKeySize = 512; + pInfo->flags = CKF_SIGN | CKF_VERIFY; + break; +#endif case CKM_RSA_PKCS_KEY_PAIR_GEN: pInfo->ulMinKeySize = rsaMinSize; pInfo->ulMaxKeySize = rsaMaxSize; @@ -1178,6 +1246,12 @@ CK_RV SoftHSM::C_GetMechanismInfo(CK_SLOT_ID slotID, CK_MECHANISM_TYPE type, CK_ case CKM_SHA256_RSA_PKCS: case CKM_SHA384_RSA_PKCS: case CKM_SHA512_RSA_PKCS: +#ifdef WITH_SHA3 + case CKM_SHA3_224_RSA_PKCS: + case CKM_SHA3_256_RSA_PKCS: + case CKM_SHA3_384_RSA_PKCS: + case CKM_SHA3_512_RSA_PKCS: +#endif #ifdef WITH_RAW_PSS case CKM_RSA_PKCS_PSS: #endif @@ -1186,6 +1260,12 @@ CK_RV SoftHSM::C_GetMechanismInfo(CK_SLOT_ID slotID, CK_MECHANISM_TYPE type, CK_ case CKM_SHA256_RSA_PKCS_PSS: case CKM_SHA384_RSA_PKCS_PSS: case CKM_SHA512_RSA_PKCS_PSS: +#ifdef WITH_SHA3 + case CKM_SHA3_224_RSA_PKCS_PSS: + case CKM_SHA3_256_RSA_PKCS_PSS: + case CKM_SHA3_384_RSA_PKCS_PSS: + case CKM_SHA3_512_RSA_PKCS_PSS: +#endif pInfo->ulMinKeySize = rsaMinSize; pInfo->ulMaxKeySize = rsaMaxSize; pInfo->flags = CKF_SIGN | CKF_VERIFY; @@ -1309,6 +1389,12 @@ CK_RV SoftHSM::C_GetMechanismInfo(CK_SLOT_ID slotID, CK_MECHANISM_TYPE type, CK_ case CKM_DSA_SHA256: case CKM_DSA_SHA384: case CKM_DSA_SHA512: +#ifdef WITH_SHA3 + case CKM_DSA_SHA3_224: + case CKM_DSA_SHA3_256: + case CKM_DSA_SHA3_384: + case CKM_DSA_SHA3_512: +#endif pInfo->ulMinKeySize = dsaMinSize; pInfo->ulMaxKeySize = dsaMaxSize; pInfo->flags = CKF_SIGN | CKF_VERIFY; @@ -1341,6 +1427,12 @@ CK_RV SoftHSM::C_GetMechanismInfo(CK_SLOT_ID slotID, CK_MECHANISM_TYPE type, CK_ case CKM_ECDSA_SHA256: case CKM_ECDSA_SHA384: case CKM_ECDSA_SHA512: +#ifdef WITH_SHA3 + case CKM_ECDSA_SHA3_224: + case CKM_ECDSA_SHA3_256: + case CKM_ECDSA_SHA3_384: + case CKM_ECDSA_SHA3_512: +#endif pInfo->ulMinKeySize = ecdsaMinSize; pInfo->ulMaxKeySize = ecdsaMaxSize; pInfo->flags = CKF_SIGN | CKF_VERIFY | CKF_EC_COMMOM; @@ -3843,6 +3935,20 @@ CK_RV SoftHSM::C_DigestInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechan case CKM_SHA512: algo = HashAlgo::SHA512; break; +#ifdef WITH_SHA3 + case CKM_SHA3_224: + algo = HashAlgo::SHA3_224; + break; + case CKM_SHA3_256: + algo = HashAlgo::SHA3_256; + break; + case CKM_SHA3_384: + algo = HashAlgo::SHA3_384; + break; + case CKM_SHA3_512: + algo = HashAlgo::SHA3_512; + break; +#endif #ifdef WITH_GOST case CKM_GOSTR3411: algo = HashAlgo::GOST; @@ -4096,6 +4202,12 @@ static bool isMacMechanism(CK_MECHANISM_PTR pMechanism) case CKM_SHA256_HMAC: case CKM_SHA384_HMAC: case CKM_SHA512_HMAC: +#ifdef WITH_SHA3 + case CKM_SHA3_224_HMAC: + case CKM_SHA3_256_HMAC: + case CKM_SHA3_384_HMAC: + case CKM_SHA3_512_HMAC: +#endif #ifdef WITH_GOST case CKM_GOSTR3411_HMAC: #endif @@ -4197,6 +4309,32 @@ CK_RV SoftHSM::MacSignInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechani minSize = 64; algo = MacAlgo::HMAC_SHA512; break; +#ifdef WITH_SHA3 + case CKM_SHA3_224_HMAC: + if (keyType != CKK_GENERIC_SECRET && keyType != CKK_SHA3_224_HMAC) + return CKR_KEY_TYPE_INCONSISTENT; + minSize = 28; + algo = MacAlgo::HMAC_SHA3_224; + break; + case CKM_SHA3_256_HMAC: + if (keyType != CKK_GENERIC_SECRET && keyType != CKK_SHA3_256_HMAC) + return CKR_KEY_TYPE_INCONSISTENT; + minSize = 32; + algo = MacAlgo::HMAC_SHA3_256; + break; + case CKM_SHA3_384_HMAC: + if (keyType != CKK_GENERIC_SECRET && keyType != CKK_SHA3_384_HMAC) + return CKR_KEY_TYPE_INCONSISTENT; + minSize = 48; + algo = MacAlgo::HMAC_SHA3_384; + break; + case CKM_SHA3_512_HMAC: + if (keyType != CKK_GENERIC_SECRET && keyType != CKK_SHA3_512_HMAC) + return CKR_KEY_TYPE_INCONSISTENT; + minSize = 64; + algo = MacAlgo::HMAC_SHA3_512; + break; +#endif #ifdef WITH_GOST case CKM_GOSTR3411_HMAC: if (keyType != CKK_GENERIC_SECRET && keyType != CKK_GOST28147) @@ -4368,6 +4506,28 @@ CK_RV SoftHSM::AsymSignInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechan bAllowMultiPartOp = true; isRSA = true; break; +#ifdef WITH_SHA3 + case CKM_SHA3_224_RSA_PKCS: + mechanism = AsymMech::RSA_SHA3_224_PKCS; + bAllowMultiPartOp = true; + isRSA = true; + break; + case CKM_SHA3_256_RSA_PKCS: + mechanism = AsymMech::RSA_SHA3_256_PKCS; + bAllowMultiPartOp = true; + isRSA = true; + break; + case CKM_SHA3_384_RSA_PKCS: + mechanism = AsymMech::RSA_SHA3_384_PKCS; + bAllowMultiPartOp = true; + isRSA = true; + break; + case CKM_SHA3_512_RSA_PKCS: + mechanism = AsymMech::RSA_SHA3_512_PKCS; + bAllowMultiPartOp = true; + isRSA = true; + break; +#endif #ifdef WITH_RAW_PSS case CKM_RSA_PKCS_PSS: if (pMechanism->pParameter == NULL_PTR || @@ -4405,6 +4565,28 @@ CK_RV SoftHSM::AsymSignInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechan rsaPssParam.mgfAlg = AsymRSAMGF::MGF1_SHA512; allowedMgf = CKG_MGF1_SHA512; break; +#ifdef WITH_SHA3 + case CKM_SHA3_224: + rsaPssParam.hashAlg = HashAlgo::SHA3_224; + rsaPssParam.mgfAlg = AsymRSAMGF::MGF1_SHA3_224; + allowedMgf = CKG_MGF1_SHA3_224; + break; + case CKM_SHA3_256: + rsaPssParam.hashAlg = HashAlgo::SHA3_256; + rsaPssParam.mgfAlg = AsymRSAMGF::MGF1_SHA3_256; + allowedMgf = CKG_MGF1_SHA3_256; + break; + case CKM_SHA3_384: + rsaPssParam.hashAlg = HashAlgo::SHA3_384; + rsaPssParam.mgfAlg = AsymRSAMGF::MGF1_SHA3_384; + allowedMgf = CKG_MGF1_SHA3_384; + break; + case CKM_SHA3_512: + rsaPssParam.hashAlg = HashAlgo::SHA3_512; + rsaPssParam.mgfAlg = AsymRSAMGF::MGF1_SHA3_512; + allowedMgf = CKG_MGF1_SHA3_512; + break; +#endif default: ERROR_MSG("Invalid RSA-PSS hash"); return CKR_ARGUMENTS_BAD; @@ -4506,6 +4688,76 @@ CK_RV SoftHSM::AsymSignInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechan bAllowMultiPartOp = true; isRSA = true; break; +#ifdef WITH_SHA3 + case CKM_SHA3_224_RSA_PKCS_PSS: + if (pMechanism->pParameter == NULL_PTR || + pMechanism->ulParameterLen != sizeof(CK_RSA_PKCS_PSS_PARAMS) || + CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->hashAlg != CKM_SHA3_224 || + CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->mgf != CKG_MGF1_SHA3_224) + { + ERROR_MSG("Invalid parameters"); + return CKR_ARGUMENTS_BAD; + } + mechanism = AsymMech::RSA_SHA3_224_PKCS_PSS; + rsaPssParam.hashAlg = HashAlgo::SHA3_224; + rsaPssParam.mgfAlg = AsymRSAMGF::MGF1_SHA3_224; + rsaPssParam.sLen = CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->sLen; + mechanismParam = &rsaPssParam; + bAllowMultiPartOp = true; + isRSA = true; + break; + case CKM_SHA3_256_RSA_PKCS_PSS: + if (pMechanism->pParameter == NULL_PTR || + pMechanism->ulParameterLen != sizeof(CK_RSA_PKCS_PSS_PARAMS) || + CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->hashAlg != CKM_SHA3_256 || + CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->mgf != CKG_MGF1_SHA3_256) + { + ERROR_MSG("Invalid parameters"); + return CKR_ARGUMENTS_BAD; + } + mechanism = AsymMech::RSA_SHA3_256_PKCS_PSS; + rsaPssParam.hashAlg = HashAlgo::SHA3_256; + rsaPssParam.mgfAlg = AsymRSAMGF::MGF1_SHA3_256; + rsaPssParam.sLen = CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->sLen; + mechanismParam = &rsaPssParam; + bAllowMultiPartOp = true; + isRSA = true; + break; + case CKM_SHA3_384_RSA_PKCS_PSS: + if (pMechanism->pParameter == NULL_PTR || + pMechanism->ulParameterLen != sizeof(CK_RSA_PKCS_PSS_PARAMS) || + CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->hashAlg != CKM_SHA3_384 || + CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->mgf != CKG_MGF1_SHA3_384) + { + ERROR_MSG("Invalid parameters"); + return CKR_ARGUMENTS_BAD; + } + mechanism = AsymMech::RSA_SHA3_384_PKCS_PSS; + rsaPssParam.hashAlg = HashAlgo::SHA3_384; + rsaPssParam.mgfAlg = AsymRSAMGF::MGF1_SHA3_384; + rsaPssParam.sLen = CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->sLen; + mechanismParam = &rsaPssParam; + bAllowMultiPartOp = true; + isRSA = true; + break; + case CKM_SHA3_512_RSA_PKCS_PSS: + if (pMechanism->pParameter == NULL_PTR || + pMechanism->ulParameterLen != sizeof(CK_RSA_PKCS_PSS_PARAMS) || + CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->hashAlg != CKM_SHA3_512 || + CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->mgf != CKG_MGF1_SHA3_512) + { + ERROR_MSG("Invalid parameters"); + return CKR_ARGUMENTS_BAD; + } + mechanism = AsymMech::RSA_SHA3_512_PKCS_PSS; + rsaPssParam.hashAlg = HashAlgo::SHA3_512; + rsaPssParam.mgfAlg = AsymRSAMGF::MGF1_SHA3_512; + rsaPssParam.sLen = CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->sLen; + mechanismParam = &rsaPssParam; + bAllowMultiPartOp = true; + isRSA = true; + break; +#endif case CKM_DSA: mechanism = AsymMech::DSA; bAllowMultiPartOp = false; @@ -4536,6 +4788,28 @@ CK_RV SoftHSM::AsymSignInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechan bAllowMultiPartOp = true; isDSA = true; break; +#ifdef WITH_SHA3 + case CKM_DSA_SHA3_224: + mechanism = AsymMech::DSA_SHA3_224; + bAllowMultiPartOp = true; + isDSA = true; + break; + case CKM_DSA_SHA3_256: + mechanism = AsymMech::DSA_SHA3_256; + bAllowMultiPartOp = true; + isDSA = true; + break; + case CKM_DSA_SHA3_384: + mechanism = AsymMech::DSA_SHA3_384; + bAllowMultiPartOp = true; + isDSA = true; + break; + case CKM_DSA_SHA3_512: + mechanism = AsymMech::DSA_SHA3_512; + bAllowMultiPartOp = true; + isDSA = true; + break; +#endif #ifdef WITH_ECC case CKM_ECDSA: mechanism = AsymMech::ECDSA; @@ -4567,6 +4841,28 @@ CK_RV SoftHSM::AsymSignInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechan bAllowMultiPartOp = true; isECDSA = true; break; +#ifdef WITH_SHA3 + case CKM_ECDSA_SHA3_224: + mechanism = AsymMech::ECDSA_SHA3_224; + bAllowMultiPartOp = true; + isECDSA = true; + break; + case CKM_ECDSA_SHA3_256: + mechanism = AsymMech::ECDSA_SHA3_256; + bAllowMultiPartOp = true; + isECDSA = true; + break; + case CKM_ECDSA_SHA3_384: + mechanism = AsymMech::ECDSA_SHA3_384; + bAllowMultiPartOp = true; + isECDSA = true; + break; + case CKM_ECDSA_SHA3_512: + mechanism = AsymMech::ECDSA_SHA3_512; + bAllowMultiPartOp = true; + isECDSA = true; + break; +#endif #endif #ifdef WITH_GOST case CKM_GOSTR3410: @@ -5287,6 +5583,32 @@ CK_RV SoftHSM::MacVerifyInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMecha minSize = 64; algo = MacAlgo::HMAC_SHA512; break; +#ifdef WITH_SHA3 + case CKM_SHA3_224_HMAC: + if (keyType != CKK_GENERIC_SECRET && keyType != CKK_SHA3_224_HMAC) + return CKR_KEY_TYPE_INCONSISTENT; + minSize = 28; + algo = MacAlgo::HMAC_SHA3_224; + break; + case CKM_SHA3_256_HMAC: + if (keyType != CKK_GENERIC_SECRET && keyType != CKK_SHA3_256_HMAC) + return CKR_KEY_TYPE_INCONSISTENT; + minSize = 32; + algo = MacAlgo::HMAC_SHA3_256; + break; + case CKM_SHA3_384_HMAC: + if (keyType != CKK_GENERIC_SECRET && keyType != CKK_SHA3_384_HMAC) + return CKR_KEY_TYPE_INCONSISTENT; + minSize = 48; + algo = MacAlgo::HMAC_SHA3_384; + break; + case CKM_SHA3_512_HMAC: + if (keyType != CKK_GENERIC_SECRET && keyType != CKK_SHA3_512_HMAC) + return CKR_KEY_TYPE_INCONSISTENT; + minSize = 64; + algo = MacAlgo::HMAC_SHA3_512; + break; +#endif #ifdef WITH_GOST case CKM_GOSTR3411_HMAC: if (keyType != CKK_GENERIC_SECRET && keyType != CKK_GOST28147) @@ -5458,6 +5780,28 @@ CK_RV SoftHSM::AsymVerifyInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMech bAllowMultiPartOp = true; isRSA = true; break; +#ifdef WITH_SHA3 + case CKM_SHA3_224_RSA_PKCS: + mechanism = AsymMech::RSA_SHA3_224_PKCS; + bAllowMultiPartOp = true; + isRSA = true; + break; + case CKM_SHA3_256_RSA_PKCS: + mechanism = AsymMech::RSA_SHA3_256_PKCS; + bAllowMultiPartOp = true; + isRSA = true; + break; + case CKM_SHA3_384_RSA_PKCS: + mechanism = AsymMech::RSA_SHA3_384_PKCS; + bAllowMultiPartOp = true; + isRSA = true; + break; + case CKM_SHA3_512_RSA_PKCS: + mechanism = AsymMech::RSA_SHA3_512_PKCS; + bAllowMultiPartOp = true; + isRSA = true; + break; +#endif #ifdef WITH_RAW_PSS case CKM_RSA_PKCS_PSS: if (pMechanism->pParameter == NULL_PTR || @@ -5495,6 +5839,28 @@ CK_RV SoftHSM::AsymVerifyInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMech rsaPssParam.mgfAlg = AsymRSAMGF::MGF1_SHA512; expectedMgf = CKG_MGF1_SHA512; break; +#ifdef WITH_SHA3 + case CKM_SHA3_224: + rsaPssParam.hashAlg = HashAlgo::SHA3_224; + rsaPssParam.mgfAlg = AsymRSAMGF::MGF1_SHA3_224; + expectedMgf = CKG_MGF1_SHA3_224; + break; + case CKM_SHA3_256: + rsaPssParam.hashAlg = HashAlgo::SHA3_256; + rsaPssParam.mgfAlg = AsymRSAMGF::MGF1_SHA3_256; + expectedMgf = CKG_MGF1_SHA3_256; + break; + case CKM_SHA3_384: + rsaPssParam.hashAlg = HashAlgo::SHA3_384; + rsaPssParam.mgfAlg = AsymRSAMGF::MGF1_SHA3_384; + expectedMgf = CKG_MGF1_SHA3_384; + break; + case CKM_SHA3_512: + rsaPssParam.hashAlg = HashAlgo::SHA3_512; + rsaPssParam.mgfAlg = AsymRSAMGF::MGF1_SHA3_512; + expectedMgf = CKG_MGF1_SHA3_512; + break; +#endif default: return CKR_ARGUMENTS_BAD; } @@ -5595,6 +5961,76 @@ CK_RV SoftHSM::AsymVerifyInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMech bAllowMultiPartOp = true; isRSA = true; break; +#ifdef WITH_SHA3 + case CKM_SHA3_224_RSA_PKCS_PSS: + if (pMechanism->pParameter == NULL_PTR || + pMechanism->ulParameterLen != sizeof(CK_RSA_PKCS_PSS_PARAMS) || + CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->hashAlg != CKM_SHA3_224 || + CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->mgf != CKG_MGF1_SHA3_224) + { + ERROR_MSG("Invalid parameters"); + return CKR_ARGUMENTS_BAD; + } + mechanism = AsymMech::RSA_SHA3_224_PKCS_PSS; + rsaPssParam.hashAlg = HashAlgo::SHA3_224; + rsaPssParam.mgfAlg = AsymRSAMGF::MGF1_SHA3_224; + rsaPssParam.sLen = CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->sLen; + mechanismParam = &rsaPssParam; + bAllowMultiPartOp = true; + isRSA = true; + break; + case CKM_SHA3_256_RSA_PKCS_PSS: + if (pMechanism->pParameter == NULL_PTR || + pMechanism->ulParameterLen != sizeof(CK_RSA_PKCS_PSS_PARAMS) || + CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->hashAlg != CKM_SHA3_256 || + CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->mgf != CKG_MGF1_SHA3_256) + { + ERROR_MSG("Invalid parameters"); + return CKR_ARGUMENTS_BAD; + } + mechanism = AsymMech::RSA_SHA3_256_PKCS_PSS; + rsaPssParam.hashAlg = HashAlgo::SHA3_256; + rsaPssParam.mgfAlg = AsymRSAMGF::MGF1_SHA3_256; + rsaPssParam.sLen = CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->sLen; + mechanismParam = &rsaPssParam; + bAllowMultiPartOp = true; + isRSA = true; + break; + case CKM_SHA3_384_RSA_PKCS_PSS: + if (pMechanism->pParameter == NULL_PTR || + pMechanism->ulParameterLen != sizeof(CK_RSA_PKCS_PSS_PARAMS) || + CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->hashAlg != CKM_SHA3_384 || + CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->mgf != CKG_MGF1_SHA3_384) + { + ERROR_MSG("Invalid parameters"); + return CKR_ARGUMENTS_BAD; + } + mechanism = AsymMech::RSA_SHA3_384_PKCS_PSS; + rsaPssParam.hashAlg = HashAlgo::SHA3_384; + rsaPssParam.mgfAlg = AsymRSAMGF::MGF1_SHA3_384; + rsaPssParam.sLen = CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->sLen; + mechanismParam = &rsaPssParam; + bAllowMultiPartOp = true; + isRSA = true; + break; + case CKM_SHA3_512_RSA_PKCS_PSS: + if (pMechanism->pParameter == NULL_PTR || + pMechanism->ulParameterLen != sizeof(CK_RSA_PKCS_PSS_PARAMS) || + CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->hashAlg != CKM_SHA3_512 || + CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->mgf != CKG_MGF1_SHA3_512) + { + ERROR_MSG("Invalid parameters"); + return CKR_ARGUMENTS_BAD; + } + mechanism = AsymMech::RSA_SHA3_512_PKCS_PSS; + rsaPssParam.hashAlg = HashAlgo::SHA3_512; + rsaPssParam.mgfAlg = AsymRSAMGF::MGF1_SHA3_512; + rsaPssParam.sLen = CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->sLen; + mechanismParam = &rsaPssParam; + bAllowMultiPartOp = true; + isRSA = true; + break; +#endif case CKM_DSA: mechanism = AsymMech::DSA; bAllowMultiPartOp = false; @@ -5625,6 +6061,28 @@ CK_RV SoftHSM::AsymVerifyInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMech bAllowMultiPartOp = true; isDSA = true; break; +#ifdef WITH_SHA3 + case CKM_DSA_SHA3_224: + mechanism = AsymMech::DSA_SHA3_224; + bAllowMultiPartOp = true; + isDSA = true; + break; + case CKM_DSA_SHA3_256: + mechanism = AsymMech::DSA_SHA3_256; + bAllowMultiPartOp = true; + isDSA = true; + break; + case CKM_DSA_SHA3_384: + mechanism = AsymMech::DSA_SHA3_384; + bAllowMultiPartOp = true; + isDSA = true; + break; + case CKM_DSA_SHA3_512: + mechanism = AsymMech::DSA_SHA3_512; + bAllowMultiPartOp = true; + isDSA = true; + break; +#endif #ifdef WITH_ECC case CKM_ECDSA: mechanism = AsymMech::ECDSA; @@ -5656,6 +6114,28 @@ CK_RV SoftHSM::AsymVerifyInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMech bAllowMultiPartOp = true; isECDSA = true; break; +#ifdef WITH_SHA3 + case CKM_ECDSA_SHA3_224: + mechanism = AsymMech::ECDSA_SHA3_224; + bAllowMultiPartOp = true; + isECDSA = true; + break; + case CKM_ECDSA_SHA3_256: + mechanism = AsymMech::ECDSA_SHA3_256; + bAllowMultiPartOp = true; + isECDSA = true; + break; + case CKM_ECDSA_SHA3_384: + mechanism = AsymMech::ECDSA_SHA3_384; + bAllowMultiPartOp = true; + isECDSA = true; + break; + case CKM_ECDSA_SHA3_512: + mechanism = AsymMech::ECDSA_SHA3_512; + bAllowMultiPartOp = true; + isECDSA = true; + break; +#endif #endif #ifdef WITH_GOST case CKM_GOSTR3410: @@ -14908,6 +15388,24 @@ CK_RV SoftHSM::BuildRSAOAEPParam(const CK_RSA_PKCS_OAEP_PARAMS *params, mechanismParam->hashAlg = HashAlgo::SHA512; if (hashLen) *hashLen = 64; break; +#ifdef WITH_SHA3 + case CKM_SHA3_224: + mechanismParam->hashAlg = HashAlgo::SHA3_224; + if (hashLen) *hashLen = 28; + break; + case CKM_SHA3_256: + mechanismParam->hashAlg = HashAlgo::SHA3_256; + if (hashLen) *hashLen = 32; + break; + case CKM_SHA3_384: + mechanismParam->hashAlg = HashAlgo::SHA3_384; + if (hashLen) *hashLen = 48; + break; + case CKM_SHA3_512: + mechanismParam->hashAlg = HashAlgo::SHA3_512; + if (hashLen) *hashLen = 64; + break; +#endif default: ERROR_MSG("hash algorithm not supported for OAEP"); return CKR_ARGUMENTS_BAD; @@ -14929,6 +15427,20 @@ CK_RV SoftHSM::BuildRSAOAEPParam(const CK_RSA_PKCS_OAEP_PARAMS *params, case CKG_MGF1_SHA512: mechanismParam->mgfAlg = AsymRSAMGF::MGF1_SHA512; break; +#ifdef WITH_SHA3 + case CKG_MGF1_SHA3_224: + mechanismParam->mgfAlg = AsymRSAMGF::MGF1_SHA3_224; + break; + case CKG_MGF1_SHA3_256: + mechanismParam->mgfAlg = AsymRSAMGF::MGF1_SHA3_256; + break; + case CKG_MGF1_SHA3_384: + mechanismParam->mgfAlg = AsymRSAMGF::MGF1_SHA3_384; + break; + case CKG_MGF1_SHA3_512: + mechanismParam->mgfAlg = AsymRSAMGF::MGF1_SHA3_512; + break; +#endif default: ERROR_MSG("mgf algorithm not supported for OAEP"); return CKR_ARGUMENTS_BAD; diff --git a/src/lib/crypto/AsymmetricAlgorithm.h b/src/lib/crypto/AsymmetricAlgorithm.h index bed410b28..81303a45f 100644 --- a/src/lib/crypto/AsymmetricAlgorithm.h +++ b/src/lib/crypto/AsymmetricAlgorithm.h @@ -77,12 +77,20 @@ struct AsymMech RSA_SHA256_PKCS, RSA_SHA384_PKCS, RSA_SHA512_PKCS, + RSA_SHA3_224_PKCS, + RSA_SHA3_256_PKCS, + RSA_SHA3_384_PKCS, + RSA_SHA3_512_PKCS, RSA_PKCS_PSS, RSA_SHA1_PKCS_PSS, RSA_SHA224_PKCS_PSS, RSA_SHA256_PKCS_PSS, RSA_SHA384_PKCS_PSS, RSA_SHA512_PKCS_PSS, + RSA_SHA3_224_PKCS_PSS, + RSA_SHA3_256_PKCS_PSS, + RSA_SHA3_384_PKCS_PSS, + RSA_SHA3_512_PKCS_PSS, RSA_SSL, DSA, DSA_SHA1, @@ -90,12 +98,20 @@ struct AsymMech DSA_SHA256, DSA_SHA384, DSA_SHA512, + DSA_SHA3_224, + DSA_SHA3_256, + DSA_SHA3_384, + DSA_SHA3_512, ECDSA, ECDSA_SHA1, ECDSA_SHA224, ECDSA_SHA256, ECDSA_SHA384, ECDSA_SHA512, + ECDSA_SHA3_224, + ECDSA_SHA3_256, + ECDSA_SHA3_384, + ECDSA_SHA3_512, GOST, GOST_GOST, EDDSA, @@ -113,7 +129,11 @@ struct AsymRSAMGF MGF1_SHA224, MGF1_SHA256, MGF1_SHA384, - MGF1_SHA512 + MGF1_SHA512, + MGF1_SHA3_224, + MGF1_SHA3_256, + MGF1_SHA3_384, + MGF1_SHA3_512 }; }; diff --git a/src/lib/crypto/BotanCryptoFactory.cpp b/src/lib/crypto/BotanCryptoFactory.cpp index 4ad743df8..fbe1dfce3 100644 --- a/src/lib/crypto/BotanCryptoFactory.cpp +++ b/src/lib/crypto/BotanCryptoFactory.cpp @@ -48,6 +48,12 @@ #include "BotanSHA256.h" #include "BotanSHA384.h" #include "BotanSHA512.h" +#ifdef WITH_SHA3 +#include "BotanSHA3_224.h" +#include "BotanSHA3_256.h" +#include "BotanSHA3_384.h" +#include "BotanSHA3_512.h" +#endif #ifdef WITH_GOST #include "BotanGOST.h" #include "BotanGOSTR3411.h" @@ -177,6 +183,16 @@ HashAlgorithm* BotanCryptoFactory::getHashAlgorithm(HashAlgo::Type algorithm) return new BotanSHA384(); case HashAlgo::SHA512: return new BotanSHA512(); +#ifdef WITH_SHA3 + case HashAlgo::SHA3_224: + return new BotanSHA3_224(); + case HashAlgo::SHA3_256: + return new BotanSHA3_256(); + case HashAlgo::SHA3_384: + return new BotanSHA3_384(); + case HashAlgo::SHA3_512: + return new BotanSHA3_512(); +#endif #ifdef WITH_GOST case HashAlgo::GOST: return new BotanGOSTR3411(); @@ -209,6 +225,16 @@ MacAlgorithm* BotanCryptoFactory::getMacAlgorithm(MacAlgo::Type algorithm) return new BotanHMACSHA384(); case MacAlgo::HMAC_SHA512: return new BotanHMACSHA512(); +#ifdef WITH_SHA3 + case MacAlgo::HMAC_SHA3_224: + return new BotanHMACSHA3_224(); + case MacAlgo::HMAC_SHA3_256: + return new BotanHMACSHA3_256(); + case MacAlgo::HMAC_SHA3_384: + return new BotanHMACSHA3_384(); + case MacAlgo::HMAC_SHA3_512: + return new BotanHMACSHA3_512(); +#endif #ifdef WITH_GOST case MacAlgo::HMAC_GOST: return new BotanHMACGOSTR3411(); diff --git a/src/lib/crypto/BotanDSA.cpp b/src/lib/crypto/BotanDSA.cpp index b390c2216..545b235b2 100644 --- a/src/lib/crypto/BotanDSA.cpp +++ b/src/lib/crypto/BotanDSA.cpp @@ -170,6 +170,18 @@ bool BotanDSA::signInit(PrivateKey* privateKey, const AsymMech::Type mechanism, case AsymMech::DSA_SHA512: emsa = "EMSA1(SHA-512)"; break; + case AsymMech::DSA_SHA3_224: + emsa = "EMSA1(SHA-3(224))"; + break; + case AsymMech::DSA_SHA3_256: + emsa = "EMSA1(SHA-3(256))"; + break; + case AsymMech::DSA_SHA3_384: + emsa = "EMSA1(SHA-3(384))"; + break; + case AsymMech::DSA_SHA3_512: + emsa = "EMSA1(SHA-3(512))"; + break; default: ERROR_MSG("Invalid mechanism supplied (%i)", mechanism); @@ -384,6 +396,18 @@ bool BotanDSA::verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, case AsymMech::DSA_SHA512: emsa = "EMSA1(SHA-512)"; break; + case AsymMech::DSA_SHA3_224: + emsa = "EMSA1(SHA-3(224))"; + break; + case AsymMech::DSA_SHA3_256: + emsa = "EMSA1(SHA-3(256))"; + break; + case AsymMech::DSA_SHA3_384: + emsa = "EMSA1(SHA-3(384))"; + break; + case AsymMech::DSA_SHA3_512: + emsa = "EMSA1(SHA-3(512))"; + break; default: ERROR_MSG("Invalid mechanism supplied (%i)", mechanism); diff --git a/src/lib/crypto/BotanECDSA.cpp b/src/lib/crypto/BotanECDSA.cpp index e6651e792..08628a9d0 100644 --- a/src/lib/crypto/BotanECDSA.cpp +++ b/src/lib/crypto/BotanECDSA.cpp @@ -93,6 +93,18 @@ bool BotanECDSA::sign(PrivateKey* privateKey, const ByteString& dataToSign, case AsymMech::ECDSA_SHA512: hash = HashAlgo::SHA512; break; + case AsymMech::ECDSA_SHA3_224: + hash = HashAlgo::SHA3_224; + break; + case AsymMech::ECDSA_SHA3_256: + hash = HashAlgo::SHA3_256; + break; + case AsymMech::ECDSA_SHA3_384: + hash = HashAlgo::SHA3_384; + break; + case AsymMech::ECDSA_SHA3_512: + hash = HashAlgo::SHA3_512; + break; default: ERROR_MSG("Invalid mechanism supplied (%i)", mechanism); return false; @@ -213,6 +225,18 @@ bool BotanECDSA::signInit(PrivateKey* privateKey, const AsymMech::Type mechanism case AsymMech::ECDSA_SHA512: hash = HashAlgo::SHA512; break; + case AsymMech::ECDSA_SHA3_224: + hash = HashAlgo::SHA3_224; + break; + case AsymMech::ECDSA_SHA3_256: + hash = HashAlgo::SHA3_256; + break; + case AsymMech::ECDSA_SHA3_384: + hash = HashAlgo::SHA3_384; + break; + case AsymMech::ECDSA_SHA3_512: + hash = HashAlgo::SHA3_512; + break; default: ERROR_MSG("Invalid mechanism supplied (%i)", mechanism); @@ -360,6 +384,18 @@ bool BotanECDSA::verify(PublicKey* publicKey, const ByteString& originalData, case AsymMech::ECDSA_SHA512: hash = HashAlgo::SHA512; break; + case AsymMech::ECDSA_SHA3_224: + hash = HashAlgo::SHA3_224; + break; + case AsymMech::ECDSA_SHA3_256: + hash = HashAlgo::SHA3_256; + break; + case AsymMech::ECDSA_SHA3_384: + hash = HashAlgo::SHA3_384; + break; + case AsymMech::ECDSA_SHA3_512: + hash = HashAlgo::SHA3_512; + break; default: ERROR_MSG("Invalid mechanism supplied (%i)", mechanism); return false; @@ -477,6 +513,18 @@ bool BotanECDSA::verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism case AsymMech::ECDSA_SHA512: hash = HashAlgo::SHA512; break; + case AsymMech::ECDSA_SHA3_224: + hash = HashAlgo::SHA3_224; + break; + case AsymMech::ECDSA_SHA3_256: + hash = HashAlgo::SHA3_256; + break; + case AsymMech::ECDSA_SHA3_384: + hash = HashAlgo::SHA3_384; + break; + case AsymMech::ECDSA_SHA3_512: + hash = HashAlgo::SHA3_512; + break; default: ERROR_MSG("Invalid mechanism supplied (%i)", mechanism); diff --git a/src/lib/crypto/BotanMAC.cpp b/src/lib/crypto/BotanMAC.cpp index b45f127f0..246819c86 100644 --- a/src/lib/crypto/BotanMAC.cpp +++ b/src/lib/crypto/BotanMAC.cpp @@ -93,6 +93,48 @@ size_t BotanHMACSHA512::getMacSize() const return 64; } +#ifdef WITH_SHA3 +std::string BotanHMACSHA3_224::getAlgorithm() const +{ + return "HMAC(SHA-3(224))"; +} + +size_t BotanHMACSHA3_224::getMacSize() const +{ + return 28; +} + +std::string BotanHMACSHA3_256::getAlgorithm() const +{ + return "HMAC(SHA-3(256))"; +} + +size_t BotanHMACSHA3_256::getMacSize() const +{ + return 32; +} + +std::string BotanHMACSHA3_384::getAlgorithm() const +{ + return "HMAC(SHA-3(384))"; +} + +size_t BotanHMACSHA3_384::getMacSize() const +{ + return 48; +} + +std::string BotanHMACSHA3_512::getAlgorithm() const +{ + return "HMAC(SHA-3(512))"; +} + +size_t BotanHMACSHA3_512::getMacSize() const +{ + return 64; +} +#endif + #ifdef WITH_GOST std::string BotanHMACGOSTR3411::getAlgorithm() const { diff --git a/src/lib/crypto/BotanMAC.h b/src/lib/crypto/BotanMAC.h index 9f7151782..8e72f1719 100644 --- a/src/lib/crypto/BotanMAC.h +++ b/src/lib/crypto/BotanMAC.h @@ -79,6 +79,34 @@ class BotanHMACSHA512 : public BotanMacAlgorithm virtual size_t getMacSize() const; }; +class BotanHMACSHA3_224 : public BotanMacAlgorithm +{ +protected: + virtual std::string getAlgorithm() const; + virtual size_t getMacSize() const; +}; + +class BotanHMACSHA3_256 : public BotanMacAlgorithm +{ +protected: + virtual std::string getAlgorithm() const; + virtual size_t getMacSize() const; +}; + +class BotanHMACSHA3_384 : public BotanMacAlgorithm +{ +protected: + virtual std::string getAlgorithm() const; + virtual size_t getMacSize() const; +}; + +class BotanHMACSHA3_512 : public BotanMacAlgorithm +{ +protected: + virtual std::string getAlgorithm() const; + virtual size_t getMacSize() const; +}; + #ifdef WITH_GOST class BotanHMACGOSTR3411 : public BotanMacAlgorithm { diff --git a/src/lib/crypto/BotanRSA.cpp b/src/lib/crypto/BotanRSA.cpp index b826fc5ee..3ce1ad9e5 100644 --- a/src/lib/crypto/BotanRSA.cpp +++ b/src/lib/crypto/BotanRSA.cpp @@ -38,6 +38,7 @@ #include "BotanCryptoFactory.h" #include "RSAParameters.h" #include "RSAMechanismParam.h" +#include "RSAUtil.h" #include "BotanRSAKeyPair.h" #include #include @@ -166,7 +167,6 @@ bool BotanRSA::signInit(PrivateKey* privateKey, const AsymMech::Type mechanism, std::string emsa; std::ostringstream request; size_t sLen; - const RSAPssMechanismParam* pssParam = NULL; switch (mechanism) { @@ -188,28 +188,21 @@ bool BotanRSA::signInit(PrivateKey* privateKey, const AsymMech::Type mechanism, case AsymMech::RSA_SHA512_PKCS: emsa = "EMSA3(SHA-512)"; break; + case AsymMech::RSA_SHA3_224_PKCS: + emsa = "EMSA3(SHA-3(224))"; + break; + case AsymMech::RSA_SHA3_256_PKCS: + emsa = "EMSA3(SHA-3(256))"; + break; + case AsymMech::RSA_SHA3_384_PKCS: + emsa = "EMSA3(SHA-3(384))"; + break; + case AsymMech::RSA_SHA3_512_PKCS: + emsa = "EMSA3(SHA-3(512))"; + break; case AsymMech::RSA_SHA1_PKCS_PSS: - if ((mechanismParam == NULL) || (!mechanismParam->isOfType(RSAPssMechanismParam::type))) + if (!RSAUtil::checkPssParams(mechanismParam, HashAlgo::SHA1, AsymRSAMGF::MGF1_SHA1, 20, privateKey->getBitLength(), sLen)) { - ERROR_MSG("Invalid RSA PSS mechanism parameter type supplied"); - ByteString dummy; - AsymmetricAlgorithm::signFinal(dummy); - return false; - } - pssParam = dynamic_cast(mechanismParam); - if ((pssParam->hashAlg != HashAlgo::SHA1)|| - (pssParam->mgfAlg != AsymRSAMGF::MGF1_SHA1)) - { - ERROR_MSG("Invalid RSA PSS mechanism parameters supplied"); - ByteString dummy; - AsymmetricAlgorithm::signFinal(dummy); - return false; - } - sLen = pssParam->sLen; - if (sLen > ((privateKey->getBitLength()+6)/8-2-20)) - { - ERROR_MSG("sLen (%lu) is too large for current key size (%lu)", - (unsigned long)sLen, privateKey->getBitLength()); ByteString dummy; AsymmetricAlgorithm::signFinal(dummy); return false; @@ -218,27 +211,8 @@ bool BotanRSA::signInit(PrivateKey* privateKey, const AsymMech::Type mechanism, emsa = request.str(); break; case AsymMech::RSA_SHA224_PKCS_PSS: - if ((mechanismParam == NULL) || (!mechanismParam->isOfType(RSAPssMechanismParam::type))) + if (!RSAUtil::checkPssParams(mechanismParam, HashAlgo::SHA224, AsymRSAMGF::MGF1_SHA224, 28, privateKey->getBitLength(), sLen)) { - ERROR_MSG("Invalid RSA PSS mechanism parameter type supplied"); - ByteString dummy; - AsymmetricAlgorithm::signFinal(dummy); - return false; - } - pssParam = dynamic_cast(mechanismParam); - if ((pssParam->hashAlg != HashAlgo::SHA224)|| - (pssParam->mgfAlg != AsymRSAMGF::MGF1_SHA224)) - { - ERROR_MSG("Invalid RSA PSS mechanism parameters supplied"); - ByteString dummy; - AsymmetricAlgorithm::signFinal(dummy); - return false; - } - sLen = pssParam->sLen; - if (sLen > ((privateKey->getBitLength()+6)/8-2-28)) - { - ERROR_MSG("sLen (%lu) is too large for current key size (%lu)", - (unsigned long)sLen, privateKey->getBitLength()); ByteString dummy; AsymmetricAlgorithm::signFinal(dummy); return false; @@ -247,27 +221,8 @@ bool BotanRSA::signInit(PrivateKey* privateKey, const AsymMech::Type mechanism, emsa = request.str(); break; case AsymMech::RSA_SHA256_PKCS_PSS: - if ((mechanismParam == NULL) || (!mechanismParam->isOfType(RSAPssMechanismParam::type))) - { - ERROR_MSG("Invalid RSA PSS mechanism parameter type supplied"); - ByteString dummy; - AsymmetricAlgorithm::signFinal(dummy); - return false; - } - pssParam = dynamic_cast(mechanismParam); - if ((pssParam->hashAlg != HashAlgo::SHA256)|| - (pssParam->mgfAlg != AsymRSAMGF::MGF1_SHA256)) + if (!RSAUtil::checkPssParams(mechanismParam, HashAlgo::SHA256, AsymRSAMGF::MGF1_SHA256, 32, privateKey->getBitLength(), sLen)) { - ERROR_MSG("Invalid RSA PSS mechanism parameters supplied"); - ByteString dummy; - AsymmetricAlgorithm::signFinal(dummy); - return false; - } - sLen = pssParam->sLen; - if (sLen > ((privateKey->getBitLength()+6)/8-2-32)) - { - ERROR_MSG("sLen (%lu) is too large for current key size (%lu)", - (unsigned long)sLen, privateKey->getBitLength()); ByteString dummy; AsymmetricAlgorithm::signFinal(dummy); return false; @@ -276,61 +231,63 @@ bool BotanRSA::signInit(PrivateKey* privateKey, const AsymMech::Type mechanism, emsa = request.str(); break; case AsymMech::RSA_SHA384_PKCS_PSS: - if ((mechanismParam == NULL) || (!mechanismParam->isOfType(RSAPssMechanismParam::type))) + if (!RSAUtil::checkPssParams(mechanismParam, HashAlgo::SHA384, AsymRSAMGF::MGF1_SHA384, 48, privateKey->getBitLength(), sLen)) { - ERROR_MSG("Invalid RSA PSS mechanism parameter type supplied"); ByteString dummy; AsymmetricAlgorithm::signFinal(dummy); return false; } - pssParam = dynamic_cast(mechanismParam); - if ((pssParam->hashAlg != HashAlgo::SHA384)|| - (pssParam->mgfAlg != AsymRSAMGF::MGF1_SHA384)) + request << "EMSA4(SHA-384,MGF1," << sLen << ")"; + emsa = request.str(); + break; + case AsymMech::RSA_SHA512_PKCS_PSS: + if (!RSAUtil::checkPssParams(mechanismParam, HashAlgo::SHA512, AsymRSAMGF::MGF1_SHA512, 64, privateKey->getBitLength(), sLen)) { - ERROR_MSG("Invalid RSA PSS mechanism parameters supplied"); ByteString dummy; AsymmetricAlgorithm::signFinal(dummy); return false; } - sLen = pssParam->sLen; - if (sLen > ((privateKey->getBitLength()+6)/8-2-48)) + request << "EMSA4(SHA-512,MGF1," << sLen << ")"; + emsa = request.str(); + break; + case AsymMech::RSA_SHA3_224_PKCS_PSS: + if (!RSAUtil::checkPssParams(mechanismParam, HashAlgo::SHA3_224, AsymRSAMGF::MGF1_SHA3_224, 28, privateKey->getBitLength(), sLen)) { - ERROR_MSG("sLen (%lu) is too large for current key size (%lu)", - (unsigned long)sLen, privateKey->getBitLength()); ByteString dummy; AsymmetricAlgorithm::signFinal(dummy); return false; } - request << "EMSA4(SHA-384,MGF1," << sLen << ")"; + request << "EMSA4(SHA-3(224),MGF1," << sLen << ")"; emsa = request.str(); break; - case AsymMech::RSA_SHA512_PKCS_PSS: - if ((mechanismParam == NULL) || (!mechanismParam->isOfType(RSAPssMechanismParam::type))) + case AsymMech::RSA_SHA3_256_PKCS_PSS: + if (!RSAUtil::checkPssParams(mechanismParam, HashAlgo::SHA3_256, AsymRSAMGF::MGF1_SHA3_256, 32, privateKey->getBitLength(), sLen)) { - ERROR_MSG("Invalid RSA PSS mechanism parameter type supplied"); ByteString dummy; AsymmetricAlgorithm::signFinal(dummy); return false; } - pssParam = dynamic_cast(mechanismParam); - if ((pssParam->hashAlg != HashAlgo::SHA512)|| - (pssParam->mgfAlg != AsymRSAMGF::MGF1_SHA512)) + request << "EMSA4(SHA-3(256),MGF1," << sLen << ")"; + emsa = request.str(); + break; + case AsymMech::RSA_SHA3_384_PKCS_PSS: + if (!RSAUtil::checkPssParams(mechanismParam, HashAlgo::SHA3_384, AsymRSAMGF::MGF1_SHA3_384, 48, privateKey->getBitLength(), sLen)) { - ERROR_MSG("Invalid RSA PSS mechanism parameters supplied"); ByteString dummy; AsymmetricAlgorithm::signFinal(dummy); return false; } - sLen = pssParam->sLen; - if (sLen > ((privateKey->getBitLength()+6)/8-2-64)) + request << "EMSA4(SHA-3(384),MGF1," << sLen << ")"; + emsa = request.str(); + break; + case AsymMech::RSA_SHA3_512_PKCS_PSS: + if (!RSAUtil::checkPssParams(mechanismParam, HashAlgo::SHA3_512, AsymRSAMGF::MGF1_SHA3_512, 64, privateKey->getBitLength(), sLen)) { - ERROR_MSG("sLen (%lu) is too large for current key size (%lu)", - (unsigned long)sLen, privateKey->getBitLength()); ByteString dummy; AsymmetricAlgorithm::signFinal(dummy); return false; } - request << "EMSA4(SHA-512,MGF1," << sLen << ")"; + request << "EMSA4(SHA-3(512),MGF1," << sLen << ")"; emsa = request.str(); break; case AsymMech::RSA_SSL: @@ -546,7 +503,6 @@ bool BotanRSA::verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, std::string emsa; std::ostringstream request; size_t sLen; - const RSAPssMechanismParam* pssParam = NULL; switch (mechanism) { @@ -568,28 +524,21 @@ bool BotanRSA::verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, case AsymMech::RSA_SHA512_PKCS: emsa = "EMSA3(SHA-512)"; break; + case AsymMech::RSA_SHA3_224_PKCS: + emsa = "EMSA3(SHA-3(224))"; + break; + case AsymMech::RSA_SHA3_256_PKCS: + emsa = "EMSA3(SHA-3(256))"; + break; + case AsymMech::RSA_SHA3_384_PKCS: + emsa = "EMSA3(SHA-3(384))"; + break; + case AsymMech::RSA_SHA3_512_PKCS: + emsa = "EMSA3(SHA-3(512))"; + break; case AsymMech::RSA_SHA1_PKCS_PSS: - if ((mechanismParam == NULL) || (!mechanismParam->isOfType(RSAPssMechanismParam::type))) - { - ERROR_MSG("Invalid RSA PSS mechanism parameter type supplied"); - ByteString dummy; - AsymmetricAlgorithm::verifyFinal(dummy); - return false; - } - pssParam = dynamic_cast(mechanismParam); - if ((pssParam->hashAlg != HashAlgo::SHA1)|| - (pssParam->mgfAlg != AsymRSAMGF::MGF1_SHA1)) - { - ERROR_MSG("Invalid RSA PSS mechanism parameters supplied"); - ByteString dummy; - AsymmetricAlgorithm::verifyFinal(dummy); - return false; - } - sLen = pssParam->sLen; - if (sLen > ((publicKey->getBitLength()+6)/8-2-20)) + if (!RSAUtil::checkPssParams(mechanismParam, HashAlgo::SHA1, AsymRSAMGF::MGF1_SHA1, 20, publicKey->getBitLength(), sLen)) { - ERROR_MSG("sLen (%lu) is too large for current key size (%lu)", - (unsigned long)sLen, publicKey->getBitLength()); ByteString dummy; AsymmetricAlgorithm::verifyFinal(dummy); return false; @@ -598,27 +547,8 @@ bool BotanRSA::verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, emsa = request.str(); break; case AsymMech::RSA_SHA224_PKCS_PSS: - if ((mechanismParam == NULL) || (!mechanismParam->isOfType(RSAPssMechanismParam::type))) + if (!RSAUtil::checkPssParams(mechanismParam, HashAlgo::SHA224, AsymRSAMGF::MGF1_SHA224, 28, publicKey->getBitLength(), sLen)) { - ERROR_MSG("Invalid RSA PSS mechanism parameter type supplied"); - ByteString dummy; - AsymmetricAlgorithm::verifyFinal(dummy); - return false; - } - pssParam = dynamic_cast(mechanismParam); - if ((pssParam->hashAlg != HashAlgo::SHA224)|| - (pssParam->mgfAlg != AsymRSAMGF::MGF1_SHA224)) - { - ERROR_MSG("Invalid RSA PSS mechanism parameters supplied"); - ByteString dummy; - AsymmetricAlgorithm::verifyFinal(dummy); - return false; - } - sLen = pssParam->sLen; - if (sLen > ((publicKey->getBitLength()+6)/8-2-28)) - { - ERROR_MSG("sLen (%lu) is too large for current key size (%lu)", - (unsigned long)sLen, publicKey->getBitLength()); ByteString dummy; AsymmetricAlgorithm::verifyFinal(dummy); return false; @@ -627,27 +557,8 @@ bool BotanRSA::verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, emsa = request.str(); break; case AsymMech::RSA_SHA256_PKCS_PSS: - if ((mechanismParam == NULL) || (!mechanismParam->isOfType(RSAPssMechanismParam::type))) + if (!RSAUtil::checkPssParams(mechanismParam, HashAlgo::SHA256, AsymRSAMGF::MGF1_SHA256, 32, publicKey->getBitLength(), sLen)) { - ERROR_MSG("Invalid RSA PSS mechanism parameter type supplied"); - ByteString dummy; - AsymmetricAlgorithm::verifyFinal(dummy); - return false; - } - pssParam = dynamic_cast(mechanismParam); - if ((pssParam->hashAlg != HashAlgo::SHA256)|| - (pssParam->mgfAlg != AsymRSAMGF::MGF1_SHA256)) - { - ERROR_MSG("Invalid RSA PSS mechanism parameters supplied"); - ByteString dummy; - AsymmetricAlgorithm::verifyFinal(dummy); - return false; - } - sLen = pssParam->sLen; - if (sLen > ((publicKey->getBitLength()+6)/8-2-32)) - { - ERROR_MSG("sLen (%lu) is too large for current key size (%lu)", - (unsigned long)sLen, publicKey->getBitLength()); ByteString dummy; AsymmetricAlgorithm::verifyFinal(dummy); return false; @@ -656,61 +567,63 @@ bool BotanRSA::verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, emsa = request.str(); break; case AsymMech::RSA_SHA384_PKCS_PSS: - if ((mechanismParam == NULL) || (!mechanismParam->isOfType(RSAPssMechanismParam::type))) + if (!RSAUtil::checkPssParams(mechanismParam, HashAlgo::SHA384, AsymRSAMGF::MGF1_SHA384, 48, publicKey->getBitLength(), sLen)) { - ERROR_MSG("Invalid RSA PSS mechanism parameter type supplied"); ByteString dummy; AsymmetricAlgorithm::verifyFinal(dummy); return false; } - pssParam = dynamic_cast(mechanismParam); - if ((pssParam->hashAlg != HashAlgo::SHA384)|| - (pssParam->mgfAlg != AsymRSAMGF::MGF1_SHA384)) + request << "EMSA4(SHA-384,MGF1," << sLen << ")"; + emsa = request.str(); + break; + case AsymMech::RSA_SHA512_PKCS_PSS: + if (!RSAUtil::checkPssParams(mechanismParam, HashAlgo::SHA512, AsymRSAMGF::MGF1_SHA512, 64, publicKey->getBitLength(), sLen)) { - ERROR_MSG("Invalid RSA PSS mechanism parameters supplied"); ByteString dummy; AsymmetricAlgorithm::verifyFinal(dummy); return false; } - sLen = pssParam->sLen; - if (sLen > ((publicKey->getBitLength()+6)/8-2-48)) + request << "EMSA4(SHA-512,MGF1," << sLen << ")"; + emsa = request.str(); + break; + case AsymMech::RSA_SHA3_224_PKCS_PSS: + if (!RSAUtil::checkPssParams(mechanismParam, HashAlgo::SHA3_224, AsymRSAMGF::MGF1_SHA3_224, 28, publicKey->getBitLength(), sLen)) { - ERROR_MSG("sLen (%lu) is too large for current key size (%lu)", - (unsigned long)sLen, publicKey->getBitLength()); ByteString dummy; AsymmetricAlgorithm::verifyFinal(dummy); return false; } - request << "EMSA4(SHA-384,MGF1," << sLen << ")"; + request << "EMSA4(SHA-3(224),MGF1," << sLen << ")"; emsa = request.str(); break; - case AsymMech::RSA_SHA512_PKCS_PSS: - if ((mechanismParam == NULL) || (!mechanismParam->isOfType(RSAPssMechanismParam::type))) + case AsymMech::RSA_SHA3_256_PKCS_PSS: + if (!RSAUtil::checkPssParams(mechanismParam, HashAlgo::SHA3_256, AsymRSAMGF::MGF1_SHA3_256, 32, publicKey->getBitLength(), sLen)) { - ERROR_MSG("Invalid RSA PSS mechanism parameter type supplied"); ByteString dummy; AsymmetricAlgorithm::verifyFinal(dummy); return false; } - pssParam = dynamic_cast(mechanismParam); - if ((pssParam->hashAlg != HashAlgo::SHA512)|| - (pssParam->mgfAlg != AsymRSAMGF::MGF1_SHA512)) + request << "EMSA4(SHA-3(256),MGF1," << sLen << ")"; + emsa = request.str(); + break; + case AsymMech::RSA_SHA3_384_PKCS_PSS: + if (!RSAUtil::checkPssParams(mechanismParam, HashAlgo::SHA3_384, AsymRSAMGF::MGF1_SHA3_384, 48, publicKey->getBitLength(), sLen)) { - ERROR_MSG("Invalid RSA PSS mechanism parameters supplied"); ByteString dummy; AsymmetricAlgorithm::verifyFinal(dummy); return false; } - sLen = pssParam->sLen; - if (sLen > ((publicKey->getBitLength()+6)/8-2-64)) + request << "EMSA4(SHA-3(384),MGF1," << sLen << ")"; + emsa = request.str(); + break; + case AsymMech::RSA_SHA3_512_PKCS_PSS: + if (!RSAUtil::checkPssParams(mechanismParam, HashAlgo::SHA3_512, AsymRSAMGF::MGF1_SHA3_512, 64, publicKey->getBitLength(), sLen)) { - ERROR_MSG("sLen (%lu) is too large for current key size (%lu)", - (unsigned long)sLen, publicKey->getBitLength()); ByteString dummy; AsymmetricAlgorithm::verifyFinal(dummy); return false; } - request << "EMSA4(SHA-512,MGF1," << sLen << ")"; + request << "EMSA4(SHA-3(512),MGF1," << sLen << ")"; emsa = request.str(); break; case AsymMech::RSA_SSL: @@ -1219,6 +1132,22 @@ std::string BotanRSA::getCipherRawPss(size_t bitLength, size_t dataSize, const M hashStr = "SHA-512"; allowedLen = 64; break; + case HashAlgo::SHA3_224: + hashStr = "SHA-3(224)"; + allowedLen = 28; + break; + case HashAlgo::SHA3_256: + hashStr = "SHA-3(256)"; + allowedLen = 32; + break; + case HashAlgo::SHA3_384: + hashStr = "SHA-3(384)"; + allowedLen = 48; + break; + case HashAlgo::SHA3_512: + hashStr = "SHA-3(512)"; + allowedLen = 64; + break; default: ERROR_MSG("Invalid hash parameter"); return ""; @@ -1231,7 +1160,7 @@ std::string BotanRSA::getCipherRawPss(size_t bitLength, size_t dataSize, const M } size_t sLen = rsaPssMecahnismParam->sLen; - if (sLen > ((bitLength+6)/8-2-20)) + if (sLen > ((bitLength+6)/8-2-allowedLen)) { ERROR_MSG("sLen (%lu) is too large for current key size (%lu)", (unsigned long)sLen, bitLength); @@ -1284,6 +1213,22 @@ std::string BotanRSA::getCipherOaep(size_t bitLength, size_t dataSize, const Mec hashStr = "SHA-512"; hashLen = 64; break; + case HashAlgo::SHA3_224: + hashStr = "SHA-3(224)"; + hashLen = 28; + break; + case HashAlgo::SHA3_256: + hashStr = "SHA-3(256)"; + hashLen = 32; + break; + case HashAlgo::SHA3_384: + hashStr = "SHA-3(384)"; + hashLen = 48; + break; + case HashAlgo::SHA3_512: + hashStr = "SHA-3(512)"; + hashLen = 64; + break; default: ERROR_MSG("Invalid hash parameter"); return ""; @@ -1305,6 +1250,18 @@ std::string BotanRSA::getCipherOaep(size_t bitLength, size_t dataSize, const Mec case AsymRSAMGF::MGF1_SHA512: mgfStr = "SHA-512"; break; + case AsymRSAMGF::MGF1_SHA3_224: + mgfStr = "SHA-3(224)"; + break; + case AsymRSAMGF::MGF1_SHA3_256: + mgfStr = "SHA-3(256)"; + break; + case AsymRSAMGF::MGF1_SHA3_384: + mgfStr = "SHA-3(384)"; + break; + case AsymRSAMGF::MGF1_SHA3_512: + mgfStr = "SHA-3(512)"; + break; default: ERROR_MSG("Invalid mgf parameter"); return ""; diff --git a/src/lib/crypto/BotanSHA3_224.cpp b/src/lib/crypto/BotanSHA3_224.cpp new file mode 100644 index 000000000..73de7dd12 --- /dev/null +++ b/src/lib/crypto/BotanSHA3_224.cpp @@ -0,0 +1,26 @@ +/* + * Copyright (c) 2026 SoftHSMv2 contributors + * + * SPDX-License-Identifier: BSD-2-Clause + */ + +/***************************************************************************** + BotanSHA3_224.cpp + + Botan SHA3-224 implementation + *****************************************************************************/ + +#include "config.h" +#ifdef WITH_SHA3 +#include "BotanSHA3_224.h" + +int BotanSHA3_224::getHashSize() +{ + return 28; +} + +const char* BotanSHA3_224::getHashName() const +{ + return "SHA-3(224)"; +} +#endif diff --git a/src/lib/crypto/BotanSHA3_224.h b/src/lib/crypto/BotanSHA3_224.h new file mode 100644 index 000000000..8847549c3 --- /dev/null +++ b/src/lib/crypto/BotanSHA3_224.h @@ -0,0 +1,27 @@ +/* + * Copyright (c) 2026 SoftHSMv2 contributors + * + * SPDX-License-Identifier: BSD-2-Clause + */ + +/***************************************************************************** + BotanSHA3_224.h + + Botan SHA3-224 implementation + *****************************************************************************/ + +#ifndef _SOFTHSM_V2_BOTANSHA3_224_H +#define _SOFTHSM_V2_BOTANSHA3_224_H + +#include "config.h" +#include "BotanHashAlgorithm.h" +#include + +class BotanSHA3_224 : public BotanHashAlgorithm +{ + virtual int getHashSize(); +protected: + virtual const char* getHashName() const; +}; + +#endif // !_SOFTHSM_V2_BOTANSHA3_224_H diff --git a/src/lib/crypto/BotanSHA3_256.cpp b/src/lib/crypto/BotanSHA3_256.cpp new file mode 100644 index 000000000..7b247d815 --- /dev/null +++ b/src/lib/crypto/BotanSHA3_256.cpp @@ -0,0 +1,26 @@ +/* + * Copyright (c) 2026 SoftHSMv2 contributors + * + * SPDX-License-Identifier: BSD-2-Clause + */ + +/***************************************************************************** + BotanSHA3_256.cpp + + Botan SHA3-256 implementation + *****************************************************************************/ + +#include "config.h" +#ifdef WITH_SHA3 +#include "BotanSHA3_256.h" + +int BotanSHA3_256::getHashSize() +{ + return 32; +} + +const char* BotanSHA3_256::getHashName() const +{ + return "SHA-3(256)"; +} +#endif diff --git a/src/lib/crypto/BotanSHA3_256.h b/src/lib/crypto/BotanSHA3_256.h new file mode 100644 index 000000000..d49dfd454 --- /dev/null +++ b/src/lib/crypto/BotanSHA3_256.h @@ -0,0 +1,27 @@ +/* + * Copyright (c) 2026 SoftHSMv2 contributors + * + * SPDX-License-Identifier: BSD-2-Clause + */ + +/***************************************************************************** + BotanSHA3_256.h + + Botan SHA3-256 implementation + *****************************************************************************/ + +#ifndef _SOFTHSM_V2_BOTANSHA3_256_H +#define _SOFTHSM_V2_BOTANSHA3_256_H + +#include "config.h" +#include "BotanHashAlgorithm.h" +#include + +class BotanSHA3_256 : public BotanHashAlgorithm +{ + virtual int getHashSize(); +protected: + virtual const char* getHashName() const; +}; + +#endif // !_SOFTHSM_V2_BOTANSHA3_256_H diff --git a/src/lib/crypto/BotanSHA3_384.cpp b/src/lib/crypto/BotanSHA3_384.cpp new file mode 100644 index 000000000..12d3abb6a --- /dev/null +++ b/src/lib/crypto/BotanSHA3_384.cpp @@ -0,0 +1,26 @@ +/* + * Copyright (c) 2026 SoftHSMv2 contributors + * + * SPDX-License-Identifier: BSD-2-Clause + */ + +/***************************************************************************** + BotanSHA3_384.cpp + + Botan SHA3-384 implementation + *****************************************************************************/ + +#include "config.h" +#ifdef WITH_SHA3 +#include "BotanSHA3_384.h" + +int BotanSHA3_384::getHashSize() +{ + return 48; +} + +const char* BotanSHA3_384::getHashName() const +{ + return "SHA-3(384)"; +} +#endif diff --git a/src/lib/crypto/BotanSHA3_384.h b/src/lib/crypto/BotanSHA3_384.h new file mode 100644 index 000000000..dbe8462e8 --- /dev/null +++ b/src/lib/crypto/BotanSHA3_384.h @@ -0,0 +1,27 @@ +/* + * Copyright (c) 2026 SoftHSMv2 contributors + * + * SPDX-License-Identifier: BSD-2-Clause + */ + +/***************************************************************************** + BotanSHA3_384.h + + Botan SHA3-384 implementation + *****************************************************************************/ + +#ifndef _SOFTHSM_V2_BOTANSHA3_384_H +#define _SOFTHSM_V2_BOTANSHA3_384_H + +#include "config.h" +#include "BotanHashAlgorithm.h" +#include + +class BotanSHA3_384 : public BotanHashAlgorithm +{ + virtual int getHashSize(); +protected: + virtual const char* getHashName() const; +}; + +#endif // !_SOFTHSM_V2_BOTANSHA3_384_H diff --git a/src/lib/crypto/BotanSHA3_512.cpp b/src/lib/crypto/BotanSHA3_512.cpp new file mode 100644 index 000000000..8e73eafdd --- /dev/null +++ b/src/lib/crypto/BotanSHA3_512.cpp @@ -0,0 +1,26 @@ +/* + * Copyright (c) 2026 SoftHSMv2 contributors + * + * SPDX-License-Identifier: BSD-2-Clause + */ + +/***************************************************************************** + BotanSHA3_512.cpp + + Botan SHA3-512 implementation + *****************************************************************************/ + +#include "config.h" +#ifdef WITH_SHA3 +#include "BotanSHA3_512.h" + +int BotanSHA3_512::getHashSize() +{ + return 64; +} + +const char* BotanSHA3_512::getHashName() const +{ + return "SHA-3(512)"; +} +#endif diff --git a/src/lib/crypto/BotanSHA3_512.h b/src/lib/crypto/BotanSHA3_512.h new file mode 100644 index 000000000..053a47e3d --- /dev/null +++ b/src/lib/crypto/BotanSHA3_512.h @@ -0,0 +1,27 @@ +/* + * Copyright (c) 2026 SoftHSMv2 contributors + * + * SPDX-License-Identifier: BSD-2-Clause + */ + +/***************************************************************************** + BotanSHA3_512.h + + Botan SHA3-512 implementation + *****************************************************************************/ + +#ifndef _SOFTHSM_V2_BOTANSHA3_512_H +#define _SOFTHSM_V2_BOTANSHA3_512_H + +#include "config.h" +#include "BotanHashAlgorithm.h" +#include + +class BotanSHA3_512 : public BotanHashAlgorithm +{ + virtual int getHashSize(); +protected: + virtual const char* getHashName() const; +}; + +#endif // !_SOFTHSM_V2_BOTANSHA3_512_H diff --git a/src/lib/crypto/CMakeLists.txt b/src/lib/crypto/CMakeLists.txt index fe0d47f7b..0579a08a3 100644 --- a/src/lib/crypto/CMakeLists.txt +++ b/src/lib/crypto/CMakeLists.txt @@ -43,6 +43,7 @@ set(SOURCES AESKey.cpp RSAParameters.cpp RSAPrivateKey.cpp RSAPublicKey.cpp + RSAUtil.cpp SymmetricAlgorithm.cpp SymmetricKey.cpp ) @@ -99,6 +100,10 @@ if(WITH_OPENSSL) OSSLSHA256.cpp OSSLSHA384.cpp OSSLSHA512.cpp + OSSLSHA3_224.cpp + OSSLSHA3_256.cpp + OSSLSHA3_384.cpp + OSSLSHA3_512.cpp OSSLUtil.cpp ) endif(WITH_OPENSSL) @@ -147,6 +152,10 @@ if(WITH_BOTAN) BotanSHA256.cpp BotanSHA384.cpp BotanSHA512.cpp + BotanSHA3_224.cpp + BotanSHA3_256.cpp + BotanSHA3_384.cpp + BotanSHA3_512.cpp BotanSymmetricAlgorithm.cpp BotanUtil.cpp ) diff --git a/src/lib/crypto/HashAlgorithm.h b/src/lib/crypto/HashAlgorithm.h index ca2ae08b4..b0e094923 100644 --- a/src/lib/crypto/HashAlgorithm.h +++ b/src/lib/crypto/HashAlgorithm.h @@ -47,6 +47,10 @@ struct HashAlgo SHA256, SHA384, SHA512, + SHA3_224, + SHA3_256, + SHA3_384, + SHA3_512, GOST }; }; diff --git a/src/lib/crypto/MacAlgorithm.h b/src/lib/crypto/MacAlgorithm.h index e9b22b04d..7096a5d90 100644 --- a/src/lib/crypto/MacAlgorithm.h +++ b/src/lib/crypto/MacAlgorithm.h @@ -49,6 +49,10 @@ struct MacAlgo HMAC_SHA256, HMAC_SHA384, HMAC_SHA512, + HMAC_SHA3_224, + HMAC_SHA3_256, + HMAC_SHA3_384, + HMAC_SHA3_512, HMAC_GOST, CMAC_DES, CMAC_AES diff --git a/src/lib/crypto/Makefile.am b/src/lib/crypto/Makefile.am index 781375be0..4746a16eb 100644 --- a/src/lib/crypto/Makefile.am +++ b/src/lib/crypto/Makefile.am @@ -43,6 +43,7 @@ libsofthsm_crypto_la_SOURCES = AESKey.cpp \ RSAParameters.cpp \ RSAPrivateKey.cpp \ RSAPublicKey.cpp \ + RSAUtil.cpp \ SymmetricAlgorithm.cpp \ SymmetricKey.cpp libsofthsm_crypto_la_LIBADD = @CRYPTO_LIBS@ @@ -106,6 +107,10 @@ libsofthsm_crypto_la_SOURCES += OSSLAES.cpp \ OSSLSHA256.cpp \ OSSLSHA384.cpp \ OSSLSHA512.cpp \ + OSSLSHA3_224.cpp \ + OSSLSHA3_256.cpp \ + OSSLSHA3_384.cpp \ + OSSLSHA3_512.cpp \ OSSLUtil.cpp endif @@ -153,6 +158,10 @@ libsofthsm_crypto_la_SOURCES += BotanAES.cpp \ BotanSHA256.cpp \ BotanSHA384.cpp \ BotanSHA512.cpp \ + BotanSHA3_224.cpp \ + BotanSHA3_256.cpp \ + BotanSHA3_384.cpp \ + BotanSHA3_512.cpp \ BotanSymmetricAlgorithm.cpp \ BotanUtil.cpp \ Botan_ecb.cpp diff --git a/src/lib/crypto/OSSLCryptoFactory.cpp b/src/lib/crypto/OSSLCryptoFactory.cpp index c46d0dde1..b70eec4e7 100644 --- a/src/lib/crypto/OSSLCryptoFactory.cpp +++ b/src/lib/crypto/OSSLCryptoFactory.cpp @@ -42,6 +42,12 @@ #include "OSSLSHA256.h" #include "OSSLSHA384.h" #include "OSSLSHA512.h" +#ifdef WITH_SHA3 +#include "OSSLSHA3_224.h" +#include "OSSLSHA3_256.h" +#include "OSSLSHA3_384.h" +#include "OSSLSHA3_512.h" +#endif #include "OSSLCMAC.h" #include "OSSLHMAC.h" #include "OSSLRSA.h" @@ -393,6 +399,16 @@ HashAlgorithm* OSSLCryptoFactory::getHashAlgorithm(HashAlgo::Type algorithm) return new OSSLSHA384(); case HashAlgo::SHA512: return new OSSLSHA512(); +#ifdef WITH_SHA3 + case HashAlgo::SHA3_224: + return new OSSLSHA3_224(); + case HashAlgo::SHA3_256: + return new OSSLSHA3_256(); + case HashAlgo::SHA3_384: + return new OSSLSHA3_384(); + case HashAlgo::SHA3_512: + return new OSSLSHA3_512(); +#endif #ifdef WITH_GOST case HashAlgo::GOST: return new OSSLGOSTR3411(); @@ -423,6 +439,16 @@ MacAlgorithm* OSSLCryptoFactory::getMacAlgorithm(MacAlgo::Type algorithm) return new OSSLHMACSHA384(); case MacAlgo::HMAC_SHA512: return new OSSLHMACSHA512(); +#ifdef WITH_SHA3 + case MacAlgo::HMAC_SHA3_224: + return new OSSLHMACSHA3_224(); + case MacAlgo::HMAC_SHA3_256: + return new OSSLHMACSHA3_256(); + case MacAlgo::HMAC_SHA3_384: + return new OSSLHMACSHA3_384(); + case MacAlgo::HMAC_SHA3_512: + return new OSSLHMACSHA3_512(); +#endif #ifdef WITH_GOST case MacAlgo::HMAC_GOST: return new OSSLHMACGOSTR3411(); diff --git a/src/lib/crypto/OSSLDSA.cpp b/src/lib/crypto/OSSLDSA.cpp index 7fd40c791..d87c8cce3 100644 --- a/src/lib/crypto/OSSLDSA.cpp +++ b/src/lib/crypto/OSSLDSA.cpp @@ -140,6 +140,18 @@ bool OSSLDSA::signInit(PrivateKey* privateKey, const AsymMech::Type mechanism, case AsymMech::DSA_SHA512: hash = HashAlgo::SHA512; break; + case AsymMech::DSA_SHA3_224: + hash = HashAlgo::SHA3_224; + break; + case AsymMech::DSA_SHA3_256: + hash = HashAlgo::SHA3_256; + break; + case AsymMech::DSA_SHA3_384: + hash = HashAlgo::SHA3_384; + break; + case AsymMech::DSA_SHA3_512: + hash = HashAlgo::SHA3_512; + break; default: ERROR_MSG("Invalid mechanism supplied (%i)", mechanism); @@ -328,6 +340,18 @@ bool OSSLDSA::verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, case AsymMech::DSA_SHA512: hash = HashAlgo::SHA512; break; + case AsymMech::DSA_SHA3_224: + hash = HashAlgo::SHA3_224; + break; + case AsymMech::DSA_SHA3_256: + hash = HashAlgo::SHA3_256; + break; + case AsymMech::DSA_SHA3_384: + hash = HashAlgo::SHA3_384; + break; + case AsymMech::DSA_SHA3_512: + hash = HashAlgo::SHA3_512; + break; default: ERROR_MSG("Invalid mechanism supplied (%i)", mechanism); diff --git a/src/lib/crypto/OSSLECDSA.cpp b/src/lib/crypto/OSSLECDSA.cpp index 36480cbbb..895e507c6 100644 --- a/src/lib/crypto/OSSLECDSA.cpp +++ b/src/lib/crypto/OSSLECDSA.cpp @@ -90,6 +90,18 @@ bool OSSLECDSA::sign(PrivateKey* privateKey, const ByteString& dataToSign, case AsymMech::ECDSA_SHA512: hash = HashAlgo::SHA512; break; + case AsymMech::ECDSA_SHA3_224: + hash = HashAlgo::SHA3_224; + break; + case AsymMech::ECDSA_SHA3_256: + hash = HashAlgo::SHA3_256; + break; + case AsymMech::ECDSA_SHA3_384: + hash = HashAlgo::SHA3_384; + break; + case AsymMech::ECDSA_SHA3_512: + hash = HashAlgo::SHA3_512; + break; default: ERROR_MSG("Invalid mechanism supplied (%i)", mechanism); return false; @@ -211,6 +223,18 @@ bool OSSLECDSA::signInit(PrivateKey* privateKey, const AsymMech::Type mechanism, case AsymMech::ECDSA_SHA512: hash = HashAlgo::SHA512; break; + case AsymMech::ECDSA_SHA3_224: + hash = HashAlgo::SHA3_224; + break; + case AsymMech::ECDSA_SHA3_256: + hash = HashAlgo::SHA3_256; + break; + case AsymMech::ECDSA_SHA3_384: + hash = HashAlgo::SHA3_384; + break; + case AsymMech::ECDSA_SHA3_512: + hash = HashAlgo::SHA3_512; + break; default: ERROR_MSG("Invalid mechanism supplied (%i)", mechanism); @@ -364,6 +388,18 @@ bool OSSLECDSA::verify(PublicKey* publicKey, const ByteString& originalData, case AsymMech::ECDSA_SHA512: hash = HashAlgo::SHA512; break; + case AsymMech::ECDSA_SHA3_224: + hash = HashAlgo::SHA3_224; + break; + case AsymMech::ECDSA_SHA3_256: + hash = HashAlgo::SHA3_256; + break; + case AsymMech::ECDSA_SHA3_384: + hash = HashAlgo::SHA3_384; + break; + case AsymMech::ECDSA_SHA3_512: + hash = HashAlgo::SHA3_512; + break; default: ERROR_MSG("Invalid mechanism supplied (%i)", mechanism); return false; @@ -505,6 +541,18 @@ bool OSSLECDSA::verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, case AsymMech::ECDSA_SHA512: hash = HashAlgo::SHA512; break; + case AsymMech::ECDSA_SHA3_224: + hash = HashAlgo::SHA3_224; + break; + case AsymMech::ECDSA_SHA3_256: + hash = HashAlgo::SHA3_256; + break; + case AsymMech::ECDSA_SHA3_384: + hash = HashAlgo::SHA3_384; + break; + case AsymMech::ECDSA_SHA3_512: + hash = HashAlgo::SHA3_512; + break; default: ERROR_MSG("Invalid mechanism supplied (%i)", mechanism); diff --git a/src/lib/crypto/OSSLHMAC.cpp b/src/lib/crypto/OSSLHMAC.cpp index f8b73a761..bb3c6225d 100644 --- a/src/lib/crypto/OSSLHMAC.cpp +++ b/src/lib/crypto/OSSLHMAC.cpp @@ -96,6 +96,48 @@ size_t OSSLHMACSHA512::getMacSize() const return 64; } +#ifdef WITH_SHA3 +const EVP_MD* OSSLHMACSHA3_224::getEVPHash() const +{ + return EVP_sha3_224(); +} + +size_t OSSLHMACSHA3_224::getMacSize() const +{ + return 28; +} + +const EVP_MD* OSSLHMACSHA3_256::getEVPHash() const +{ + return EVP_sha3_256(); +} + +size_t OSSLHMACSHA3_256::getMacSize() const +{ + return 32; +} + +const EVP_MD* OSSLHMACSHA3_384::getEVPHash() const +{ + return EVP_sha3_384(); +} + +size_t OSSLHMACSHA3_384::getMacSize() const +{ + return 48; +} + +const EVP_MD* OSSLHMACSHA3_512::getEVPHash() const +{ + return EVP_sha3_512(); +} + +size_t OSSLHMACSHA3_512::getMacSize() const +{ + return 64; +} +#endif + #ifdef WITH_GOST const EVP_MD* OSSLHMACGOSTR3411::getEVPHash() const { diff --git a/src/lib/crypto/OSSLHMAC.h b/src/lib/crypto/OSSLHMAC.h index 852614e76..65ccf8109 100644 --- a/src/lib/crypto/OSSLHMAC.h +++ b/src/lib/crypto/OSSLHMAC.h @@ -79,6 +79,34 @@ class OSSLHMACSHA512 : public OSSLEVPMacAlgorithm virtual size_t getMacSize() const; }; +class OSSLHMACSHA3_224 : public OSSLEVPMacAlgorithm +{ +protected: + virtual const EVP_MD* getEVPHash() const; + virtual size_t getMacSize() const; +}; + +class OSSLHMACSHA3_256 : public OSSLEVPMacAlgorithm +{ +protected: + virtual const EVP_MD* getEVPHash() const; + virtual size_t getMacSize() const; +}; + +class OSSLHMACSHA3_384 : public OSSLEVPMacAlgorithm +{ +protected: + virtual const EVP_MD* getEVPHash() const; + virtual size_t getMacSize() const; +}; + +class OSSLHMACSHA3_512 : public OSSLEVPMacAlgorithm +{ +protected: + virtual const EVP_MD* getEVPHash() const; + virtual size_t getMacSize() const; +}; + #ifdef WITH_GOST class OSSLHMACGOSTR3411 : public OSSLEVPMacAlgorithm { diff --git a/src/lib/crypto/OSSLRSA.cpp b/src/lib/crypto/OSSLRSA.cpp index eb0247c0b..2fe0f6c7d 100644 --- a/src/lib/crypto/OSSLRSA.cpp +++ b/src/lib/crypto/OSSLRSA.cpp @@ -37,6 +37,7 @@ #include "CryptoFactory.h" #include "RSAParameters.h" #include "RSAMechanismParam.h" +#include "RSAUtil.h" #include "OSSLRSAKeyPair.h" #include #include @@ -177,6 +178,24 @@ bool OSSLRSA::sign(PrivateKey* privateKey, const ByteString& dataToSign, hash = EVP_sha512(); allowedLen = 64; break; +#ifdef WITH_SHA3 + case HashAlgo::SHA3_224: + hash = EVP_sha3_224(); + allowedLen = 28; + break; + case HashAlgo::SHA3_256: + hash = EVP_sha3_256(); + allowedLen = 32; + break; + case HashAlgo::SHA3_384: + hash = EVP_sha3_384(); + allowedLen = 48; + break; + case HashAlgo::SHA3_512: + hash = EVP_sha3_512(); + allowedLen = 64; + break; +#endif default: return false; } @@ -198,6 +217,20 @@ bool OSSLRSA::sign(PrivateKey* privateKey, const ByteString& dataToSign, case AsymRSAMGF::MGF1_SHA512: mgf = EVP_sha512(); break; +#ifdef WITH_SHA3 + case AsymRSAMGF::MGF1_SHA3_224: + mgf = EVP_sha3_224(); + break; + case AsymRSAMGF::MGF1_SHA3_256: + mgf = EVP_sha3_256(); + break; + case AsymRSAMGF::MGF1_SHA3_384: + mgf = EVP_sha3_384(); + break; + case AsymRSAMGF::MGF1_SHA3_512: + mgf = EVP_sha3_512(); + break; +#endif default: return false; } @@ -326,7 +359,6 @@ bool OSSLRSA::signInit(PrivateKey *privateKey, const AsymMech::Type mechanism, HashAlgo::Type hash1 = HashAlgo::Unknown; HashAlgo::Type hash2 = HashAlgo::Unknown; - const RSAPssMechanismParam* pssParam = NULL; switch (mechanism) { case AsymMech::RSA_MD5_PKCS: @@ -347,28 +379,21 @@ bool OSSLRSA::signInit(PrivateKey *privateKey, const AsymMech::Type mechanism, case AsymMech::RSA_SHA512_PKCS: hash1 = HashAlgo::SHA512; break; + case AsymMech::RSA_SHA3_224_PKCS: + hash1 = HashAlgo::SHA3_224; + break; + case AsymMech::RSA_SHA3_256_PKCS: + hash1 = HashAlgo::SHA3_256; + break; + case AsymMech::RSA_SHA3_384_PKCS: + hash1 = HashAlgo::SHA3_384; + break; + case AsymMech::RSA_SHA3_512_PKCS: + hash1 = HashAlgo::SHA3_512; + break; case AsymMech::RSA_SHA1_PKCS_PSS: - if ((mechanismParam == NULL) || (!mechanismParam->isOfType(RSAPssMechanismParam::type))) - { - ERROR_MSG("Invalid RSA PSS mechanism parameter type supplied"); - ByteString dummy; - AsymmetricAlgorithm::signFinal(dummy); - return false; - } - pssParam = dynamic_cast(mechanismParam); - if ((pssParam->hashAlg != HashAlgo::SHA1)|| - (pssParam->mgfAlg != AsymRSAMGF::MGF1_SHA1)) + if (!RSAUtil::checkPssParams(mechanismParam, HashAlgo::SHA1, AsymRSAMGF::MGF1_SHA1, 20, privateKey->getBitLength(), sLen)) { - ERROR_MSG("Invalid RSA PSS mechanism parameters supplied"); - ByteString dummy; - AsymmetricAlgorithm::signFinal(dummy); - return false; - } - sLen = pssParam->sLen; - if (sLen > ((privateKey->getBitLength() + 6) / 8 - 2 - 20)) - { - ERROR_MSG("sLen (%lu) is too large for current key size (%lu)", - (unsigned long)sLen, privateKey->getBitLength()); ByteString dummy; AsymmetricAlgorithm::signFinal(dummy); return false; @@ -376,27 +401,8 @@ bool OSSLRSA::signInit(PrivateKey *privateKey, const AsymMech::Type mechanism, hash1 = HashAlgo::SHA1; break; case AsymMech::RSA_SHA224_PKCS_PSS: - if ((mechanismParam == NULL) || (!mechanismParam->isOfType(RSAPssMechanismParam::type))) - { - ERROR_MSG("Invalid RSA PSS mechanism parameter type supplied"); - ByteString dummy; - AsymmetricAlgorithm::signFinal(dummy); - return false; - } - pssParam = dynamic_cast(mechanismParam); - if ((pssParam->hashAlg != HashAlgo::SHA224)|| - (pssParam->mgfAlg != AsymRSAMGF::MGF1_SHA224)) + if (!RSAUtil::checkPssParams(mechanismParam, HashAlgo::SHA224, AsymRSAMGF::MGF1_SHA224, 28, privateKey->getBitLength(), sLen)) { - ERROR_MSG("Invalid RSA PSS mechanism parameters supplied"); - ByteString dummy; - AsymmetricAlgorithm::signFinal(dummy); - return false; - } - sLen = pssParam->sLen; - if (sLen > ((privateKey->getBitLength() + 6) / 8 - 2 - 28)) - { - ERROR_MSG("sLen (%lu) is too large for current key size (%lu)", - (unsigned long)sLen, privateKey->getBitLength()); ByteString dummy; AsymmetricAlgorithm::signFinal(dummy); return false; @@ -404,27 +410,8 @@ bool OSSLRSA::signInit(PrivateKey *privateKey, const AsymMech::Type mechanism, hash1 = HashAlgo::SHA224; break; case AsymMech::RSA_SHA256_PKCS_PSS: - if ((mechanismParam == NULL) || (!mechanismParam->isOfType(RSAPssMechanismParam::type))) + if (!RSAUtil::checkPssParams(mechanismParam, HashAlgo::SHA256, AsymRSAMGF::MGF1_SHA256, 32, privateKey->getBitLength(), sLen)) { - ERROR_MSG("Invalid RSA PSS mechanism parameter type supplied"); - ByteString dummy; - AsymmetricAlgorithm::signFinal(dummy); - return false; - } - pssParam = dynamic_cast(mechanismParam); - if ((pssParam->hashAlg != HashAlgo::SHA256)|| - (pssParam->mgfAlg != AsymRSAMGF::MGF1_SHA256)) - { - ERROR_MSG("Invalid RSA PSS mechanism parameters supplied"); - ByteString dummy; - AsymmetricAlgorithm::signFinal(dummy); - return false; - } - sLen = pssParam->sLen; - if (sLen > ((privateKey->getBitLength() + 6) / 8 - 2 - 32)) - { - ERROR_MSG("sLen (%lu) is too large for current key size (%lu)", - (unsigned long)sLen, privateKey->getBitLength()); ByteString dummy; AsymmetricAlgorithm::signFinal(dummy); return false; @@ -432,60 +419,58 @@ bool OSSLRSA::signInit(PrivateKey *privateKey, const AsymMech::Type mechanism, hash1 = HashAlgo::SHA256; break; case AsymMech::RSA_SHA384_PKCS_PSS: - if ((mechanismParam == NULL) || (!mechanismParam->isOfType(RSAPssMechanismParam::type))) + if (!RSAUtil::checkPssParams(mechanismParam, HashAlgo::SHA384, AsymRSAMGF::MGF1_SHA384, 48, privateKey->getBitLength(), sLen)) { - ERROR_MSG("Invalid RSA PSS mechanism parameter type supplied"); ByteString dummy; AsymmetricAlgorithm::signFinal(dummy); return false; } - pssParam = dynamic_cast(mechanismParam); - if ((pssParam->hashAlg != HashAlgo::SHA384)|| - (pssParam->mgfAlg != AsymRSAMGF::MGF1_SHA384)) + hash1 = HashAlgo::SHA384; + break; + case AsymMech::RSA_SHA512_PKCS_PSS: + if (!RSAUtil::checkPssParams(mechanismParam, HashAlgo::SHA512, AsymRSAMGF::MGF1_SHA512, 64, privateKey->getBitLength(), sLen)) { - ERROR_MSG("Invalid RSA PSS mechanism parameters supplied"); ByteString dummy; AsymmetricAlgorithm::signFinal(dummy); return false; } - sLen = pssParam->sLen; - if (sLen > ((privateKey->getBitLength() + 6) / 8 - 2 - 48)) + hash1 = HashAlgo::SHA512; + break; + case AsymMech::RSA_SHA3_224_PKCS_PSS: + if (!RSAUtil::checkPssParams(mechanismParam, HashAlgo::SHA3_224, AsymRSAMGF::MGF1_SHA3_224, 28, privateKey->getBitLength(), sLen)) { - ERROR_MSG("sLen (%lu) is too large for current key size (%lu)", - (unsigned long)sLen, privateKey->getBitLength()); ByteString dummy; AsymmetricAlgorithm::signFinal(dummy); return false; } - hash1 = HashAlgo::SHA384; + hash1 = HashAlgo::SHA3_224; break; - case AsymMech::RSA_SHA512_PKCS_PSS: - if ((mechanismParam == NULL) || (!mechanismParam->isOfType(RSAPssMechanismParam::type))) + case AsymMech::RSA_SHA3_256_PKCS_PSS: + if (!RSAUtil::checkPssParams(mechanismParam, HashAlgo::SHA3_256, AsymRSAMGF::MGF1_SHA3_256, 32, privateKey->getBitLength(), sLen)) { - ERROR_MSG("Invalid RSA PSS mechanism parameter type supplied"); ByteString dummy; AsymmetricAlgorithm::signFinal(dummy); return false; } - pssParam = dynamic_cast(mechanismParam); - if ((pssParam->hashAlg != HashAlgo::SHA512)|| - (pssParam->mgfAlg != AsymRSAMGF::MGF1_SHA512)) + hash1 = HashAlgo::SHA3_256; + break; + case AsymMech::RSA_SHA3_384_PKCS_PSS: + if (!RSAUtil::checkPssParams(mechanismParam, HashAlgo::SHA3_384, AsymRSAMGF::MGF1_SHA3_384, 48, privateKey->getBitLength(), sLen)) { - ERROR_MSG("Invalid RSA PSS mechanism parameters supplied"); ByteString dummy; AsymmetricAlgorithm::signFinal(dummy); return false; } - sLen = pssParam->sLen; - if (sLen > ((privateKey->getBitLength() + 6) / 8 - 2 - 64)) + hash1 = HashAlgo::SHA3_384; + break; + case AsymMech::RSA_SHA3_512_PKCS_PSS: + if (!RSAUtil::checkPssParams(mechanismParam, HashAlgo::SHA3_512, AsymRSAMGF::MGF1_SHA3_512, 64, privateKey->getBitLength(), sLen)) { - ERROR_MSG("sLen (%lu) is too large for current key size (%lu)", - (unsigned long)sLen, privateKey->getBitLength()); ByteString dummy; AsymmetricAlgorithm::signFinal(dummy); return false; } - hash1 = HashAlgo::SHA512; + hash1 = HashAlgo::SHA3_512; break; case AsymMech::RSA_SSL: hash1 = HashAlgo::MD5; @@ -638,6 +623,24 @@ bool OSSLRSA::signFinal(ByteString& signature) hash = EVP_sha512(); rsaPadding = RSA_PKCS1_PADDING; break; +#ifdef WITH_SHA3 + case AsymMech::RSA_SHA3_224_PKCS: + hash = EVP_sha3_224(); + rsaPadding = RSA_PKCS1_PADDING; + break; + case AsymMech::RSA_SHA3_256_PKCS: + hash = EVP_sha3_256(); + rsaPadding = RSA_PKCS1_PADDING; + break; + case AsymMech::RSA_SHA3_384_PKCS: + hash = EVP_sha3_384(); + rsaPadding = RSA_PKCS1_PADDING; + break; + case AsymMech::RSA_SHA3_512_PKCS: + hash = EVP_sha3_512(); + rsaPadding = RSA_PKCS1_PADDING; + break; +#endif case AsymMech::RSA_SHA1_PKCS_PSS: rsaPadding = RSA_PKCS1_PSS_PADDING; hash = EVP_sha1(); @@ -658,6 +661,24 @@ bool OSSLRSA::signFinal(ByteString& signature) rsaPadding = RSA_PKCS1_PSS_PADDING; hash = EVP_sha512(); break; +#ifdef WITH_SHA3 + case AsymMech::RSA_SHA3_224_PKCS_PSS: + rsaPadding = RSA_PKCS1_PSS_PADDING; + hash = EVP_sha3_224(); + break; + case AsymMech::RSA_SHA3_256_PKCS_PSS: + rsaPadding = RSA_PKCS1_PSS_PADDING; + hash = EVP_sha3_256(); + break; + case AsymMech::RSA_SHA3_384_PKCS_PSS: + rsaPadding = RSA_PKCS1_PSS_PADDING; + hash = EVP_sha3_384(); + break; + case AsymMech::RSA_SHA3_512_PKCS_PSS: + rsaPadding = RSA_PKCS1_PSS_PADDING; + hash = EVP_sha3_512(); + break; +#endif case AsymMech::RSA_SSL: rsaPadding = RSA_PKCS1_PADDING; hash = EVP_md5_sha1(); @@ -801,6 +822,24 @@ bool OSSLRSA::verify(PublicKey* publicKey, const ByteString& originalData, hash = EVP_sha512(); allowedLen = 64; break; +#ifdef WITH_SHA3 + case HashAlgo::SHA3_224: + hash = EVP_sha3_224(); + allowedLen = 28; + break; + case HashAlgo::SHA3_256: + hash = EVP_sha3_256(); + allowedLen = 32; + break; + case HashAlgo::SHA3_384: + hash = EVP_sha3_384(); + allowedLen = 48; + break; + case HashAlgo::SHA3_512: + hash = EVP_sha3_512(); + allowedLen = 64; + break; +#endif default: return false; } @@ -821,6 +860,20 @@ bool OSSLRSA::verify(PublicKey* publicKey, const ByteString& originalData, case AsymRSAMGF::MGF1_SHA512: mgf = EVP_sha512(); break; +#ifdef WITH_SHA3 + case AsymRSAMGF::MGF1_SHA3_224: + mgf = EVP_sha3_224(); + break; + case AsymRSAMGF::MGF1_SHA3_256: + mgf = EVP_sha3_256(); + break; + case AsymRSAMGF::MGF1_SHA3_384: + mgf = EVP_sha3_384(); + break; + case AsymRSAMGF::MGF1_SHA3_512: + mgf = EVP_sha3_512(); + break; +#endif default: return false; } @@ -936,8 +989,6 @@ bool OSSLRSA::verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, HashAlgo::Type hash1 = HashAlgo::Unknown; HashAlgo::Type hash2 = HashAlgo::Unknown; - const RSAPssMechanismParam* pssParam = NULL; - switch (mechanism) { case AsymMech::RSA_MD5_PKCS: @@ -958,28 +1009,21 @@ bool OSSLRSA::verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, case AsymMech::RSA_SHA512_PKCS: hash1 = HashAlgo::SHA512; break; + case AsymMech::RSA_SHA3_224_PKCS: + hash1 = HashAlgo::SHA3_224; + break; + case AsymMech::RSA_SHA3_256_PKCS: + hash1 = HashAlgo::SHA3_256; + break; + case AsymMech::RSA_SHA3_384_PKCS: + hash1 = HashAlgo::SHA3_384; + break; + case AsymMech::RSA_SHA3_512_PKCS: + hash1 = HashAlgo::SHA3_512; + break; case AsymMech::RSA_SHA1_PKCS_PSS: - if ((mechanismParam == NULL) || (!mechanismParam->isOfType(RSAPssMechanismParam::type))) - { - ERROR_MSG("Invalid RSA PSS mechanism parameter type supplied"); - ByteString dummy; - AsymmetricAlgorithm::verifyFinal(dummy); - return false; - } - pssParam = dynamic_cast(mechanismParam); - if ((pssParam->hashAlg != HashAlgo::SHA1)|| - (pssParam->mgfAlg != AsymRSAMGF::MGF1_SHA1)) + if (!RSAUtil::checkPssParams(mechanismParam, HashAlgo::SHA1, AsymRSAMGF::MGF1_SHA1, 20, publicKey->getBitLength(), sLen)) { - ERROR_MSG("Invalid RSA PSS mechanism parameters supplied"); - ByteString dummy; - AsymmetricAlgorithm::verifyFinal(dummy); - return false; - } - sLen = pssParam->sLen; - if (sLen > ((publicKey->getBitLength() + 6) / 8 - 2 - 20)) - { - ERROR_MSG("sLen (%lu) is too large for current key size (%lu)", - (unsigned long)sLen, publicKey->getBitLength()); ByteString dummy; AsymmetricAlgorithm::verifyFinal(dummy); return false; @@ -987,27 +1031,8 @@ bool OSSLRSA::verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, hash1 = HashAlgo::SHA1; break; case AsymMech::RSA_SHA224_PKCS_PSS: - if ((mechanismParam == NULL) || (!mechanismParam->isOfType(RSAPssMechanismParam::type))) + if (!RSAUtil::checkPssParams(mechanismParam, HashAlgo::SHA224, AsymRSAMGF::MGF1_SHA224, 28, publicKey->getBitLength(), sLen)) { - ERROR_MSG("Invalid RSA PSS mechanism parameter type supplied"); - ByteString dummy; - AsymmetricAlgorithm::verifyFinal(dummy); - return false; - } - pssParam = dynamic_cast(mechanismParam); - if ((pssParam->hashAlg != HashAlgo::SHA224)|| - (pssParam->mgfAlg != AsymRSAMGF::MGF1_SHA224)) - { - ERROR_MSG("Invalid RSA PSS mechanism parameters supplied"); - ByteString dummy; - AsymmetricAlgorithm::verifyFinal(dummy); - return false; - } - sLen = pssParam->sLen; - if (sLen > ((publicKey->getBitLength() + 6) / 8 - 2 - 28)) - { - ERROR_MSG("sLen (%lu) is too large for current key size (%lu)", - (unsigned long)sLen, publicKey->getBitLength()); ByteString dummy; AsymmetricAlgorithm::verifyFinal(dummy); return false; @@ -1015,88 +1040,67 @@ bool OSSLRSA::verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, hash1 = HashAlgo::SHA224; break; case AsymMech::RSA_SHA256_PKCS_PSS: - if ((mechanismParam == NULL) || (!mechanismParam->isOfType(RSAPssMechanismParam::type))) - { - ERROR_MSG("Invalid RSA PSS mechanism parameter type supplied"); - ByteString dummy; - AsymmetricAlgorithm::verifyFinal(dummy); - return false; - } - pssParam = dynamic_cast(mechanismParam); - if ((pssParam->hashAlg != HashAlgo::SHA256)|| - (pssParam->mgfAlg != AsymRSAMGF::MGF1_SHA256)) + if (!RSAUtil::checkPssParams(mechanismParam, HashAlgo::SHA256, AsymRSAMGF::MGF1_SHA256, 32, publicKey->getBitLength(), sLen)) { - ERROR_MSG("Invalid RSA PSS mechanism parameters supplied"); ByteString dummy; AsymmetricAlgorithm::verifyFinal(dummy); return false; } - sLen = pssParam->sLen; - if (sLen > ((publicKey->getBitLength() + 6) / 8 - 2 - 32)) + hash1 = HashAlgo::SHA256; + break; + case AsymMech::RSA_SHA384_PKCS_PSS: + if (!RSAUtil::checkPssParams(mechanismParam, HashAlgo::SHA384, AsymRSAMGF::MGF1_SHA384, 48, publicKey->getBitLength(), sLen)) { - ERROR_MSG("sLen (%lu) is too large for current key size (%lu)", - (unsigned long)sLen, publicKey->getBitLength()); ByteString dummy; AsymmetricAlgorithm::verifyFinal(dummy); return false; } - hash1 = HashAlgo::SHA256; + hash1 = HashAlgo::SHA384; break; - case AsymMech::RSA_SHA384_PKCS_PSS: - if ((mechanismParam == NULL) || (!mechanismParam->isOfType(RSAPssMechanismParam::type))) + case AsymMech::RSA_SHA512_PKCS_PSS: + if (!RSAUtil::checkPssParams(mechanismParam, HashAlgo::SHA512, AsymRSAMGF::MGF1_SHA512, 64, publicKey->getBitLength(), sLen)) { - ERROR_MSG("Invalid RSA PSS mechanism parameter type supplied"); ByteString dummy; AsymmetricAlgorithm::verifyFinal(dummy); return false; } - pssParam = dynamic_cast(mechanismParam); - if ((pssParam->hashAlg != HashAlgo::SHA384)|| - (pssParam->mgfAlg != AsymRSAMGF::MGF1_SHA384)) + hash1 = HashAlgo::SHA512; + break; + case AsymMech::RSA_SHA3_224_PKCS_PSS: + if (!RSAUtil::checkPssParams(mechanismParam, HashAlgo::SHA3_224, AsymRSAMGF::MGF1_SHA3_224, 28, publicKey->getBitLength(), sLen)) { - ERROR_MSG("Invalid RSA PSS mechanism parameters supplied"); ByteString dummy; AsymmetricAlgorithm::verifyFinal(dummy); return false; } - sLen = pssParam->sLen; - if (sLen > ((publicKey->getBitLength() + 6) / 8 - 2 - 48)) - { - ERROR_MSG("sLen (%lu) is too large for current key size (%lu)", - (unsigned long)sLen, publicKey->getBitLength()); - ByteString dummy; - AsymmetricAlgorithm::verifyFinal(dummy); - return false; - } - hash1 = HashAlgo::SHA384; + hash1 = HashAlgo::SHA3_224; break; - case AsymMech::RSA_SHA512_PKCS_PSS: - if ((mechanismParam == NULL) || (!mechanismParam->isOfType(RSAPssMechanismParam::type))) + case AsymMech::RSA_SHA3_256_PKCS_PSS: + if (!RSAUtil::checkPssParams(mechanismParam, HashAlgo::SHA3_256, AsymRSAMGF::MGF1_SHA3_256, 32, publicKey->getBitLength(), sLen)) { - ERROR_MSG("Invalid RSA PSS mechanism parameter type supplied"); ByteString dummy; AsymmetricAlgorithm::verifyFinal(dummy); return false; } - pssParam = dynamic_cast(mechanismParam); - if ((pssParam->hashAlg != HashAlgo::SHA512)|| - (pssParam->mgfAlg != AsymRSAMGF::MGF1_SHA512)) + hash1 = HashAlgo::SHA3_256; + break; + case AsymMech::RSA_SHA3_384_PKCS_PSS: + if (!RSAUtil::checkPssParams(mechanismParam, HashAlgo::SHA3_384, AsymRSAMGF::MGF1_SHA3_384, 48, publicKey->getBitLength(), sLen)) { - ERROR_MSG("Invalid RSA PSS mechanism parameters supplied"); ByteString dummy; AsymmetricAlgorithm::verifyFinal(dummy); return false; } - sLen = pssParam->sLen; - if (sLen > ((publicKey->getBitLength() + 6) / 8 - 2 - 64)) + hash1 = HashAlgo::SHA3_384; + break; + case AsymMech::RSA_SHA3_512_PKCS_PSS: + if (!RSAUtil::checkPssParams(mechanismParam, HashAlgo::SHA3_512, AsymRSAMGF::MGF1_SHA3_512, 64, publicKey->getBitLength(), sLen)) { - ERROR_MSG("sLen (%lu) is too large for current key size (%lu)", - (unsigned long)sLen, publicKey->getBitLength()); ByteString dummy; AsymmetricAlgorithm::verifyFinal(dummy); return false; } - hash1 = HashAlgo::SHA512; + hash1 = HashAlgo::SHA3_512; break; case AsymMech::RSA_SSL: hash1 = HashAlgo::MD5; @@ -1249,6 +1253,24 @@ bool OSSLRSA::verifyFinal(const ByteString& signature) rsaPadding = RSA_PKCS1_PADDING; hash = EVP_sha512(); break; +#ifdef WITH_SHA3 + case AsymMech::RSA_SHA3_224_PKCS: + rsaPadding = RSA_PKCS1_PADDING; + hash = EVP_sha3_224(); + break; + case AsymMech::RSA_SHA3_256_PKCS: + rsaPadding = RSA_PKCS1_PADDING; + hash = EVP_sha3_256(); + break; + case AsymMech::RSA_SHA3_384_PKCS: + rsaPadding = RSA_PKCS1_PADDING; + hash = EVP_sha3_384(); + break; + case AsymMech::RSA_SHA3_512_PKCS: + rsaPadding = RSA_PKCS1_PADDING; + hash = EVP_sha3_512(); + break; +#endif case AsymMech::RSA_SHA1_PKCS_PSS: rsaPadding = RSA_PKCS1_PSS_PADDING; hash = EVP_sha1(); @@ -1269,6 +1291,24 @@ bool OSSLRSA::verifyFinal(const ByteString& signature) rsaPadding = RSA_PKCS1_PSS_PADDING; hash = EVP_sha512(); break; +#ifdef WITH_SHA3 + case AsymMech::RSA_SHA3_224_PKCS_PSS: + rsaPadding = RSA_PKCS1_PSS_PADDING; + hash = EVP_sha3_224(); + break; + case AsymMech::RSA_SHA3_256_PKCS_PSS: + rsaPadding = RSA_PKCS1_PSS_PADDING; + hash = EVP_sha3_256(); + break; + case AsymMech::RSA_SHA3_384_PKCS_PSS: + rsaPadding = RSA_PKCS1_PSS_PADDING; + hash = EVP_sha3_384(); + break; + case AsymMech::RSA_SHA3_512_PKCS_PSS: + rsaPadding = RSA_PKCS1_PSS_PADDING; + hash = EVP_sha3_512(); + break; +#endif case AsymMech::RSA_SSL: rsaPadding = RSA_PKCS1_PADDING; hash = EVP_md5_sha1(); @@ -1385,6 +1425,24 @@ bool OSSLRSA::encrypt(PublicKey* publicKey, const ByteString& data, hash = EVP_sha512(); hashLen = 64; break; +#ifdef WITH_SHA3 + case HashAlgo::SHA3_224: + hash = EVP_sha3_224(); + hashLen = 28; + break; + case HashAlgo::SHA3_256: + hash = EVP_sha3_256(); + hashLen = 32; + break; + case HashAlgo::SHA3_384: + hash = EVP_sha3_384(); + hashLen = 48; + break; + case HashAlgo::SHA3_512: + hash = EVP_sha3_512(); + hashLen = 64; + break; +#endif default: return false; } @@ -1405,6 +1463,20 @@ bool OSSLRSA::encrypt(PublicKey* publicKey, const ByteString& data, case AsymRSAMGF::MGF1_SHA512: mgf = EVP_sha512(); break; +#ifdef WITH_SHA3 + case AsymRSAMGF::MGF1_SHA3_224: + mgf = EVP_sha3_224(); + break; + case AsymRSAMGF::MGF1_SHA3_256: + mgf = EVP_sha3_256(); + break; + case AsymRSAMGF::MGF1_SHA3_384: + mgf = EVP_sha3_384(); + break; + case AsymRSAMGF::MGF1_SHA3_512: + mgf = EVP_sha3_512(); + break; +#endif default: return false; } @@ -1555,6 +1627,20 @@ bool OSSLRSA::decrypt(PrivateKey* privateKey, const ByteString& encryptedData, case HashAlgo::SHA512: hash = EVP_sha512(); break; +#ifdef WITH_SHA3 + case HashAlgo::SHA3_224: + hash = EVP_sha3_224(); + break; + case HashAlgo::SHA3_256: + hash = EVP_sha3_256(); + break; + case HashAlgo::SHA3_384: + hash = EVP_sha3_384(); + break; + case HashAlgo::SHA3_512: + hash = EVP_sha3_512(); + break; +#endif default: return false; } @@ -1575,6 +1661,20 @@ bool OSSLRSA::decrypt(PrivateKey* privateKey, const ByteString& encryptedData, case AsymRSAMGF::MGF1_SHA512: mgf = EVP_sha512(); break; +#ifdef WITH_SHA3 + case AsymRSAMGF::MGF1_SHA3_224: + mgf = EVP_sha3_224(); + break; + case AsymRSAMGF::MGF1_SHA3_256: + mgf = EVP_sha3_256(); + break; + case AsymRSAMGF::MGF1_SHA3_384: + mgf = EVP_sha3_384(); + break; + case AsymRSAMGF::MGF1_SHA3_512: + mgf = EVP_sha3_512(); + break; +#endif default: return false; } diff --git a/src/lib/crypto/OSSLSHA3_224.cpp b/src/lib/crypto/OSSLSHA3_224.cpp new file mode 100644 index 000000000..5c4bb2742 --- /dev/null +++ b/src/lib/crypto/OSSLSHA3_224.cpp @@ -0,0 +1,27 @@ +/* + * Copyright (c) 2026 SoftHSMv2 contributors + * + * SPDX-License-Identifier: BSD-2-Clause + */ + +/***************************************************************************** + OSSLSHA3_224.cpp + + OpenSSL SHA3-224 implementation + *****************************************************************************/ + +#include "config.h" +#ifdef WITH_SHA3 +#include "OSSLSHA3_224.h" +#include + +int OSSLSHA3_224::getHashSize() +{ + return 28; +} + +const EVP_MD* OSSLSHA3_224::getEVPHash() const +{ + return EVP_sha3_224(); +} +#endif diff --git a/src/lib/crypto/OSSLSHA3_224.h b/src/lib/crypto/OSSLSHA3_224.h new file mode 100644 index 000000000..0c9859dca --- /dev/null +++ b/src/lib/crypto/OSSLSHA3_224.h @@ -0,0 +1,27 @@ +/* + * Copyright (c) 2026 SoftHSMv2 contributors + * + * SPDX-License-Identifier: BSD-2-Clause + */ + +/***************************************************************************** + OSSLSHA3_224.h + + OpenSSL SHA3-224 implementation + *****************************************************************************/ + +#ifndef _SOFTHSM_V2_OSSLSHA3_224_H +#define _SOFTHSM_V2_OSSLSHA3_224_H + +#include "config.h" +#include "OSSLEVPHashAlgorithm.h" +#include + +class OSSLSHA3_224 : public OSSLEVPHashAlgorithm +{ + virtual int getHashSize(); +protected: + virtual const EVP_MD* getEVPHash() const; +}; + +#endif // !_SOFTHSM_V2_OSSLSHA3_224_H diff --git a/src/lib/crypto/OSSLSHA3_256.cpp b/src/lib/crypto/OSSLSHA3_256.cpp new file mode 100644 index 000000000..cc8cae1e0 --- /dev/null +++ b/src/lib/crypto/OSSLSHA3_256.cpp @@ -0,0 +1,27 @@ +/* + * Copyright (c) 2026 SoftHSMv2 contributors + * + * SPDX-License-Identifier: BSD-2-Clause + */ + +/***************************************************************************** + OSSLSHA3_256.cpp + + OpenSSL SHA3-256 implementation + *****************************************************************************/ + +#include "config.h" +#ifdef WITH_SHA3 +#include "OSSLSHA3_256.h" +#include + +int OSSLSHA3_256::getHashSize() +{ + return 32; +} + +const EVP_MD* OSSLSHA3_256::getEVPHash() const +{ + return EVP_sha3_256(); +} +#endif diff --git a/src/lib/crypto/OSSLSHA3_256.h b/src/lib/crypto/OSSLSHA3_256.h new file mode 100644 index 000000000..683e52d92 --- /dev/null +++ b/src/lib/crypto/OSSLSHA3_256.h @@ -0,0 +1,27 @@ +/* + * Copyright (c) 2026 SoftHSMv2 contributors + * + * SPDX-License-Identifier: BSD-2-Clause + */ + +/***************************************************************************** + OSSLSHA3_256.h + + OpenSSL SHA3-256 implementation + *****************************************************************************/ + +#ifndef _SOFTHSM_V2_OSSLSHA3_256_H +#define _SOFTHSM_V2_OSSLSHA3_256_H + +#include "config.h" +#include "OSSLEVPHashAlgorithm.h" +#include + +class OSSLSHA3_256 : public OSSLEVPHashAlgorithm +{ + virtual int getHashSize(); +protected: + virtual const EVP_MD* getEVPHash() const; +}; + +#endif // !_SOFTHSM_V2_OSSLSHA3_256_H diff --git a/src/lib/crypto/OSSLSHA3_384.cpp b/src/lib/crypto/OSSLSHA3_384.cpp new file mode 100644 index 000000000..3746aac77 --- /dev/null +++ b/src/lib/crypto/OSSLSHA3_384.cpp @@ -0,0 +1,27 @@ +/* + * Copyright (c) 2026 SoftHSMv2 contributors + * + * SPDX-License-Identifier: BSD-2-Clause + */ + +/***************************************************************************** + OSSLSHA3_384.cpp + + OpenSSL SHA3-384 implementation + *****************************************************************************/ + +#include "config.h" +#ifdef WITH_SHA3 +#include "OSSLSHA3_384.h" +#include + +int OSSLSHA3_384::getHashSize() +{ + return 48; +} + +const EVP_MD* OSSLSHA3_384::getEVPHash() const +{ + return EVP_sha3_384(); +} +#endif diff --git a/src/lib/crypto/OSSLSHA3_384.h b/src/lib/crypto/OSSLSHA3_384.h new file mode 100644 index 000000000..957c740cd --- /dev/null +++ b/src/lib/crypto/OSSLSHA3_384.h @@ -0,0 +1,27 @@ +/* + * Copyright (c) 2026 SoftHSMv2 contributors + * + * SPDX-License-Identifier: BSD-2-Clause + */ + +/***************************************************************************** + OSSLSHA3_384.h + + OpenSSL SHA3-384 implementation + *****************************************************************************/ + +#ifndef _SOFTHSM_V2_OSSLSHA3_384_H +#define _SOFTHSM_V2_OSSLSHA3_384_H + +#include "config.h" +#include "OSSLEVPHashAlgorithm.h" +#include + +class OSSLSHA3_384 : public OSSLEVPHashAlgorithm +{ + virtual int getHashSize(); +protected: + virtual const EVP_MD* getEVPHash() const; +}; + +#endif // !_SOFTHSM_V2_OSSLSHA3_384_H diff --git a/src/lib/crypto/OSSLSHA3_512.cpp b/src/lib/crypto/OSSLSHA3_512.cpp new file mode 100644 index 000000000..d51bfadf0 --- /dev/null +++ b/src/lib/crypto/OSSLSHA3_512.cpp @@ -0,0 +1,27 @@ +/* + * Copyright (c) 2026 SoftHSMv2 contributors + * + * SPDX-License-Identifier: BSD-2-Clause + */ + +/***************************************************************************** + OSSLSHA3_512.cpp + + OpenSSL SHA3-512 implementation + *****************************************************************************/ + +#include "config.h" +#ifdef WITH_SHA3 +#include "OSSLSHA3_512.h" +#include + +int OSSLSHA3_512::getHashSize() +{ + return 64; +} + +const EVP_MD* OSSLSHA3_512::getEVPHash() const +{ + return EVP_sha3_512(); +} +#endif diff --git a/src/lib/crypto/OSSLSHA3_512.h b/src/lib/crypto/OSSLSHA3_512.h new file mode 100644 index 000000000..d546f90e8 --- /dev/null +++ b/src/lib/crypto/OSSLSHA3_512.h @@ -0,0 +1,27 @@ +/* + * Copyright (c) 2026 SoftHSMv2 contributors + * + * SPDX-License-Identifier: BSD-2-Clause + */ + +/***************************************************************************** + OSSLSHA3_512.h + + OpenSSL SHA3-512 implementation + *****************************************************************************/ + +#ifndef _SOFTHSM_V2_OSSLSHA3_512_H +#define _SOFTHSM_V2_OSSLSHA3_512_H + +#include "config.h" +#include "OSSLEVPHashAlgorithm.h" +#include + +class OSSLSHA3_512 : public OSSLEVPHashAlgorithm +{ + virtual int getHashSize(); +protected: + virtual const EVP_MD* getEVPHash() const; +}; + +#endif // !_SOFTHSM_V2_OSSLSHA3_512_H diff --git a/src/lib/crypto/RSAUtil.cpp b/src/lib/crypto/RSAUtil.cpp new file mode 100644 index 000000000..c4e7c4efc --- /dev/null +++ b/src/lib/crypto/RSAUtil.cpp @@ -0,0 +1,40 @@ +/* + * Copyright (c) 2026 SoftHSMv2 contributors + * + * SPDX-License-Identifier: BSD-2-Clause + */ +/***************************************************************************** + RSAUtil.cpp + + RSA convenience functions + *****************************************************************************/ + +#include "config.h" +#include "log.h" +#include "RSAUtil.h" +#include "RSAMechanismParam.h" + +/*static*/ bool RSAUtil::checkPssParams(const MechanismParam* mechanismParam, HashAlgo::Type hashAlg, + AsymRSAMGF::Type mgfAlg, size_t digestSize, size_t keyBitLength, + size_t& sLen) +{ + if ((mechanismParam == NULL) || (!mechanismParam->isOfType(RSAPssMechanismParam::type))) + { + ERROR_MSG("Invalid RSA PSS mechanism parameter type supplied"); + return false; + } + const RSAPssMechanismParam* pssParam = dynamic_cast(mechanismParam); + if ((pssParam->hashAlg != hashAlg) || (pssParam->mgfAlg != mgfAlg)) + { + ERROR_MSG("Invalid RSA PSS mechanism parameters supplied"); + return false; + } + sLen = pssParam->sLen; + if (sLen > ((keyBitLength + 6) / 8 - 2 - digestSize)) + { + ERROR_MSG("sLen (%lu) is too large for current key size (%lu)", + (unsigned long)sLen, keyBitLength); + return false; + } + return true; +} diff --git a/src/lib/crypto/RSAUtil.h b/src/lib/crypto/RSAUtil.h new file mode 100644 index 000000000..e4cea328e --- /dev/null +++ b/src/lib/crypto/RSAUtil.h @@ -0,0 +1,31 @@ +/* + * Copyright (c) 2026 SoftHSMv2 contributors + * + * SPDX-License-Identifier: BSD-2-Clause + */ +/***************************************************************************** + RSAUtil.h + + RSA convenience functions + *****************************************************************************/ + +#ifndef _SOFTHSM_V2_RSAUTIL_H +#define _SOFTHSM_V2_RSAUTIL_H + +#include "config.h" +#include "AsymmetricAlgorithm.h" +#include "HashAlgorithm.h" +#include "MechanismParam.h" + +class RSAUtil +{ +public: + RSAUtil() = delete; + + // Validate an RSA-PSS mechanism parameter against the expected hash/MGF algorithm and + // check that the requested salt length fits the key size. Returns the salt length in sLen + // on success; logs an ERROR_MSG and returns false otherwise. + static bool checkPssParams(const MechanismParam* mechanismParam, HashAlgo::Type hashAlg, AsymRSAMGF::Type mgfAlg, size_t digestSize, size_t keyBitLength, size_t& sLen); +}; + +#endif // !_SOFTHSM_V2_RSAUTIL_H diff --git a/src/lib/crypto/test/HashTests.cpp b/src/lib/crypto/test/HashTests.cpp index f02adbc09..70b151f4c 100644 --- a/src/lib/crypto/test/HashTests.cpp +++ b/src/lib/crypto/test/HashTests.cpp @@ -233,6 +233,112 @@ void HashTests::testSHA384() rng = NULL; } +#ifdef WITH_SHA3 +void HashTests::testSHA3_224() +{ + CPPUNIT_ASSERT((hash = CryptoFactory::i()->getHashAlgorithm(HashAlgo::SHA3_224)) != NULL); + + ByteString empty(""), abc("616263"); + ByteString emptyExpected("6B4E03423667DBB73B6E15454F0EB1ABD4597F9A1B078E3F5B5A6BC7"); + ByteString abcExpected("E642824C3F8CF24AD09234EE7D3C766FC9A3A5168D0C94AD73B46FDF"); + ByteString shsmHash; + + CPPUNIT_ASSERT(hash->hashInit()); + CPPUNIT_ASSERT(hash->hashUpdate(empty)); + CPPUNIT_ASSERT(hash->hashFinal(shsmHash)); + CPPUNIT_ASSERT(emptyExpected == shsmHash); + + shsmHash.wipe(); + CPPUNIT_ASSERT(hash->hashInit()); + CPPUNIT_ASSERT(hash->hashUpdate(abc.substr(0, 1))); + CPPUNIT_ASSERT(hash->hashUpdate(abc.substr(1, 1))); + CPPUNIT_ASSERT(hash->hashUpdate(abc.substr(2))); + CPPUNIT_ASSERT(hash->hashFinal(shsmHash)); + CPPUNIT_ASSERT(abcExpected == shsmHash); + + CryptoFactory::i()->recycleHashAlgorithm(hash); + hash = NULL; +} + +void HashTests::testSHA3_256() +{ + CPPUNIT_ASSERT((hash = CryptoFactory::i()->getHashAlgorithm(HashAlgo::SHA3_256)) != NULL); + + ByteString empty(""), abc("616263"); + ByteString emptyExpected("A7FFC6F8BF1ED76651C14756A061D662F580FF4DE43B49FA82D80A4B80F8434A"); + ByteString abcExpected("3A985DA74FE225B2045C172D6BD390BD855F086E3E9D525B46BFE24511431532"); + ByteString shsmHash; + + CPPUNIT_ASSERT(hash->hashInit()); + CPPUNIT_ASSERT(hash->hashUpdate(empty)); + CPPUNIT_ASSERT(hash->hashFinal(shsmHash)); + CPPUNIT_ASSERT(emptyExpected == shsmHash); + + shsmHash.wipe(); + CPPUNIT_ASSERT(hash->hashInit()); + CPPUNIT_ASSERT(hash->hashUpdate(abc.substr(0, 1))); + CPPUNIT_ASSERT(hash->hashUpdate(abc.substr(1, 1))); + CPPUNIT_ASSERT(hash->hashUpdate(abc.substr(2))); + CPPUNIT_ASSERT(hash->hashFinal(shsmHash)); + CPPUNIT_ASSERT(abcExpected == shsmHash); + + CryptoFactory::i()->recycleHashAlgorithm(hash); + hash = NULL; +} + +void HashTests::testSHA3_384() +{ + CPPUNIT_ASSERT((hash = CryptoFactory::i()->getHashAlgorithm(HashAlgo::SHA3_384)) != NULL); + + ByteString empty(""), abc("616263"); + ByteString emptyExpected("0C63A75B845E4F7D01107D852E4C2485C51A50AAAA94FC61995E71BBEE983A2AC3713831264ADB47FB6BD1E058D5F004"); + ByteString abcExpected("EC01498288516FC926459F58E2C6AD8DF9B473CB0FC08C2596DA7CF0E49BE4B298D88CEA927AC7F539F1EDF228376D25"); + ByteString shsmHash; + + CPPUNIT_ASSERT(hash->hashInit()); + CPPUNIT_ASSERT(hash->hashUpdate(empty)); + CPPUNIT_ASSERT(hash->hashFinal(shsmHash)); + CPPUNIT_ASSERT(emptyExpected == shsmHash); + + shsmHash.wipe(); + CPPUNIT_ASSERT(hash->hashInit()); + CPPUNIT_ASSERT(hash->hashUpdate(abc.substr(0, 1))); + CPPUNIT_ASSERT(hash->hashUpdate(abc.substr(1, 1))); + CPPUNIT_ASSERT(hash->hashUpdate(abc.substr(2))); + CPPUNIT_ASSERT(hash->hashFinal(shsmHash)); + CPPUNIT_ASSERT(abcExpected == shsmHash); + + CryptoFactory::i()->recycleHashAlgorithm(hash); + hash = NULL; +} + +void HashTests::testSHA3_512() +{ + CPPUNIT_ASSERT((hash = CryptoFactory::i()->getHashAlgorithm(HashAlgo::SHA3_512)) != NULL); + + ByteString empty(""), abc("616263"); + ByteString emptyExpected("A69F73CCA23A9AC5C8B567DC185A756E97C982164FE25859E0D1DCC1475C80A615B2123AF1F5F94C11E3E9402C3AC558F500199D95B6D3E301758586281DCD26"); + ByteString abcExpected("B751850B1A57168A5693CD924B6B096E08F621827444F70D884F5D0240D2712E10E116E9192AF3C91A7EC57647E3934057340B4CF408D5A56592F8274EEC53F0"); + ByteString shsmHash; + + CPPUNIT_ASSERT(hash->hashInit()); + CPPUNIT_ASSERT(hash->hashUpdate(empty)); + CPPUNIT_ASSERT(hash->hashFinal(shsmHash)); + CPPUNIT_ASSERT(emptyExpected == shsmHash); + + shsmHash.wipe(); + CPPUNIT_ASSERT(hash->hashInit()); + CPPUNIT_ASSERT(hash->hashUpdate(abc.substr(0, 1))); + CPPUNIT_ASSERT(hash->hashUpdate(abc.substr(1, 1))); + CPPUNIT_ASSERT(hash->hashUpdate(abc.substr(2))); + CPPUNIT_ASSERT(hash->hashFinal(shsmHash)); + CPPUNIT_ASSERT(abcExpected == shsmHash); + + CryptoFactory::i()->recycleHashAlgorithm(hash); + hash = NULL; +} +#endif + void HashTests::testSHA512() { char testData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diff --git a/src/lib/crypto/test/HashTests.h b/src/lib/crypto/test/HashTests.h index dd6566d27..639367cf8 100644 --- a/src/lib/crypto/test/HashTests.h +++ b/src/lib/crypto/test/HashTests.h @@ -47,6 +47,12 @@ class HashTests : public CppUnit::TestFixture CPPUNIT_TEST(testSHA224); CPPUNIT_TEST(testSHA256); CPPUNIT_TEST(testSHA384); +#ifdef WITH_SHA3 + CPPUNIT_TEST(testSHA3_224); + CPPUNIT_TEST(testSHA3_256); + CPPUNIT_TEST(testSHA3_384); + CPPUNIT_TEST(testSHA3_512); +#endif CPPUNIT_TEST(testSHA512); CPPUNIT_TEST_SUITE_END(); @@ -58,6 +64,12 @@ class HashTests : public CppUnit::TestFixture void testSHA224(); void testSHA256(); void testSHA384(); +#ifdef WITH_SHA3 + void testSHA3_224(); + void testSHA3_256(); + void testSHA3_384(); + void testSHA3_512(); +#endif void testSHA512(); void setUp(); diff --git a/src/lib/test/AsymEncryptDecryptTests.cpp b/src/lib/test/AsymEncryptDecryptTests.cpp index 279b35f2f..fe16986f6 100644 --- a/src/lib/test/AsymEncryptDecryptTests.cpp +++ b/src/lib/test/AsymEncryptDecryptTests.cpp @@ -253,4 +253,26 @@ void AsymEncryptDecryptTests::testRsaEncryptDecrypt() oaepParams.pSourceData = (void*)EncryptLabel; oaepParams.ulSourceDataLen = strlen(EncryptLabel); rsaEncryptDecrypt(CKM_RSA_PKCS_OAEP,hSessionRO,hPublicKey,hPrivateKey,&oaepParams); +#ifdef WITH_SHA3 + oaepParams = { CKM_SHA3_224, CKG_MGF1_SHA3_224, 1, NULL_PTR, 0 }; + rsaEncryptDecrypt(CKM_RSA_PKCS_OAEP,hSessionRO,hPublicKey,hPrivateKey,&oaepParams); + oaepParams.pSourceData = (void*)EncryptLabel; + oaepParams.ulSourceDataLen = strlen(EncryptLabel); + rsaEncryptDecrypt(CKM_RSA_PKCS_OAEP,hSessionRO,hPublicKey,hPrivateKey,&oaepParams); + oaepParams = { CKM_SHA3_256, CKG_MGF1_SHA3_256, 1, NULL_PTR, 0 }; + rsaEncryptDecrypt(CKM_RSA_PKCS_OAEP,hSessionRO,hPublicKey,hPrivateKey,&oaepParams); + oaepParams.pSourceData = (void*)EncryptLabel; + oaepParams.ulSourceDataLen = strlen(EncryptLabel); + rsaEncryptDecrypt(CKM_RSA_PKCS_OAEP,hSessionRO,hPublicKey,hPrivateKey,&oaepParams); + oaepParams = { CKM_SHA3_384, CKG_MGF1_SHA3_384, 1, NULL_PTR, 0 }; + rsaEncryptDecrypt(CKM_RSA_PKCS_OAEP,hSessionRO,hPublicKey,hPrivateKey,&oaepParams); + oaepParams.pSourceData = (void*)EncryptLabel; + oaepParams.ulSourceDataLen = strlen(EncryptLabel); + rsaEncryptDecrypt(CKM_RSA_PKCS_OAEP,hSessionRO,hPublicKey,hPrivateKey,&oaepParams); + oaepParams = { CKM_SHA3_512, CKG_MGF1_SHA3_512, 1, NULL_PTR, 0 }; + rsaEncryptDecrypt(CKM_RSA_PKCS_OAEP,hSessionRO,hPublicKey,hPrivateKey,&oaepParams); + oaepParams.pSourceData = (void*)EncryptLabel; + oaepParams.ulSourceDataLen = strlen(EncryptLabel); + rsaEncryptDecrypt(CKM_RSA_PKCS_OAEP,hSessionRO,hPublicKey,hPrivateKey,&oaepParams); +#endif } diff --git a/src/lib/test/DigestTests.cpp b/src/lib/test/DigestTests.cpp index b5e7e7ef4..5606d62a5 100644 --- a/src/lib/test/DigestTests.cpp +++ b/src/lib/test/DigestTests.cpp @@ -292,6 +292,12 @@ void DigestTests::testDigestAll() { CKM_SHA256, NULL_PTR, 0 }, { CKM_SHA384, NULL_PTR, 0 }, { CKM_SHA512, NULL_PTR, 0 }, +#ifdef WITH_SHA3 + { CKM_SHA3_224, NULL_PTR, 0 }, + { CKM_SHA3_256, NULL_PTR, 0 }, + { CKM_SHA3_384, NULL_PTR, 0 }, + { CKM_SHA3_512, NULL_PTR, 0 }, +#endif #ifdef WITH_GOST { CKM_GOSTR3411, NULL_PTR, 0 }, #endif diff --git a/src/lib/test/SignVerifyTests.cpp b/src/lib/test/SignVerifyTests.cpp index 222d79b67..8684b946d 100644 --- a/src/lib/test/SignVerifyTests.cpp +++ b/src/lib/test/SignVerifyTests.cpp @@ -388,7 +388,13 @@ void SignVerifyTests::testRsaSignVerify() { CKM_SHA224, CKG_MGF1_SHA224, 28 }, { CKM_SHA256, CKG_MGF1_SHA256, 32 }, { CKM_SHA384, CKG_MGF1_SHA384, 0 }, - { CKM_SHA512, CKG_MGF1_SHA512, 0 } + { CKM_SHA512, CKG_MGF1_SHA512, 0 }, +#ifdef WITH_SHA3 + { CKM_SHA3_224, CKG_MGF1_SHA3_224, 28 }, + { CKM_SHA3_256, CKG_MGF1_SHA3_256, 32 }, + { CKM_SHA3_384, CKG_MGF1_SHA3_384, 48 }, + { CKM_SHA3_512, CKG_MGF1_SHA3_512, 64 } +#endif }; // Just make sure that we finalize any previous tests @@ -431,6 +437,12 @@ void SignVerifyTests::testRsaSignVerify() signVerifyMulti(CKM_SHA256_RSA_PKCS, hSessionRO, hPuk,hPrk); signVerifyMulti(CKM_SHA384_RSA_PKCS, hSessionRO, hPuk,hPrk); signVerifyMulti(CKM_SHA512_RSA_PKCS, hSessionRO, hPuk,hPrk); +#ifdef WITH_SHA3 + signVerifyMulti(CKM_SHA3_224_RSA_PKCS, hSessionRO, hPuk,hPrk); + signVerifyMulti(CKM_SHA3_256_RSA_PKCS, hSessionRO, hPuk,hPrk); + signVerifyMulti(CKM_SHA3_384_RSA_PKCS, hSessionRO, hPuk,hPrk); + signVerifyMulti(CKM_SHA3_512_RSA_PKCS, hSessionRO, hPuk,hPrk); +#endif #ifdef WITH_RAW_PSS signVerifySingleData(20, CKM_RSA_PKCS_PSS, hSessionRO, hPuk,hPrk, ¶ms[0], sizeof(params[0])); @@ -438,6 +450,12 @@ void SignVerifyTests::testRsaSignVerify() signVerifySingleData(32, CKM_RSA_PKCS_PSS, hSessionRO, hPuk,hPrk, ¶ms[2], sizeof(params[2])); signVerifySingleData(48, CKM_RSA_PKCS_PSS, hSessionRO, hPuk,hPrk, ¶ms[3], sizeof(params[3])); signVerifySingleData(64, CKM_RSA_PKCS_PSS, hSessionRO, hPuk,hPrk, ¶ms[4], sizeof(params[4])); +#ifdef WITH_SHA3 + signVerifySingleData(28, CKM_RSA_PKCS_PSS, hSessionRO, hPuk,hPrk, ¶ms[5], sizeof(params[5])); + signVerifySingleData(32, CKM_RSA_PKCS_PSS, hSessionRO, hPuk,hPrk, ¶ms[6], sizeof(params[6])); + signVerifySingleData(48, CKM_RSA_PKCS_PSS, hSessionRO, hPuk,hPrk, ¶ms[7], sizeof(params[7])); + signVerifySingleData(64, CKM_RSA_PKCS_PSS, hSessionRO, hPuk,hPrk, ¶ms[8], sizeof(params[8])); +#endif #endif signVerifyMulti(CKM_SHA1_RSA_PKCS_PSS, hSessionRO, hPuk,hPrk, ¶ms[0], sizeof(params[0])); @@ -445,6 +463,12 @@ void SignVerifyTests::testRsaSignVerify() signVerifyMulti(CKM_SHA256_RSA_PKCS_PSS, hSessionRO, hPuk,hPrk, ¶ms[2], sizeof(params[2])); signVerifyMulti(CKM_SHA384_RSA_PKCS_PSS, hSessionRO, hPuk,hPrk, ¶ms[3], sizeof(params[3])); signVerifyMulti(CKM_SHA512_RSA_PKCS_PSS, hSessionRO, hPuk,hPrk, ¶ms[4], sizeof(params[4])); +#ifdef WITH_SHA3 + signVerifyMulti(CKM_SHA3_224_RSA_PKCS_PSS, hSessionRO, hPuk,hPrk, ¶ms[5], sizeof(params[5])); + signVerifyMulti(CKM_SHA3_256_RSA_PKCS_PSS, hSessionRO, hPuk,hPrk, ¶ms[6], sizeof(params[6])); + signVerifyMulti(CKM_SHA3_384_RSA_PKCS_PSS, hSessionRO, hPuk,hPrk, ¶ms[7], sizeof(params[7])); + signVerifyMulti(CKM_SHA3_512_RSA_PKCS_PSS, hSessionRO, hPuk,hPrk, ¶ms[8], sizeof(params[8])); +#endif // Private Session Keys rv = generateRSA(hSessionRW,IN_SESSION,IS_PRIVATE,IN_SESSION,IS_PRIVATE,hPuk,hPrk); @@ -460,11 +484,23 @@ void SignVerifyTests::testRsaSignVerify() signVerifyMulti(CKM_SHA256_RSA_PKCS, hSessionRW, hPuk,hPrk); signVerifyMulti(CKM_SHA384_RSA_PKCS, hSessionRW, hPuk,hPrk); signVerifyMulti(CKM_SHA512_RSA_PKCS, hSessionRW, hPuk,hPrk); +#ifdef WITH_SHA3 + signVerifyMulti(CKM_SHA3_224_RSA_PKCS, hSessionRW, hPuk,hPrk); + signVerifyMulti(CKM_SHA3_256_RSA_PKCS, hSessionRW, hPuk,hPrk); + signVerifyMulti(CKM_SHA3_384_RSA_PKCS, hSessionRW, hPuk,hPrk); + signVerifyMulti(CKM_SHA3_512_RSA_PKCS, hSessionRW, hPuk,hPrk); +#endif signVerifyMulti(CKM_SHA1_RSA_PKCS_PSS, hSessionRW, hPuk,hPrk, ¶ms[0], sizeof(params[0])); signVerifyMulti(CKM_SHA224_RSA_PKCS_PSS, hSessionRW, hPuk,hPrk, ¶ms[1], sizeof(params[1])); signVerifyMulti(CKM_SHA256_RSA_PKCS_PSS, hSessionRW, hPuk,hPrk, ¶ms[2], sizeof(params[2])); signVerifyMulti(CKM_SHA384_RSA_PKCS_PSS, hSessionRW, hPuk,hPrk, ¶ms[3], sizeof(params[3])); signVerifyMulti(CKM_SHA512_RSA_PKCS_PSS, hSessionRW, hPuk,hPrk, ¶ms[4], sizeof(params[4])); +#ifdef WITH_SHA3 + signVerifyMulti(CKM_SHA3_224_RSA_PKCS_PSS, hSessionRW, hPuk,hPrk, ¶ms[5], sizeof(params[5])); + signVerifyMulti(CKM_SHA3_256_RSA_PKCS_PSS, hSessionRW, hPuk,hPrk, ¶ms[6], sizeof(params[6])); + signVerifyMulti(CKM_SHA3_384_RSA_PKCS_PSS, hSessionRW, hPuk,hPrk, ¶ms[7], sizeof(params[7])); + signVerifyMulti(CKM_SHA3_512_RSA_PKCS_PSS, hSessionRW, hPuk,hPrk, ¶ms[8], sizeof(params[8])); +#endif // Public Token Keys rv = generateRSA(hSessionRW,ON_TOKEN,IS_PUBLIC,ON_TOKEN,IS_PUBLIC,hPuk,hPrk); @@ -480,11 +516,23 @@ void SignVerifyTests::testRsaSignVerify() signVerifyMulti(CKM_SHA256_RSA_PKCS, hSessionRW, hPuk,hPrk); signVerifyMulti(CKM_SHA384_RSA_PKCS, hSessionRW, hPuk,hPrk); signVerifyMulti(CKM_SHA512_RSA_PKCS, hSessionRW, hPuk,hPrk); +#ifdef WITH_SHA3 + signVerifyMulti(CKM_SHA3_224_RSA_PKCS, hSessionRW, hPuk,hPrk); + signVerifyMulti(CKM_SHA3_256_RSA_PKCS, hSessionRW, hPuk,hPrk); + signVerifyMulti(CKM_SHA3_384_RSA_PKCS, hSessionRW, hPuk,hPrk); + signVerifyMulti(CKM_SHA3_512_RSA_PKCS, hSessionRW, hPuk,hPrk); +#endif signVerifyMulti(CKM_SHA1_RSA_PKCS_PSS, hSessionRW, hPuk,hPrk, ¶ms[0], sizeof(params[0])); signVerifyMulti(CKM_SHA224_RSA_PKCS_PSS, hSessionRW, hPuk,hPrk, ¶ms[1], sizeof(params[1])); signVerifyMulti(CKM_SHA256_RSA_PKCS_PSS, hSessionRW, hPuk,hPrk, ¶ms[2], sizeof(params[2])); signVerifyMulti(CKM_SHA384_RSA_PKCS_PSS, hSessionRW, hPuk,hPrk, ¶ms[3], sizeof(params[3])); signVerifyMulti(CKM_SHA512_RSA_PKCS_PSS, hSessionRW, hPuk,hPrk, ¶ms[4], sizeof(params[4])); +#ifdef WITH_SHA3 + signVerifyMulti(CKM_SHA3_224_RSA_PKCS_PSS, hSessionRW, hPuk,hPrk, ¶ms[5], sizeof(params[5])); + signVerifyMulti(CKM_SHA3_256_RSA_PKCS_PSS, hSessionRW, hPuk,hPrk, ¶ms[6], sizeof(params[6])); + signVerifyMulti(CKM_SHA3_384_RSA_PKCS_PSS, hSessionRW, hPuk,hPrk, ¶ms[7], sizeof(params[7])); + signVerifyMulti(CKM_SHA3_512_RSA_PKCS_PSS, hSessionRW, hPuk,hPrk, ¶ms[8], sizeof(params[8])); +#endif // Private Token Keys rv = generateRSA(hSessionRW,ON_TOKEN,IS_PRIVATE,ON_TOKEN,IS_PRIVATE,hPuk,hPrk); @@ -500,11 +548,23 @@ void SignVerifyTests::testRsaSignVerify() signVerifyMulti(CKM_SHA256_RSA_PKCS, hSessionRW, hPuk,hPrk); signVerifyMulti(CKM_SHA384_RSA_PKCS, hSessionRW, hPuk,hPrk); signVerifyMulti(CKM_SHA512_RSA_PKCS, hSessionRW, hPuk,hPrk); +#ifdef WITH_SHA3 + signVerifyMulti(CKM_SHA3_224_RSA_PKCS, hSessionRW, hPuk,hPrk); + signVerifyMulti(CKM_SHA3_256_RSA_PKCS, hSessionRW, hPuk,hPrk); + signVerifyMulti(CKM_SHA3_384_RSA_PKCS, hSessionRW, hPuk,hPrk); + signVerifyMulti(CKM_SHA3_512_RSA_PKCS, hSessionRW, hPuk,hPrk); +#endif signVerifyMulti(CKM_SHA1_RSA_PKCS_PSS, hSessionRW, hPuk,hPrk, ¶ms[0], sizeof(params[0])); signVerifyMulti(CKM_SHA224_RSA_PKCS_PSS, hSessionRW, hPuk,hPrk, ¶ms[1], sizeof(params[1])); signVerifyMulti(CKM_SHA256_RSA_PKCS_PSS, hSessionRW, hPuk,hPrk, ¶ms[2], sizeof(params[2])); signVerifyMulti(CKM_SHA384_RSA_PKCS_PSS, hSessionRW, hPuk,hPrk, ¶ms[3], sizeof(params[3])); signVerifyMulti(CKM_SHA512_RSA_PKCS_PSS, hSessionRW, hPuk,hPrk, ¶ms[4], sizeof(params[4])); +#ifdef WITH_SHA3 + signVerifyMulti(CKM_SHA3_224_RSA_PKCS_PSS, hSessionRW, hPuk,hPrk, ¶ms[5], sizeof(params[5])); + signVerifyMulti(CKM_SHA3_256_RSA_PKCS_PSS, hSessionRW, hPuk,hPrk, ¶ms[6], sizeof(params[6])); + signVerifyMulti(CKM_SHA3_384_RSA_PKCS_PSS, hSessionRW, hPuk,hPrk, ¶ms[7], sizeof(params[7])); + signVerifyMulti(CKM_SHA3_512_RSA_PKCS_PSS, hSessionRW, hPuk,hPrk, ¶ms[8], sizeof(params[8])); +#endif } #ifdef WITH_ECC @@ -549,12 +609,24 @@ void SignVerifyTests::testEcSignVerify() signVerifySingle(CKM_ECDSA_SHA256, hSessionRO, hPuk, hPrk); signVerifySingle(CKM_ECDSA_SHA384, hSessionRO, hPuk, hPrk); signVerifySingle(CKM_ECDSA_SHA512, hSessionRO, hPuk, hPrk); +#ifdef WITH_SHA3 + signVerifySingle(CKM_ECDSA_SHA3_224, hSessionRO, hPuk, hPrk); + signVerifySingle(CKM_ECDSA_SHA3_256, hSessionRO, hPuk, hPrk); + signVerifySingle(CKM_ECDSA_SHA3_384, hSessionRO, hPuk, hPrk); + signVerifySingle(CKM_ECDSA_SHA3_512, hSessionRO, hPuk, hPrk); +#endif signVerifyMulti(CKM_ECDSA_SHA1, hSessionRO, hPuk, hPrk); signVerifyMulti(CKM_ECDSA_SHA224, hSessionRO, hPuk, hPrk); signVerifyMulti(CKM_ECDSA_SHA256, hSessionRO, hPuk, hPrk); signVerifyMulti(CKM_ECDSA_SHA384, hSessionRO, hPuk, hPrk); signVerifyMulti(CKM_ECDSA_SHA512, hSessionRO, hPuk, hPrk); +#ifdef WITH_SHA3 + signVerifyMulti(CKM_ECDSA_SHA3_224, hSessionRO, hPuk, hPrk); + signVerifyMulti(CKM_ECDSA_SHA3_256, hSessionRO, hPuk, hPrk); + signVerifyMulti(CKM_ECDSA_SHA3_384, hSessionRO, hPuk, hPrk); + signVerifyMulti(CKM_ECDSA_SHA3_512, hSessionRO, hPuk, hPrk); +#endif rv = generateEC("P-384", hSessionRW,IN_SESSION,IS_PUBLIC,IN_SESSION,IS_PUBLIC,hPuk,hPrk); CPPUNIT_ASSERT(rv == CKR_OK); @@ -564,12 +636,24 @@ void SignVerifyTests::testEcSignVerify() signVerifySingle(CKM_ECDSA_SHA256, hSessionRO, hPuk, hPrk); signVerifySingle(CKM_ECDSA_SHA384, hSessionRO, hPuk, hPrk); signVerifySingle(CKM_ECDSA_SHA512, hSessionRO, hPuk, hPrk); +#ifdef WITH_SHA3 + signVerifySingle(CKM_ECDSA_SHA3_224, hSessionRO, hPuk, hPrk); + signVerifySingle(CKM_ECDSA_SHA3_256, hSessionRO, hPuk, hPrk); + signVerifySingle(CKM_ECDSA_SHA3_384, hSessionRO, hPuk, hPrk); + signVerifySingle(CKM_ECDSA_SHA3_512, hSessionRO, hPuk, hPrk); +#endif signVerifyMulti(CKM_ECDSA_SHA1, hSessionRO, hPuk, hPrk); signVerifyMulti(CKM_ECDSA_SHA224, hSessionRO, hPuk, hPrk); signVerifyMulti(CKM_ECDSA_SHA256, hSessionRO, hPuk, hPrk); signVerifyMulti(CKM_ECDSA_SHA384, hSessionRO, hPuk, hPrk); signVerifyMulti(CKM_ECDSA_SHA512, hSessionRO, hPuk, hPrk); +#ifdef WITH_SHA3 + signVerifyMulti(CKM_ECDSA_SHA3_224, hSessionRO, hPuk, hPrk); + signVerifyMulti(CKM_ECDSA_SHA3_256, hSessionRO, hPuk, hPrk); + signVerifyMulti(CKM_ECDSA_SHA3_384, hSessionRO, hPuk, hPrk); + signVerifyMulti(CKM_ECDSA_SHA3_512, hSessionRO, hPuk, hPrk); +#endif rv = generateEC("P-521", hSessionRW,IN_SESSION,IS_PUBLIC,IN_SESSION,IS_PUBLIC,hPuk,hPrk); CPPUNIT_ASSERT(rv == CKR_OK); @@ -579,12 +663,24 @@ void SignVerifyTests::testEcSignVerify() signVerifySingle(CKM_ECDSA_SHA256, hSessionRO, hPuk, hPrk); signVerifySingle(CKM_ECDSA_SHA384, hSessionRO, hPuk, hPrk); signVerifySingle(CKM_ECDSA_SHA512, hSessionRO, hPuk, hPrk); +#ifdef WITH_SHA3 + signVerifySingle(CKM_ECDSA_SHA3_224, hSessionRO, hPuk, hPrk); + signVerifySingle(CKM_ECDSA_SHA3_256, hSessionRO, hPuk, hPrk); + signVerifySingle(CKM_ECDSA_SHA3_384, hSessionRO, hPuk, hPrk); + signVerifySingle(CKM_ECDSA_SHA3_512, hSessionRO, hPuk, hPrk); +#endif signVerifyMulti(CKM_ECDSA_SHA1, hSessionRO, hPuk, hPrk); signVerifyMulti(CKM_ECDSA_SHA224, hSessionRO, hPuk, hPrk); signVerifyMulti(CKM_ECDSA_SHA256, hSessionRO, hPuk, hPrk); signVerifyMulti(CKM_ECDSA_SHA384, hSessionRO, hPuk, hPrk); signVerifyMulti(CKM_ECDSA_SHA512, hSessionRO, hPuk, hPrk); +#ifdef WITH_SHA3 + signVerifyMulti(CKM_ECDSA_SHA3_224, hSessionRO, hPuk, hPrk); + signVerifyMulti(CKM_ECDSA_SHA3_256, hSessionRO, hPuk, hPrk); + signVerifyMulti(CKM_ECDSA_SHA3_384, hSessionRO, hPuk, hPrk); + signVerifyMulti(CKM_ECDSA_SHA3_512, hSessionRO, hPuk, hPrk); +#endif // Private Session Keys rv = generateEC("P-256", hSessionRW,IN_SESSION,IS_PRIVATE,IN_SESSION,IS_PRIVATE,hPuk,hPrk); @@ -595,12 +691,24 @@ void SignVerifyTests::testEcSignVerify() signVerifySingle(CKM_ECDSA_SHA256, hSessionRO, hPuk, hPrk); signVerifySingle(CKM_ECDSA_SHA384, hSessionRO, hPuk, hPrk); signVerifySingle(CKM_ECDSA_SHA512, hSessionRO, hPuk, hPrk); +#ifdef WITH_SHA3 + signVerifySingle(CKM_ECDSA_SHA3_224, hSessionRO, hPuk, hPrk); + signVerifySingle(CKM_ECDSA_SHA3_256, hSessionRO, hPuk, hPrk); + signVerifySingle(CKM_ECDSA_SHA3_384, hSessionRO, hPuk, hPrk); + signVerifySingle(CKM_ECDSA_SHA3_512, hSessionRO, hPuk, hPrk); +#endif signVerifyMulti(CKM_ECDSA_SHA1, hSessionRO, hPuk, hPrk); signVerifyMulti(CKM_ECDSA_SHA224, hSessionRO, hPuk, hPrk); signVerifyMulti(CKM_ECDSA_SHA256, hSessionRO, hPuk, hPrk); signVerifyMulti(CKM_ECDSA_SHA384, hSessionRO, hPuk, hPrk); signVerifyMulti(CKM_ECDSA_SHA512, hSessionRO, hPuk, hPrk); +#ifdef WITH_SHA3 + signVerifyMulti(CKM_ECDSA_SHA3_224, hSessionRO, hPuk, hPrk); + signVerifyMulti(CKM_ECDSA_SHA3_256, hSessionRO, hPuk, hPrk); + signVerifyMulti(CKM_ECDSA_SHA3_384, hSessionRO, hPuk, hPrk); + signVerifyMulti(CKM_ECDSA_SHA3_512, hSessionRO, hPuk, hPrk); +#endif rv = generateEC("P-384", hSessionRW,IN_SESSION,IS_PRIVATE,IN_SESSION,IS_PRIVATE,hPuk,hPrk); CPPUNIT_ASSERT(rv == CKR_OK); @@ -610,12 +718,24 @@ void SignVerifyTests::testEcSignVerify() signVerifySingle(CKM_ECDSA_SHA256, hSessionRO, hPuk, hPrk); signVerifySingle(CKM_ECDSA_SHA384, hSessionRO, hPuk, hPrk); signVerifySingle(CKM_ECDSA_SHA512, hSessionRO, hPuk, hPrk); +#ifdef WITH_SHA3 + signVerifySingle(CKM_ECDSA_SHA3_224, hSessionRO, hPuk, hPrk); + signVerifySingle(CKM_ECDSA_SHA3_256, hSessionRO, hPuk, hPrk); + signVerifySingle(CKM_ECDSA_SHA3_384, hSessionRO, hPuk, hPrk); + signVerifySingle(CKM_ECDSA_SHA3_512, hSessionRO, hPuk, hPrk); +#endif signVerifyMulti(CKM_ECDSA_SHA1, hSessionRO, hPuk, hPrk); signVerifyMulti(CKM_ECDSA_SHA224, hSessionRO, hPuk, hPrk); signVerifyMulti(CKM_ECDSA_SHA256, hSessionRO, hPuk, hPrk); signVerifyMulti(CKM_ECDSA_SHA384, hSessionRO, hPuk, hPrk); signVerifyMulti(CKM_ECDSA_SHA512, hSessionRO, hPuk, hPrk); +#ifdef WITH_SHA3 + signVerifyMulti(CKM_ECDSA_SHA3_224, hSessionRO, hPuk, hPrk); + signVerifyMulti(CKM_ECDSA_SHA3_256, hSessionRO, hPuk, hPrk); + signVerifyMulti(CKM_ECDSA_SHA3_384, hSessionRO, hPuk, hPrk); + signVerifyMulti(CKM_ECDSA_SHA3_512, hSessionRO, hPuk, hPrk); +#endif rv = generateEC("P-521", hSessionRW,IN_SESSION,IS_PRIVATE,IN_SESSION,IS_PRIVATE,hPuk,hPrk); CPPUNIT_ASSERT(rv == CKR_OK); @@ -625,12 +745,24 @@ void SignVerifyTests::testEcSignVerify() signVerifySingle(CKM_ECDSA_SHA256, hSessionRO, hPuk, hPrk); signVerifySingle(CKM_ECDSA_SHA384, hSessionRO, hPuk, hPrk); signVerifySingle(CKM_ECDSA_SHA512, hSessionRO, hPuk, hPrk); +#ifdef WITH_SHA3 + signVerifySingle(CKM_ECDSA_SHA3_224, hSessionRO, hPuk, hPrk); + signVerifySingle(CKM_ECDSA_SHA3_256, hSessionRO, hPuk, hPrk); + signVerifySingle(CKM_ECDSA_SHA3_384, hSessionRO, hPuk, hPrk); + signVerifySingle(CKM_ECDSA_SHA3_512, hSessionRO, hPuk, hPrk); +#endif signVerifyMulti(CKM_ECDSA_SHA1, hSessionRO, hPuk, hPrk); signVerifyMulti(CKM_ECDSA_SHA224, hSessionRO, hPuk, hPrk); signVerifyMulti(CKM_ECDSA_SHA256, hSessionRO, hPuk, hPrk); signVerifyMulti(CKM_ECDSA_SHA384, hSessionRO, hPuk, hPrk); signVerifyMulti(CKM_ECDSA_SHA512, hSessionRO, hPuk, hPrk); +#ifdef WITH_SHA3 + signVerifyMulti(CKM_ECDSA_SHA3_224, hSessionRO, hPuk, hPrk); + signVerifyMulti(CKM_ECDSA_SHA3_256, hSessionRO, hPuk, hPrk); + signVerifyMulti(CKM_ECDSA_SHA3_384, hSessionRO, hPuk, hPrk); + signVerifyMulti(CKM_ECDSA_SHA3_512, hSessionRO, hPuk, hPrk); +#endif // Public Token Keys rv = generateEC("P-256", hSessionRW,ON_TOKEN,IS_PUBLIC,ON_TOKEN,IS_PUBLIC,hPuk,hPrk); @@ -641,12 +773,24 @@ void SignVerifyTests::testEcSignVerify() signVerifySingle(CKM_ECDSA_SHA256, hSessionRO, hPuk, hPrk); signVerifySingle(CKM_ECDSA_SHA384, hSessionRO, hPuk, hPrk); signVerifySingle(CKM_ECDSA_SHA512, hSessionRO, hPuk, hPrk); +#ifdef WITH_SHA3 + signVerifySingle(CKM_ECDSA_SHA3_224, hSessionRO, hPuk, hPrk); + signVerifySingle(CKM_ECDSA_SHA3_256, hSessionRO, hPuk, hPrk); + signVerifySingle(CKM_ECDSA_SHA3_384, hSessionRO, hPuk, hPrk); + signVerifySingle(CKM_ECDSA_SHA3_512, hSessionRO, hPuk, hPrk); +#endif signVerifyMulti(CKM_ECDSA_SHA1, hSessionRO, hPuk, hPrk); signVerifyMulti(CKM_ECDSA_SHA224, hSessionRO, hPuk, hPrk); signVerifyMulti(CKM_ECDSA_SHA256, hSessionRO, hPuk, hPrk); signVerifyMulti(CKM_ECDSA_SHA384, hSessionRO, hPuk, hPrk); signVerifyMulti(CKM_ECDSA_SHA512, hSessionRO, hPuk, hPrk); +#ifdef WITH_SHA3 + signVerifyMulti(CKM_ECDSA_SHA3_224, hSessionRO, hPuk, hPrk); + signVerifyMulti(CKM_ECDSA_SHA3_256, hSessionRO, hPuk, hPrk); + signVerifyMulti(CKM_ECDSA_SHA3_384, hSessionRO, hPuk, hPrk); + signVerifyMulti(CKM_ECDSA_SHA3_512, hSessionRO, hPuk, hPrk); +#endif rv = generateEC("P-384", hSessionRW,ON_TOKEN,IS_PUBLIC,ON_TOKEN,IS_PUBLIC,hPuk,hPrk); CPPUNIT_ASSERT(rv == CKR_OK); @@ -656,12 +800,24 @@ void SignVerifyTests::testEcSignVerify() signVerifySingle(CKM_ECDSA_SHA256, hSessionRO, hPuk, hPrk); signVerifySingle(CKM_ECDSA_SHA384, hSessionRO, hPuk, hPrk); signVerifySingle(CKM_ECDSA_SHA512, hSessionRO, hPuk, hPrk); +#ifdef WITH_SHA3 + signVerifySingle(CKM_ECDSA_SHA3_224, hSessionRO, hPuk, hPrk); + signVerifySingle(CKM_ECDSA_SHA3_256, hSessionRO, hPuk, hPrk); + signVerifySingle(CKM_ECDSA_SHA3_384, hSessionRO, hPuk, hPrk); + signVerifySingle(CKM_ECDSA_SHA3_512, hSessionRO, hPuk, hPrk); +#endif signVerifyMulti(CKM_ECDSA_SHA1, hSessionRO, hPuk, hPrk); signVerifyMulti(CKM_ECDSA_SHA224, hSessionRO, hPuk, hPrk); signVerifyMulti(CKM_ECDSA_SHA256, hSessionRO, hPuk, hPrk); signVerifyMulti(CKM_ECDSA_SHA384, hSessionRO, hPuk, hPrk); signVerifyMulti(CKM_ECDSA_SHA512, hSessionRO, hPuk, hPrk); +#ifdef WITH_SHA3 + signVerifyMulti(CKM_ECDSA_SHA3_224, hSessionRO, hPuk, hPrk); + signVerifyMulti(CKM_ECDSA_SHA3_256, hSessionRO, hPuk, hPrk); + signVerifyMulti(CKM_ECDSA_SHA3_384, hSessionRO, hPuk, hPrk); + signVerifyMulti(CKM_ECDSA_SHA3_512, hSessionRO, hPuk, hPrk); +#endif rv = generateEC("P-521", hSessionRW,ON_TOKEN,IS_PUBLIC,ON_TOKEN,IS_PUBLIC,hPuk,hPrk); CPPUNIT_ASSERT(rv == CKR_OK); @@ -671,12 +827,24 @@ void SignVerifyTests::testEcSignVerify() signVerifySingle(CKM_ECDSA_SHA256, hSessionRO, hPuk, hPrk); signVerifySingle(CKM_ECDSA_SHA384, hSessionRO, hPuk, hPrk); signVerifySingle(CKM_ECDSA_SHA512, hSessionRO, hPuk, hPrk); +#ifdef WITH_SHA3 + signVerifySingle(CKM_ECDSA_SHA3_224, hSessionRO, hPuk, hPrk); + signVerifySingle(CKM_ECDSA_SHA3_256, hSessionRO, hPuk, hPrk); + signVerifySingle(CKM_ECDSA_SHA3_384, hSessionRO, hPuk, hPrk); + signVerifySingle(CKM_ECDSA_SHA3_512, hSessionRO, hPuk, hPrk); +#endif signVerifyMulti(CKM_ECDSA_SHA1, hSessionRO, hPuk, hPrk); signVerifyMulti(CKM_ECDSA_SHA224, hSessionRO, hPuk, hPrk); signVerifyMulti(CKM_ECDSA_SHA256, hSessionRO, hPuk, hPrk); signVerifyMulti(CKM_ECDSA_SHA384, hSessionRO, hPuk, hPrk); signVerifyMulti(CKM_ECDSA_SHA512, hSessionRO, hPuk, hPrk); +#ifdef WITH_SHA3 + signVerifyMulti(CKM_ECDSA_SHA3_224, hSessionRO, hPuk, hPrk); + signVerifyMulti(CKM_ECDSA_SHA3_256, hSessionRO, hPuk, hPrk); + signVerifyMulti(CKM_ECDSA_SHA3_384, hSessionRO, hPuk, hPrk); + signVerifyMulti(CKM_ECDSA_SHA3_512, hSessionRO, hPuk, hPrk); +#endif // Private Token Keys rv = generateEC("P-256", hSessionRW,ON_TOKEN,IS_PRIVATE,ON_TOKEN,IS_PRIVATE,hPuk,hPrk); @@ -687,12 +855,24 @@ void SignVerifyTests::testEcSignVerify() signVerifySingle(CKM_ECDSA_SHA256, hSessionRO, hPuk, hPrk); signVerifySingle(CKM_ECDSA_SHA384, hSessionRO, hPuk, hPrk); signVerifySingle(CKM_ECDSA_SHA512, hSessionRO, hPuk, hPrk); +#ifdef WITH_SHA3 + signVerifySingle(CKM_ECDSA_SHA3_224, hSessionRO, hPuk, hPrk); + signVerifySingle(CKM_ECDSA_SHA3_256, hSessionRO, hPuk, hPrk); + signVerifySingle(CKM_ECDSA_SHA3_384, hSessionRO, hPuk, hPrk); + signVerifySingle(CKM_ECDSA_SHA3_512, hSessionRO, hPuk, hPrk); +#endif signVerifyMulti(CKM_ECDSA_SHA1, hSessionRO, hPuk, hPrk); signVerifyMulti(CKM_ECDSA_SHA224, hSessionRO, hPuk, hPrk); signVerifyMulti(CKM_ECDSA_SHA256, hSessionRO, hPuk, hPrk); signVerifyMulti(CKM_ECDSA_SHA384, hSessionRO, hPuk, hPrk); signVerifyMulti(CKM_ECDSA_SHA512, hSessionRO, hPuk, hPrk); +#ifdef WITH_SHA3 + signVerifyMulti(CKM_ECDSA_SHA3_224, hSessionRO, hPuk, hPrk); + signVerifyMulti(CKM_ECDSA_SHA3_256, hSessionRO, hPuk, hPrk); + signVerifyMulti(CKM_ECDSA_SHA3_384, hSessionRO, hPuk, hPrk); + signVerifyMulti(CKM_ECDSA_SHA3_512, hSessionRO, hPuk, hPrk); +#endif rv = generateEC("P-384", hSessionRW,ON_TOKEN,IS_PRIVATE,ON_TOKEN,IS_PRIVATE,hPuk,hPrk); CPPUNIT_ASSERT(rv == CKR_OK); @@ -702,12 +882,24 @@ void SignVerifyTests::testEcSignVerify() signVerifySingle(CKM_ECDSA_SHA256, hSessionRO, hPuk, hPrk); signVerifySingle(CKM_ECDSA_SHA384, hSessionRO, hPuk, hPrk); signVerifySingle(CKM_ECDSA_SHA512, hSessionRO, hPuk, hPrk); +#ifdef WITH_SHA3 + signVerifySingle(CKM_ECDSA_SHA3_224, hSessionRO, hPuk, hPrk); + signVerifySingle(CKM_ECDSA_SHA3_256, hSessionRO, hPuk, hPrk); + signVerifySingle(CKM_ECDSA_SHA3_384, hSessionRO, hPuk, hPrk); + signVerifySingle(CKM_ECDSA_SHA3_512, hSessionRO, hPuk, hPrk); +#endif signVerifyMulti(CKM_ECDSA_SHA1, hSessionRO, hPuk, hPrk); signVerifyMulti(CKM_ECDSA_SHA224, hSessionRO, hPuk, hPrk); signVerifyMulti(CKM_ECDSA_SHA256, hSessionRO, hPuk, hPrk); signVerifyMulti(CKM_ECDSA_SHA384, hSessionRO, hPuk, hPrk); signVerifyMulti(CKM_ECDSA_SHA512, hSessionRO, hPuk, hPrk); +#ifdef WITH_SHA3 + signVerifyMulti(CKM_ECDSA_SHA3_224, hSessionRO, hPuk, hPrk); + signVerifyMulti(CKM_ECDSA_SHA3_256, hSessionRO, hPuk, hPrk); + signVerifyMulti(CKM_ECDSA_SHA3_384, hSessionRO, hPuk, hPrk); + signVerifyMulti(CKM_ECDSA_SHA3_512, hSessionRO, hPuk, hPrk); +#endif rv = generateEC("P-521", hSessionRW,ON_TOKEN,IS_PRIVATE,ON_TOKEN,IS_PRIVATE,hPuk,hPrk); CPPUNIT_ASSERT(rv == CKR_OK); @@ -717,12 +909,24 @@ void SignVerifyTests::testEcSignVerify() signVerifySingle(CKM_ECDSA_SHA256, hSessionRO, hPuk, hPrk); signVerifySingle(CKM_ECDSA_SHA384, hSessionRO, hPuk, hPrk); signVerifySingle(CKM_ECDSA_SHA512, hSessionRO, hPuk, hPrk); +#ifdef WITH_SHA3 + signVerifySingle(CKM_ECDSA_SHA3_224, hSessionRO, hPuk, hPrk); + signVerifySingle(CKM_ECDSA_SHA3_256, hSessionRO, hPuk, hPrk); + signVerifySingle(CKM_ECDSA_SHA3_384, hSessionRO, hPuk, hPrk); + signVerifySingle(CKM_ECDSA_SHA3_512, hSessionRO, hPuk, hPrk); +#endif signVerifyMulti(CKM_ECDSA_SHA1, hSessionRO, hPuk, hPrk); signVerifyMulti(CKM_ECDSA_SHA224, hSessionRO, hPuk, hPrk); signVerifyMulti(CKM_ECDSA_SHA256, hSessionRO, hPuk, hPrk); signVerifyMulti(CKM_ECDSA_SHA384, hSessionRO, hPuk, hPrk); signVerifyMulti(CKM_ECDSA_SHA512, hSessionRO, hPuk, hPrk); +#ifdef WITH_SHA3 + signVerifyMulti(CKM_ECDSA_SHA3_224, hSessionRO, hPuk, hPrk); + signVerifyMulti(CKM_ECDSA_SHA3_256, hSessionRO, hPuk, hPrk); + signVerifyMulti(CKM_ECDSA_SHA3_384, hSessionRO, hPuk, hPrk); + signVerifyMulti(CKM_ECDSA_SHA3_512, hSessionRO, hPuk, hPrk); +#endif } #endif @@ -1067,6 +1271,24 @@ void SignVerifyTests::testMacSignVerify() CPPUNIT_ASSERT(rv == CKR_OK); macSignVerify(CKM_SHA384_HMAC, hSessionRO, hKey); +#ifdef WITH_SHA3 + rv = generateKey(hSessionRW,CKK_SHA3_224_HMAC,IN_SESSION,IS_PUBLIC,hKey); + CPPUNIT_ASSERT(rv == CKR_OK); + macSignVerify(CKM_SHA3_224_HMAC, hSessionRO, hKey); + + rv = generateKey(hSessionRW,CKK_SHA3_256_HMAC,IN_SESSION,IS_PUBLIC,hKey); + CPPUNIT_ASSERT(rv == CKR_OK); + macSignVerify(CKM_SHA3_256_HMAC, hSessionRO, hKey); + + rv = generateKey(hSessionRW,CKK_SHA3_384_HMAC,IN_SESSION,IS_PUBLIC,hKey); + CPPUNIT_ASSERT(rv == CKR_OK); + macSignVerify(CKM_SHA3_384_HMAC, hSessionRO, hKey); + + rv = generateKey(hSessionRW,CKK_SHA3_512_HMAC,IN_SESSION,IS_PUBLIC,hKey); + CPPUNIT_ASSERT(rv == CKR_OK); + macSignVerify(CKM_SHA3_512_HMAC, hSessionRO, hKey); + +#endif rv = generateKey(hSessionRW,CKK_SHA512_HMAC,IN_SESSION,IS_PUBLIC,hKey); CPPUNIT_ASSERT(rv == CKR_OK); macSignVerify(CKM_SHA512_HMAC, hSessionRO, hKey); @@ -1264,7 +1486,11 @@ void SignVerifyTests::testSignInitWrongKeyType() } // DSA mechanisms with EC key - CK_MECHANISM_TYPE dsaMechs[] = { CKM_DSA, CKM_DSA_SHA1, CKM_DSA_SHA256 }; + CK_MECHANISM_TYPE dsaMechs[] = { CKM_DSA, CKM_DSA_SHA1, CKM_DSA_SHA256 +#ifdef WITH_SHA3 + , CKM_DSA_SHA3_256 +#endif + }; for (size_t i = 0; i < sizeof(dsaMechs)/sizeof(dsaMechs[0]); i++) { CK_MECHANISM mechanism = { dsaMechs[i], NULL_PTR, 0 }; @@ -1358,7 +1584,11 @@ void SignVerifyTests::testVerifyInitWrongKeyType() } // DSA mechanisms with EC key - CK_MECHANISM_TYPE dsaMechs[] = { CKM_DSA, CKM_DSA_SHA1, CKM_DSA_SHA256 }; + CK_MECHANISM_TYPE dsaMechs[] = { CKM_DSA, CKM_DSA_SHA1, CKM_DSA_SHA256 +#ifdef WITH_SHA3 + , CKM_DSA_SHA3_256 +#endif + }; for (size_t i = 0; i < sizeof(dsaMechs)/sizeof(dsaMechs[0]); i++) { CK_MECHANISM mechanism = { dsaMechs[i], NULL_PTR, 0 };