From 4c583bfa4545feae227c726927d25c85e862453c Mon Sep 17 00:00:00 2001 From: Alexandre Laroche Date: Wed, 22 Jul 2026 19:15:31 -0400 Subject: [PATCH 01/10] Add SHA3 (FIPS 202) mechanism support Implement the full PKCS#11 v3.2 SHA3 mechanism family for both the OpenSSL and Botan crypto backends: plain digest (CKM_SHA3_*), HMAC (CKM_SHA3_*_HMAC), and RSA/DSA/ECDSA combined signing (CKM_SHA3_*_RSA_PKCS[_PSS], CKM_DSA_SHA3_*, CKM_ECDSA_SHA3_*). Also accepts a SHA3 hash parameter in CKM_RSA_PKCS_OAEP and in raw CKM_RSA_PKCS_PSS signing with a precomputed digest. Not implemented: CKM_SHA3_*_KEY_GEN and CKM_SHA3_*_HMAC_GENERAL, neither of which is implemented for any existing hash family today. Closes #603. --- src/bin/dump/tables.h | 24 ++ src/lib/P11Attributes.cpp | 8 + src/lib/SoftHSM.cpp | 458 ++++++++++++++++++++++- src/lib/crypto/AsymmetricAlgorithm.h | 22 +- src/lib/crypto/BotanCryptoFactory.cpp | 20 + src/lib/crypto/BotanDSA.cpp | 24 ++ src/lib/crypto/BotanECDSA.cpp | 48 +++ src/lib/crypto/BotanMAC.cpp | 40 ++ src/lib/crypto/BotanMAC.h | 28 ++ src/lib/crypto/BotanRSA.cpp | 300 +++++++++++++++ src/lib/crypto/BotanSHA3_224.cpp | 44 +++ src/lib/crypto/BotanSHA3_224.h | 47 +++ src/lib/crypto/BotanSHA3_256.cpp | 44 +++ src/lib/crypto/BotanSHA3_256.h | 47 +++ src/lib/crypto/BotanSHA3_384.cpp | 44 +++ src/lib/crypto/BotanSHA3_384.h | 47 +++ src/lib/crypto/BotanSHA3_512.cpp | 44 +++ src/lib/crypto/BotanSHA3_512.h | 47 +++ src/lib/crypto/CMakeLists.txt | 8 + src/lib/crypto/HashAlgorithm.h | 4 + src/lib/crypto/MacAlgorithm.h | 4 + src/lib/crypto/Makefile.am | 8 + src/lib/crypto/OSSLCryptoFactory.cpp | 20 + src/lib/crypto/OSSLDSA.cpp | 24 ++ src/lib/crypto/OSSLECDSA.cpp | 48 +++ src/lib/crypto/OSSLHMAC.cpp | 40 ++ src/lib/crypto/OSSLHMAC.h | 28 ++ src/lib/crypto/OSSLRSA.cpp | 420 +++++++++++++++++++++ src/lib/crypto/OSSLSHA3_224.cpp | 45 +++ src/lib/crypto/OSSLSHA3_224.h | 47 +++ src/lib/crypto/OSSLSHA3_256.cpp | 45 +++ src/lib/crypto/OSSLSHA3_256.h | 47 +++ src/lib/crypto/OSSLSHA3_384.cpp | 45 +++ src/lib/crypto/OSSLSHA3_384.h | 47 +++ src/lib/crypto/OSSLSHA3_512.cpp | 45 +++ src/lib/crypto/OSSLSHA3_512.h | 47 +++ src/lib/crypto/test/HashTests.cpp | 104 +++++ src/lib/crypto/test/HashTests.h | 8 + src/lib/test/AsymEncryptDecryptTests.cpp | 20 + src/lib/test/DigestTests.cpp | 4 + src/lib/test/SignVerifyTests.cpp | 158 +++++++- 41 files changed, 2597 insertions(+), 5 deletions(-) create mode 100644 src/lib/crypto/BotanSHA3_224.cpp create mode 100644 src/lib/crypto/BotanSHA3_224.h create mode 100644 src/lib/crypto/BotanSHA3_256.cpp create mode 100644 src/lib/crypto/BotanSHA3_256.h create mode 100644 src/lib/crypto/BotanSHA3_384.cpp create mode 100644 src/lib/crypto/BotanSHA3_384.h create mode 100644 src/lib/crypto/BotanSHA3_512.cpp create mode 100644 src/lib/crypto/BotanSHA3_512.h create mode 100644 src/lib/crypto/OSSLSHA3_224.cpp create mode 100644 src/lib/crypto/OSSLSHA3_224.h create mode 100644 src/lib/crypto/OSSLSHA3_256.cpp create mode 100644 src/lib/crypto/OSSLSHA3_256.h create mode 100644 src/lib/crypto/OSSLSHA3_384.cpp create mode 100644 src/lib/crypto/OSSLSHA3_384.h create mode 100644 src/lib/crypto/OSSLSHA3_512.cpp create mode 100644 src/lib/crypto/OSSLSHA3_512.h 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..2dbd5e70b 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,10 @@ void SoftHSM::prepareSupportedMechanisms(std::mapulMinKeySize = 0; pInfo->ulMaxKeySize = 0; @@ -1155,6 +1187,26 @@ CK_RV SoftHSM::C_GetMechanismInfo(CK_SLOT_ID slotID, CK_MECHANISM_TYPE type, CK_ pInfo->ulMaxKeySize = 512; pInfo->flags = CKF_SIGN | CKF_VERIFY; break; + 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; case CKM_RSA_PKCS_KEY_PAIR_GEN: pInfo->ulMinKeySize = rsaMinSize; pInfo->ulMaxKeySize = rsaMaxSize; @@ -1178,6 +1230,10 @@ 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: + case CKM_SHA3_224_RSA_PKCS: + case CKM_SHA3_256_RSA_PKCS: + case CKM_SHA3_384_RSA_PKCS: + case CKM_SHA3_512_RSA_PKCS: #ifdef WITH_RAW_PSS case CKM_RSA_PKCS_PSS: #endif @@ -1186,6 +1242,10 @@ 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: + 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: pInfo->ulMinKeySize = rsaMinSize; pInfo->ulMaxKeySize = rsaMaxSize; pInfo->flags = CKF_SIGN | CKF_VERIFY; @@ -1309,6 +1369,10 @@ 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: + case CKM_DSA_SHA3_224: + case CKM_DSA_SHA3_256: + case CKM_DSA_SHA3_384: + case CKM_DSA_SHA3_512: pInfo->ulMinKeySize = dsaMinSize; pInfo->ulMaxKeySize = dsaMaxSize; pInfo->flags = CKF_SIGN | CKF_VERIFY; @@ -1341,6 +1405,10 @@ 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: + case CKM_ECDSA_SHA3_224: + case CKM_ECDSA_SHA3_256: + case CKM_ECDSA_SHA3_384: + case CKM_ECDSA_SHA3_512: pInfo->ulMinKeySize = ecdsaMinSize; pInfo->ulMaxKeySize = ecdsaMaxSize; pInfo->flags = CKF_SIGN | CKF_VERIFY | CKF_EC_COMMOM; @@ -3843,6 +3911,18 @@ CK_RV SoftHSM::C_DigestInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechan case CKM_SHA512: algo = HashAlgo::SHA512; break; + 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; #ifdef WITH_GOST case CKM_GOSTR3411: algo = HashAlgo::GOST; @@ -4096,6 +4176,10 @@ static bool isMacMechanism(CK_MECHANISM_PTR pMechanism) case CKM_SHA256_HMAC: case CKM_SHA384_HMAC: case CKM_SHA512_HMAC: + case CKM_SHA3_224_HMAC: + case CKM_SHA3_256_HMAC: + case CKM_SHA3_384_HMAC: + case CKM_SHA3_512_HMAC: #ifdef WITH_GOST case CKM_GOSTR3411_HMAC: #endif @@ -4197,6 +4281,30 @@ CK_RV SoftHSM::MacSignInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechani minSize = 64; algo = MacAlgo::HMAC_SHA512; break; + 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; #ifdef WITH_GOST case CKM_GOSTR3411_HMAC: if (keyType != CKK_GENERIC_SECRET && keyType != CKK_GOST28147) @@ -4368,6 +4476,26 @@ CK_RV SoftHSM::AsymSignInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechan bAllowMultiPartOp = true; isRSA = true; break; + 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; #ifdef WITH_RAW_PSS case CKM_RSA_PKCS_PSS: if (pMechanism->pParameter == NULL_PTR || @@ -4405,6 +4533,26 @@ CK_RV SoftHSM::AsymSignInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechan rsaPssParam.mgfAlg = AsymRSAMGF::MGF1_SHA512; allowedMgf = CKG_MGF1_SHA512; break; + 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; default: ERROR_MSG("Invalid RSA-PSS hash"); return CKR_ARGUMENTS_BAD; @@ -4506,6 +4654,74 @@ CK_RV SoftHSM::AsymSignInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechan bAllowMultiPartOp = true; isRSA = true; break; + 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; case CKM_DSA: mechanism = AsymMech::DSA; bAllowMultiPartOp = false; @@ -4536,6 +4752,26 @@ CK_RV SoftHSM::AsymSignInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechan bAllowMultiPartOp = true; isDSA = true; break; + 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; #ifdef WITH_ECC case CKM_ECDSA: mechanism = AsymMech::ECDSA; @@ -4567,6 +4803,26 @@ CK_RV SoftHSM::AsymSignInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechan bAllowMultiPartOp = true; isECDSA = true; break; + 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 #ifdef WITH_GOST case CKM_GOSTR3410: @@ -5287,6 +5543,30 @@ CK_RV SoftHSM::MacVerifyInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMecha minSize = 64; algo = MacAlgo::HMAC_SHA512; break; + 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; #ifdef WITH_GOST case CKM_GOSTR3411_HMAC: if (keyType != CKK_GENERIC_SECRET && keyType != CKK_GOST28147) @@ -5458,6 +5738,26 @@ CK_RV SoftHSM::AsymVerifyInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMech bAllowMultiPartOp = true; isRSA = true; break; + 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; #ifdef WITH_RAW_PSS case CKM_RSA_PKCS_PSS: if (pMechanism->pParameter == NULL_PTR || @@ -5495,6 +5795,26 @@ CK_RV SoftHSM::AsymVerifyInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMech rsaPssParam.mgfAlg = AsymRSAMGF::MGF1_SHA512; expectedMgf = CKG_MGF1_SHA512; break; + 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; default: return CKR_ARGUMENTS_BAD; } @@ -5592,6 +5912,74 @@ CK_RV SoftHSM::AsymVerifyInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMech rsaPssParam.sLen = CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->sLen; mechanismParam = &rsaPssParam; + bAllowMultiPartOp = true; + isRSA = true; + break; + 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; @@ -5625,6 +6013,26 @@ CK_RV SoftHSM::AsymVerifyInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMech bAllowMultiPartOp = true; isDSA = true; break; + 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; #ifdef WITH_ECC case CKM_ECDSA: mechanism = AsymMech::ECDSA; @@ -5656,6 +6064,26 @@ CK_RV SoftHSM::AsymVerifyInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMech bAllowMultiPartOp = true; isECDSA = true; break; + 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 #ifdef WITH_GOST case CKM_GOSTR3410: @@ -14908,6 +15336,22 @@ CK_RV SoftHSM::BuildRSAOAEPParam(const CK_RSA_PKCS_OAEP_PARAMS *params, mechanismParam->hashAlg = HashAlgo::SHA512; if (hashLen) *hashLen = 64; break; + 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; default: ERROR_MSG("hash algorithm not supported for OAEP"); return CKR_ARGUMENTS_BAD; @@ -14929,6 +15373,18 @@ CK_RV SoftHSM::BuildRSAOAEPParam(const CK_RSA_PKCS_OAEP_PARAMS *params, case CKG_MGF1_SHA512: mechanismParam->mgfAlg = AsymRSAMGF::MGF1_SHA512; break; + 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; 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..70b4e4645 100644 --- a/src/lib/crypto/BotanCryptoFactory.cpp +++ b/src/lib/crypto/BotanCryptoFactory.cpp @@ -48,6 +48,10 @@ #include "BotanSHA256.h" #include "BotanSHA384.h" #include "BotanSHA512.h" +#include "BotanSHA3_224.h" +#include "BotanSHA3_256.h" +#include "BotanSHA3_384.h" +#include "BotanSHA3_512.h" #ifdef WITH_GOST #include "BotanGOST.h" #include "BotanGOSTR3411.h" @@ -177,6 +181,14 @@ HashAlgorithm* BotanCryptoFactory::getHashAlgorithm(HashAlgo::Type algorithm) return new BotanSHA384(); case HashAlgo::SHA512: return new BotanSHA512(); + 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(); #ifdef WITH_GOST case HashAlgo::GOST: return new BotanGOSTR3411(); @@ -209,6 +221,14 @@ MacAlgorithm* BotanCryptoFactory::getMacAlgorithm(MacAlgo::Type algorithm) return new BotanHMACSHA384(); case MacAlgo::HMAC_SHA512: return new BotanHMACSHA512(); + 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(); #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..5d3f2eb58 100644 --- a/src/lib/crypto/BotanMAC.cpp +++ b/src/lib/crypto/BotanMAC.cpp @@ -93,6 +93,46 @@ size_t BotanHMACSHA512::getMacSize() const return 64; } +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; +} + #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..adca212ef 100644 --- a/src/lib/crypto/BotanRSA.cpp +++ b/src/lib/crypto/BotanRSA.cpp @@ -188,6 +188,18 @@ 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))) { @@ -333,6 +345,122 @@ bool BotanRSA::signInit(PrivateKey* privateKey, const AsymMech::Type mechanism, request << "EMSA4(SHA-512,MGF1," << sLen << ")"; emsa = request.str(); break; + case AsymMech::RSA_SHA3_224_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::SHA3_224)|| + (pssParam->mgfAlg != AsymRSAMGF::MGF1_SHA3_224)) + { + 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; + } + request << "EMSA4(SHA-3(224),MGF1," << sLen << ")"; + emsa = request.str(); + break; + case AsymMech::RSA_SHA3_256_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::SHA3_256)|| + (pssParam->mgfAlg != AsymRSAMGF::MGF1_SHA3_256)) + { + 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; + } + request << "EMSA4(SHA-3(256),MGF1," << sLen << ")"; + emsa = request.str(); + break; + case AsymMech::RSA_SHA3_384_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::SHA3_384)|| + (pssParam->mgfAlg != AsymRSAMGF::MGF1_SHA3_384)) + { + 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)) + { + 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-3(384),MGF1," << sLen << ")"; + emsa = request.str(); + break; + case AsymMech::RSA_SHA3_512_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::SHA3_512)|| + (pssParam->mgfAlg != AsymRSAMGF::MGF1_SHA3_512)) + { + 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)) + { + 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-3(512),MGF1," << sLen << ")"; + emsa = request.str(); + break; case AsymMech::RSA_SSL: emsa = "EMSA3(Parallel(MD5,SHA-160))"; break; @@ -568,6 +696,18 @@ 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))) { @@ -713,6 +853,122 @@ bool BotanRSA::verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, request << "EMSA4(SHA-512,MGF1," << sLen << ")"; emsa = request.str(); break; + case AsymMech::RSA_SHA3_224_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::SHA3_224)|| + (pssParam->mgfAlg != AsymRSAMGF::MGF1_SHA3_224)) + { + 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; + } + request << "EMSA4(SHA-3(224),MGF1," << sLen << ")"; + emsa = request.str(); + break; + case AsymMech::RSA_SHA3_256_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::SHA3_256)|| + (pssParam->mgfAlg != AsymRSAMGF::MGF1_SHA3_256)) + { + 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; + } + request << "EMSA4(SHA-3(256),MGF1," << sLen << ")"; + emsa = request.str(); + break; + case AsymMech::RSA_SHA3_384_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::SHA3_384)|| + (pssParam->mgfAlg != AsymRSAMGF::MGF1_SHA3_384)) + { + 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; + } + request << "EMSA4(SHA-3(384),MGF1," << sLen << ")"; + emsa = request.str(); + break; + case AsymMech::RSA_SHA3_512_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::SHA3_512)|| + (pssParam->mgfAlg != AsymRSAMGF::MGF1_SHA3_512)) + { + 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)) + { + 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-3(512),MGF1," << sLen << ")"; + emsa = request.str(); + break; case AsymMech::RSA_SSL: emsa = "EMSA3(Parallel(MD5,SHA-160))"; break; @@ -1219,6 +1475,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 ""; @@ -1284,6 +1556,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 +1593,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..b98ff3bbc --- /dev/null +++ b/src/lib/crypto/BotanSHA3_224.cpp @@ -0,0 +1,44 @@ +/* + * Copyright (c) 2010 .SE (The Internet Infrastructure Foundation) + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE + * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER + * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR + * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN + * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/***************************************************************************** + BotanSHA3_224.cpp + + Botan SHA3-224 implementation + *****************************************************************************/ + +#include "config.h" +#include "BotanSHA3_224.h" + +int BotanSHA3_224::getHashSize() +{ + return 28; +} + +const char* BotanSHA3_224::getHashName() const +{ + return "SHA-3(224)"; +} diff --git a/src/lib/crypto/BotanSHA3_224.h b/src/lib/crypto/BotanSHA3_224.h new file mode 100644 index 000000000..b0157d442 --- /dev/null +++ b/src/lib/crypto/BotanSHA3_224.h @@ -0,0 +1,47 @@ +/* + * Copyright (c) 2010 .SE (The Internet Infrastructure Foundation) + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE + * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER + * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR + * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN + * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/***************************************************************************** + 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..99c3a772d --- /dev/null +++ b/src/lib/crypto/BotanSHA3_256.cpp @@ -0,0 +1,44 @@ +/* + * Copyright (c) 2010 .SE (The Internet Infrastructure Foundation) + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE + * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER + * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR + * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN + * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/***************************************************************************** + BotanSHA3_256.cpp + + Botan SHA3-256 implementation + *****************************************************************************/ + +#include "config.h" +#include "BotanSHA3_256.h" + +int BotanSHA3_256::getHashSize() +{ + return 32; +} + +const char* BotanSHA3_256::getHashName() const +{ + return "SHA-3(256)"; +} diff --git a/src/lib/crypto/BotanSHA3_256.h b/src/lib/crypto/BotanSHA3_256.h new file mode 100644 index 000000000..9faac7659 --- /dev/null +++ b/src/lib/crypto/BotanSHA3_256.h @@ -0,0 +1,47 @@ +/* + * Copyright (c) 2010 .SE (The Internet Infrastructure Foundation) + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE + * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER + * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR + * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN + * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/***************************************************************************** + 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..577a2a9a6 --- /dev/null +++ b/src/lib/crypto/BotanSHA3_384.cpp @@ -0,0 +1,44 @@ +/* + * Copyright (c) 2010 .SE (The Internet Infrastructure Foundation) + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE + * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER + * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR + * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN + * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/***************************************************************************** + BotanSHA3_384.cpp + + Botan SHA3-384 implementation + *****************************************************************************/ + +#include "config.h" +#include "BotanSHA3_384.h" + +int BotanSHA3_384::getHashSize() +{ + return 48; +} + +const char* BotanSHA3_384::getHashName() const +{ + return "SHA-3(384)"; +} diff --git a/src/lib/crypto/BotanSHA3_384.h b/src/lib/crypto/BotanSHA3_384.h new file mode 100644 index 000000000..7299f2350 --- /dev/null +++ b/src/lib/crypto/BotanSHA3_384.h @@ -0,0 +1,47 @@ +/* + * Copyright (c) 2010 .SE (The Internet Infrastructure Foundation) + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE + * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER + * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR + * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN + * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/***************************************************************************** + 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..7719b6c84 --- /dev/null +++ b/src/lib/crypto/BotanSHA3_512.cpp @@ -0,0 +1,44 @@ +/* + * Copyright (c) 2010 .SE (The Internet Infrastructure Foundation) + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE + * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER + * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR + * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN + * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/***************************************************************************** + BotanSHA3_512.cpp + + Botan SHA3-512 implementation + *****************************************************************************/ + +#include "config.h" +#include "BotanSHA3_512.h" + +int BotanSHA3_512::getHashSize() +{ + return 64; +} + +const char* BotanSHA3_512::getHashName() const +{ + return "SHA-3(512)"; +} diff --git a/src/lib/crypto/BotanSHA3_512.h b/src/lib/crypto/BotanSHA3_512.h new file mode 100644 index 000000000..3c155951f --- /dev/null +++ b/src/lib/crypto/BotanSHA3_512.h @@ -0,0 +1,47 @@ +/* + * Copyright (c) 2010 .SE (The Internet Infrastructure Foundation) + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE + * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER + * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR + * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN + * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/***************************************************************************** + 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..5e61bae0a 100644 --- a/src/lib/crypto/CMakeLists.txt +++ b/src/lib/crypto/CMakeLists.txt @@ -99,6 +99,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 +151,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..bceb1e44e 100644 --- a/src/lib/crypto/Makefile.am +++ b/src/lib/crypto/Makefile.am @@ -106,6 +106,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 +157,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..6995d6672 100644 --- a/src/lib/crypto/OSSLCryptoFactory.cpp +++ b/src/lib/crypto/OSSLCryptoFactory.cpp @@ -42,6 +42,10 @@ #include "OSSLSHA256.h" #include "OSSLSHA384.h" #include "OSSLSHA512.h" +#include "OSSLSHA3_224.h" +#include "OSSLSHA3_256.h" +#include "OSSLSHA3_384.h" +#include "OSSLSHA3_512.h" #include "OSSLCMAC.h" #include "OSSLHMAC.h" #include "OSSLRSA.h" @@ -393,6 +397,14 @@ HashAlgorithm* OSSLCryptoFactory::getHashAlgorithm(HashAlgo::Type algorithm) return new OSSLSHA384(); case HashAlgo::SHA512: return new OSSLSHA512(); + 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(); #ifdef WITH_GOST case HashAlgo::GOST: return new OSSLGOSTR3411(); @@ -423,6 +435,14 @@ MacAlgorithm* OSSLCryptoFactory::getMacAlgorithm(MacAlgo::Type algorithm) return new OSSLHMACSHA384(); case MacAlgo::HMAC_SHA512: return new OSSLHMACSHA512(); + 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(); #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..3175c9071 100644 --- a/src/lib/crypto/OSSLHMAC.cpp +++ b/src/lib/crypto/OSSLHMAC.cpp @@ -96,6 +96,46 @@ size_t OSSLHMACSHA512::getMacSize() const return 64; } +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; +} + #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..9bc8a251f 100644 --- a/src/lib/crypto/OSSLRSA.cpp +++ b/src/lib/crypto/OSSLRSA.cpp @@ -177,6 +177,22 @@ bool OSSLRSA::sign(PrivateKey* privateKey, const ByteString& dataToSign, hash = EVP_sha512(); allowedLen = 64; break; + 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; default: return false; } @@ -198,6 +214,18 @@ bool OSSLRSA::sign(PrivateKey* privateKey, const ByteString& dataToSign, case AsymRSAMGF::MGF1_SHA512: mgf = EVP_sha512(); break; + 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; default: return false; } @@ -347,6 +375,18 @@ 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))) { @@ -487,6 +527,118 @@ bool OSSLRSA::signInit(PrivateKey *privateKey, const AsymMech::Type mechanism, } hash1 = HashAlgo::SHA512; break; + case AsymMech::RSA_SHA3_224_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::SHA3_224)|| + (pssParam->mgfAlg != AsymRSAMGF::MGF1_SHA3_224)) + { + 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; + } + hash1 = HashAlgo::SHA3_224; + break; + case AsymMech::RSA_SHA3_256_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::SHA3_256)|| + (pssParam->mgfAlg != AsymRSAMGF::MGF1_SHA3_256)) + { + 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; + } + hash1 = HashAlgo::SHA3_256; + break; + case AsymMech::RSA_SHA3_384_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::SHA3_384)|| + (pssParam->mgfAlg != AsymRSAMGF::MGF1_SHA3_384)) + { + 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)) + { + 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::SHA3_384; + break; + case AsymMech::RSA_SHA3_512_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::SHA3_512)|| + (pssParam->mgfAlg != AsymRSAMGF::MGF1_SHA3_512)) + { + 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)) + { + 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::SHA3_512; + break; case AsymMech::RSA_SSL: hash1 = HashAlgo::MD5; hash2 = HashAlgo::SHA1; @@ -638,6 +790,22 @@ bool OSSLRSA::signFinal(ByteString& signature) hash = EVP_sha512(); rsaPadding = RSA_PKCS1_PADDING; break; + 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; case AsymMech::RSA_SHA1_PKCS_PSS: rsaPadding = RSA_PKCS1_PSS_PADDING; hash = EVP_sha1(); @@ -658,6 +826,22 @@ bool OSSLRSA::signFinal(ByteString& signature) rsaPadding = RSA_PKCS1_PSS_PADDING; hash = EVP_sha512(); break; + 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; case AsymMech::RSA_SSL: rsaPadding = RSA_PKCS1_PADDING; hash = EVP_md5_sha1(); @@ -801,6 +985,22 @@ bool OSSLRSA::verify(PublicKey* publicKey, const ByteString& originalData, hash = EVP_sha512(); allowedLen = 64; break; + 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; default: return false; } @@ -821,6 +1021,18 @@ bool OSSLRSA::verify(PublicKey* publicKey, const ByteString& originalData, case AsymRSAMGF::MGF1_SHA512: mgf = EVP_sha512(); break; + 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; default: return false; } @@ -958,6 +1170,18 @@ 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))) { @@ -1098,6 +1322,118 @@ bool OSSLRSA::verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, } hash1 = HashAlgo::SHA512; break; + case AsymMech::RSA_SHA3_224_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::SHA3_224)|| + (pssParam->mgfAlg != AsymRSAMGF::MGF1_SHA3_224)) + { + 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; + } + hash1 = HashAlgo::SHA3_224; + break; + case AsymMech::RSA_SHA3_256_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::SHA3_256)|| + (pssParam->mgfAlg != AsymRSAMGF::MGF1_SHA3_256)) + { + 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; + } + hash1 = HashAlgo::SHA3_256; + break; + case AsymMech::RSA_SHA3_384_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::SHA3_384)|| + (pssParam->mgfAlg != AsymRSAMGF::MGF1_SHA3_384)) + { + 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::SHA3_384; + break; + case AsymMech::RSA_SHA3_512_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::SHA3_512)|| + (pssParam->mgfAlg != AsymRSAMGF::MGF1_SHA3_512)) + { + 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)) + { + 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::SHA3_512; + break; case AsymMech::RSA_SSL: hash1 = HashAlgo::MD5; hash2 = HashAlgo::SHA1; @@ -1249,6 +1585,22 @@ bool OSSLRSA::verifyFinal(const ByteString& signature) rsaPadding = RSA_PKCS1_PADDING; hash = EVP_sha512(); break; + 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; case AsymMech::RSA_SHA1_PKCS_PSS: rsaPadding = RSA_PKCS1_PSS_PADDING; hash = EVP_sha1(); @@ -1269,6 +1621,22 @@ bool OSSLRSA::verifyFinal(const ByteString& signature) rsaPadding = RSA_PKCS1_PSS_PADDING; hash = EVP_sha512(); break; + 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; case AsymMech::RSA_SSL: rsaPadding = RSA_PKCS1_PADDING; hash = EVP_md5_sha1(); @@ -1385,6 +1753,22 @@ bool OSSLRSA::encrypt(PublicKey* publicKey, const ByteString& data, hash = EVP_sha512(); hashLen = 64; break; + 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; default: return false; } @@ -1405,6 +1789,18 @@ bool OSSLRSA::encrypt(PublicKey* publicKey, const ByteString& data, case AsymRSAMGF::MGF1_SHA512: mgf = EVP_sha512(); break; + 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; default: return false; } @@ -1555,6 +1951,18 @@ bool OSSLRSA::decrypt(PrivateKey* privateKey, const ByteString& encryptedData, case HashAlgo::SHA512: hash = EVP_sha512(); break; + 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; default: return false; } @@ -1575,6 +1983,18 @@ bool OSSLRSA::decrypt(PrivateKey* privateKey, const ByteString& encryptedData, case AsymRSAMGF::MGF1_SHA512: mgf = EVP_sha512(); break; + 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; 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..5d0180df0 --- /dev/null +++ b/src/lib/crypto/OSSLSHA3_224.cpp @@ -0,0 +1,45 @@ +/* + * Copyright (c) 2010 SURFnet bv + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE + * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER + * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR + * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN + * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/***************************************************************************** + OSSLSHA3_224.cpp + + OpenSSL SHA3-224 implementation + *****************************************************************************/ + +#include "config.h" +#include "OSSLSHA3_224.h" +#include + +int OSSLSHA3_224::getHashSize() +{ + return 28; +} + +const EVP_MD* OSSLSHA3_224::getEVPHash() const +{ + return EVP_sha3_224(); +} diff --git a/src/lib/crypto/OSSLSHA3_224.h b/src/lib/crypto/OSSLSHA3_224.h new file mode 100644 index 000000000..5fbc35a91 --- /dev/null +++ b/src/lib/crypto/OSSLSHA3_224.h @@ -0,0 +1,47 @@ +/* + * Copyright (c) 2010 SURFnet bv + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE + * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER + * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR + * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN + * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/***************************************************************************** + 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..5bd69c2d9 --- /dev/null +++ b/src/lib/crypto/OSSLSHA3_256.cpp @@ -0,0 +1,45 @@ +/* + * Copyright (c) 2010 SURFnet bv + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE + * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER + * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR + * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN + * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/***************************************************************************** + OSSLSHA3_256.cpp + + OpenSSL SHA3-256 implementation + *****************************************************************************/ + +#include "config.h" +#include "OSSLSHA3_256.h" +#include + +int OSSLSHA3_256::getHashSize() +{ + return 32; +} + +const EVP_MD* OSSLSHA3_256::getEVPHash() const +{ + return EVP_sha3_256(); +} diff --git a/src/lib/crypto/OSSLSHA3_256.h b/src/lib/crypto/OSSLSHA3_256.h new file mode 100644 index 000000000..cbe9911fd --- /dev/null +++ b/src/lib/crypto/OSSLSHA3_256.h @@ -0,0 +1,47 @@ +/* + * Copyright (c) 2010 SURFnet bv + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE + * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER + * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR + * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN + * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/***************************************************************************** + 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..c1b23ebf1 --- /dev/null +++ b/src/lib/crypto/OSSLSHA3_384.cpp @@ -0,0 +1,45 @@ +/* + * Copyright (c) 2010 SURFnet bv + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE + * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER + * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR + * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN + * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/***************************************************************************** + OSSLSHA3_384.cpp + + OpenSSL SHA3-384 implementation + *****************************************************************************/ + +#include "config.h" +#include "OSSLSHA3_384.h" +#include + +int OSSLSHA3_384::getHashSize() +{ + return 48; +} + +const EVP_MD* OSSLSHA3_384::getEVPHash() const +{ + return EVP_sha3_384(); +} diff --git a/src/lib/crypto/OSSLSHA3_384.h b/src/lib/crypto/OSSLSHA3_384.h new file mode 100644 index 000000000..c3bf6aa6e --- /dev/null +++ b/src/lib/crypto/OSSLSHA3_384.h @@ -0,0 +1,47 @@ +/* + * Copyright (c) 2010 SURFnet bv + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE + * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER + * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR + * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN + * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/***************************************************************************** + 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..ef7b8d7fd --- /dev/null +++ b/src/lib/crypto/OSSLSHA3_512.cpp @@ -0,0 +1,45 @@ +/* + * Copyright (c) 2010 SURFnet bv + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE + * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER + * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR + * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN + * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/***************************************************************************** + OSSLSHA3_512.cpp + + OpenSSL SHA3-512 implementation + *****************************************************************************/ + +#include "config.h" +#include "OSSLSHA3_512.h" +#include + +int OSSLSHA3_512::getHashSize() +{ + return 64; +} + +const EVP_MD* OSSLSHA3_512::getEVPHash() const +{ + return EVP_sha3_512(); +} diff --git a/src/lib/crypto/OSSLSHA3_512.h b/src/lib/crypto/OSSLSHA3_512.h new file mode 100644 index 000000000..0b1aacff5 --- /dev/null +++ b/src/lib/crypto/OSSLSHA3_512.h @@ -0,0 +1,47 @@ +/* + * Copyright (c) 2010 SURFnet bv + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE + * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER + * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR + * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN + * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/***************************************************************************** + 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/test/HashTests.cpp b/src/lib/crypto/test/HashTests.cpp index f02adbc09..33bbc7b22 100644 --- a/src/lib/crypto/test/HashTests.cpp +++ b/src/lib/crypto/test/HashTests.cpp @@ -233,6 +233,110 @@ void HashTests::testSHA384() rng = NULL; } +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; +} + 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..86bede39a 100644 --- a/src/lib/crypto/test/HashTests.h +++ b/src/lib/crypto/test/HashTests.h @@ -47,6 +47,10 @@ class HashTests : public CppUnit::TestFixture CPPUNIT_TEST(testSHA224); CPPUNIT_TEST(testSHA256); CPPUNIT_TEST(testSHA384); + CPPUNIT_TEST(testSHA3_224); + CPPUNIT_TEST(testSHA3_256); + CPPUNIT_TEST(testSHA3_384); + CPPUNIT_TEST(testSHA3_512); CPPUNIT_TEST(testSHA512); CPPUNIT_TEST_SUITE_END(); @@ -58,6 +62,10 @@ class HashTests : public CppUnit::TestFixture void testSHA224(); void testSHA256(); void testSHA384(); + void testSHA3_224(); + void testSHA3_256(); + void testSHA3_384(); + void testSHA3_512(); void testSHA512(); void setUp(); diff --git a/src/lib/test/AsymEncryptDecryptTests.cpp b/src/lib/test/AsymEncryptDecryptTests.cpp index 279b35f2f..fbebc0120 100644 --- a/src/lib/test/AsymEncryptDecryptTests.cpp +++ b/src/lib/test/AsymEncryptDecryptTests.cpp @@ -253,4 +253,24 @@ void AsymEncryptDecryptTests::testRsaEncryptDecrypt() oaepParams.pSourceData = (void*)EncryptLabel; oaepParams.ulSourceDataLen = strlen(EncryptLabel); rsaEncryptDecrypt(CKM_RSA_PKCS_OAEP,hSessionRO,hPublicKey,hPrivateKey,&oaepParams); + 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); } diff --git a/src/lib/test/DigestTests.cpp b/src/lib/test/DigestTests.cpp index b5e7e7ef4..e96668295 100644 --- a/src/lib/test/DigestTests.cpp +++ b/src/lib/test/DigestTests.cpp @@ -292,6 +292,10 @@ void DigestTests::testDigestAll() { CKM_SHA256, NULL_PTR, 0 }, { CKM_SHA384, NULL_PTR, 0 }, { CKM_SHA512, NULL_PTR, 0 }, + { CKM_SHA3_224, NULL_PTR, 0 }, + { CKM_SHA3_256, NULL_PTR, 0 }, + { CKM_SHA3_384, NULL_PTR, 0 }, + { CKM_SHA3_512, NULL_PTR, 0 }, #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..e83147655 100644 --- a/src/lib/test/SignVerifyTests.cpp +++ b/src/lib/test/SignVerifyTests.cpp @@ -388,7 +388,11 @@ 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 }, + { 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 } }; // Just make sure that we finalize any previous tests @@ -431,6 +435,10 @@ 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); + 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); #ifdef WITH_RAW_PSS signVerifySingleData(20, CKM_RSA_PKCS_PSS, hSessionRO, hPuk,hPrk, ¶ms[0], sizeof(params[0])); @@ -438,6 +446,10 @@ 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])); + 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 signVerifyMulti(CKM_SHA1_RSA_PKCS_PSS, hSessionRO, hPuk,hPrk, ¶ms[0], sizeof(params[0])); @@ -445,6 +457,10 @@ 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])); + 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])); // Private Session Keys rv = generateRSA(hSessionRW,IN_SESSION,IS_PRIVATE,IN_SESSION,IS_PRIVATE,hPuk,hPrk); @@ -460,11 +476,19 @@ 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); + 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); 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])); + 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])); // Public Token Keys rv = generateRSA(hSessionRW,ON_TOKEN,IS_PUBLIC,ON_TOKEN,IS_PUBLIC,hPuk,hPrk); @@ -480,11 +504,19 @@ 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); + 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); 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])); + 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])); // Private Token Keys rv = generateRSA(hSessionRW,ON_TOKEN,IS_PRIVATE,ON_TOKEN,IS_PRIVATE,hPuk,hPrk); @@ -500,11 +532,19 @@ 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); + 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); 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])); + 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])); } #ifdef WITH_ECC @@ -549,12 +589,20 @@ void SignVerifyTests::testEcSignVerify() signVerifySingle(CKM_ECDSA_SHA256, hSessionRO, hPuk, hPrk); signVerifySingle(CKM_ECDSA_SHA384, hSessionRO, hPuk, hPrk); signVerifySingle(CKM_ECDSA_SHA512, hSessionRO, hPuk, hPrk); + 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); 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); + 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); rv = generateEC("P-384", hSessionRW,IN_SESSION,IS_PUBLIC,IN_SESSION,IS_PUBLIC,hPuk,hPrk); CPPUNIT_ASSERT(rv == CKR_OK); @@ -564,12 +612,20 @@ void SignVerifyTests::testEcSignVerify() signVerifySingle(CKM_ECDSA_SHA256, hSessionRO, hPuk, hPrk); signVerifySingle(CKM_ECDSA_SHA384, hSessionRO, hPuk, hPrk); signVerifySingle(CKM_ECDSA_SHA512, hSessionRO, hPuk, hPrk); + 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); 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); + 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); rv = generateEC("P-521", hSessionRW,IN_SESSION,IS_PUBLIC,IN_SESSION,IS_PUBLIC,hPuk,hPrk); CPPUNIT_ASSERT(rv == CKR_OK); @@ -579,12 +635,20 @@ void SignVerifyTests::testEcSignVerify() signVerifySingle(CKM_ECDSA_SHA256, hSessionRO, hPuk, hPrk); signVerifySingle(CKM_ECDSA_SHA384, hSessionRO, hPuk, hPrk); signVerifySingle(CKM_ECDSA_SHA512, hSessionRO, hPuk, hPrk); + 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); 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); + 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); // Private Session Keys rv = generateEC("P-256", hSessionRW,IN_SESSION,IS_PRIVATE,IN_SESSION,IS_PRIVATE,hPuk,hPrk); @@ -595,12 +659,20 @@ void SignVerifyTests::testEcSignVerify() signVerifySingle(CKM_ECDSA_SHA256, hSessionRO, hPuk, hPrk); signVerifySingle(CKM_ECDSA_SHA384, hSessionRO, hPuk, hPrk); signVerifySingle(CKM_ECDSA_SHA512, hSessionRO, hPuk, hPrk); + 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); 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); + 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); rv = generateEC("P-384", hSessionRW,IN_SESSION,IS_PRIVATE,IN_SESSION,IS_PRIVATE,hPuk,hPrk); CPPUNIT_ASSERT(rv == CKR_OK); @@ -610,12 +682,20 @@ void SignVerifyTests::testEcSignVerify() signVerifySingle(CKM_ECDSA_SHA256, hSessionRO, hPuk, hPrk); signVerifySingle(CKM_ECDSA_SHA384, hSessionRO, hPuk, hPrk); signVerifySingle(CKM_ECDSA_SHA512, hSessionRO, hPuk, hPrk); + 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); 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); + 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); rv = generateEC("P-521", hSessionRW,IN_SESSION,IS_PRIVATE,IN_SESSION,IS_PRIVATE,hPuk,hPrk); CPPUNIT_ASSERT(rv == CKR_OK); @@ -625,12 +705,20 @@ void SignVerifyTests::testEcSignVerify() signVerifySingle(CKM_ECDSA_SHA256, hSessionRO, hPuk, hPrk); signVerifySingle(CKM_ECDSA_SHA384, hSessionRO, hPuk, hPrk); signVerifySingle(CKM_ECDSA_SHA512, hSessionRO, hPuk, hPrk); + 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); 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); + 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); // Public Token Keys rv = generateEC("P-256", hSessionRW,ON_TOKEN,IS_PUBLIC,ON_TOKEN,IS_PUBLIC,hPuk,hPrk); @@ -641,12 +729,20 @@ void SignVerifyTests::testEcSignVerify() signVerifySingle(CKM_ECDSA_SHA256, hSessionRO, hPuk, hPrk); signVerifySingle(CKM_ECDSA_SHA384, hSessionRO, hPuk, hPrk); signVerifySingle(CKM_ECDSA_SHA512, hSessionRO, hPuk, hPrk); + 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); 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); + 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); rv = generateEC("P-384", hSessionRW,ON_TOKEN,IS_PUBLIC,ON_TOKEN,IS_PUBLIC,hPuk,hPrk); CPPUNIT_ASSERT(rv == CKR_OK); @@ -656,12 +752,20 @@ void SignVerifyTests::testEcSignVerify() signVerifySingle(CKM_ECDSA_SHA256, hSessionRO, hPuk, hPrk); signVerifySingle(CKM_ECDSA_SHA384, hSessionRO, hPuk, hPrk); signVerifySingle(CKM_ECDSA_SHA512, hSessionRO, hPuk, hPrk); + 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); 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); + 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); rv = generateEC("P-521", hSessionRW,ON_TOKEN,IS_PUBLIC,ON_TOKEN,IS_PUBLIC,hPuk,hPrk); CPPUNIT_ASSERT(rv == CKR_OK); @@ -671,12 +775,20 @@ void SignVerifyTests::testEcSignVerify() signVerifySingle(CKM_ECDSA_SHA256, hSessionRO, hPuk, hPrk); signVerifySingle(CKM_ECDSA_SHA384, hSessionRO, hPuk, hPrk); signVerifySingle(CKM_ECDSA_SHA512, hSessionRO, hPuk, hPrk); + 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); 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); + 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); // Private Token Keys rv = generateEC("P-256", hSessionRW,ON_TOKEN,IS_PRIVATE,ON_TOKEN,IS_PRIVATE,hPuk,hPrk); @@ -687,12 +799,20 @@ void SignVerifyTests::testEcSignVerify() signVerifySingle(CKM_ECDSA_SHA256, hSessionRO, hPuk, hPrk); signVerifySingle(CKM_ECDSA_SHA384, hSessionRO, hPuk, hPrk); signVerifySingle(CKM_ECDSA_SHA512, hSessionRO, hPuk, hPrk); + 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); 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); + 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); rv = generateEC("P-384", hSessionRW,ON_TOKEN,IS_PRIVATE,ON_TOKEN,IS_PRIVATE,hPuk,hPrk); CPPUNIT_ASSERT(rv == CKR_OK); @@ -702,12 +822,20 @@ void SignVerifyTests::testEcSignVerify() signVerifySingle(CKM_ECDSA_SHA256, hSessionRO, hPuk, hPrk); signVerifySingle(CKM_ECDSA_SHA384, hSessionRO, hPuk, hPrk); signVerifySingle(CKM_ECDSA_SHA512, hSessionRO, hPuk, hPrk); + 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); 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); + 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); rv = generateEC("P-521", hSessionRW,ON_TOKEN,IS_PRIVATE,ON_TOKEN,IS_PRIVATE,hPuk,hPrk); CPPUNIT_ASSERT(rv == CKR_OK); @@ -717,12 +845,20 @@ void SignVerifyTests::testEcSignVerify() signVerifySingle(CKM_ECDSA_SHA256, hSessionRO, hPuk, hPrk); signVerifySingle(CKM_ECDSA_SHA384, hSessionRO, hPuk, hPrk); signVerifySingle(CKM_ECDSA_SHA512, hSessionRO, hPuk, hPrk); + 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); 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); + 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 @@ -1067,6 +1203,22 @@ void SignVerifyTests::testMacSignVerify() CPPUNIT_ASSERT(rv == CKR_OK); macSignVerify(CKM_SHA384_HMAC, hSessionRO, hKey); + 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); + rv = generateKey(hSessionRW,CKK_SHA512_HMAC,IN_SESSION,IS_PUBLIC,hKey); CPPUNIT_ASSERT(rv == CKR_OK); macSignVerify(CKM_SHA512_HMAC, hSessionRO, hKey); @@ -1264,7 +1416,7 @@ 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, CKM_DSA_SHA3_256 }; for (size_t i = 0; i < sizeof(dsaMechs)/sizeof(dsaMechs[0]); i++) { CK_MECHANISM mechanism = { dsaMechs[i], NULL_PTR, 0 }; @@ -1358,7 +1510,7 @@ 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, CKM_DSA_SHA3_256 }; for (size_t i = 0; i < sizeof(dsaMechs)/sizeof(dsaMechs[0]); i++) { CK_MECHANISM mechanism = { dsaMechs[i], NULL_PTR, 0 }; From b349775f07e1a4cc41354f9053281074ecda24fb Mon Sep 17 00:00:00 2001 From: Alexandre Laroche Date: Wed, 22 Jul 2026 20:37:25 -0400 Subject: [PATCH 02/10] Gate SHA3 support behind detected OpenSSL/LibreSSL capability EVP_sha3_*() requires OpenSSL >= 1.1.1 or LibreSSL >= 3.8.0, newer than SoftHSM's OpenSSL 1.0.0 baseline. Add a --enable-sha3 configure option (default detect, mirroring --enable-ecc/--enable-eddsa/--enable-mldsa) that probes for real EVP_sha3_224/256/384/512 support via a compile/link check rather than a version-number comparison, since LibreSSL pins OPENSSL_VERSION_NUMBER to a fixed value and can't be version-sniffed. Botan always resolves to supported, since it has had SHA3 since well before its own minimum required version. Every SHA3 code path is gated behind the resulting WITH_SHA3 define: the OSSLSHA3_*/BotanSHA3_* digest classes, the HMAC-SHA3 implementations, crypto factory dispatch, every EVP_sha3_*() call site in OSSLRSA.cpp, the PKCS#11 mechanism registration/dispatch in SoftHSM.cpp, and the corresponding unit tests -- mirroring how WITH_ECC/WITH_EDDSA are already handled throughout the codebase. This keeps the OpenSSL floor at 1.0.0 while avoiding build failures against old OpenSSL or LibreSSL. --- README.md | 1 + m4/acx_crypto_backend.m4 | 37 +++++++++++ m4/acx_openssl_sha3.m4 | 40 ++++++++++++ src/lib/SoftHSM.cpp | 56 ++++++++++++++++ src/lib/crypto/BotanCryptoFactory.cpp | 6 ++ src/lib/crypto/BotanMAC.cpp | 2 + src/lib/crypto/BotanSHA3_224.cpp | 2 + src/lib/crypto/BotanSHA3_256.cpp | 2 + src/lib/crypto/BotanSHA3_384.cpp | 2 + src/lib/crypto/BotanSHA3_512.cpp | 2 + src/lib/crypto/OSSLCryptoFactory.cpp | 6 ++ src/lib/crypto/OSSLHMAC.cpp | 2 + src/lib/crypto/OSSLRSA.cpp | 24 +++++++ src/lib/crypto/OSSLSHA3_224.cpp | 2 + src/lib/crypto/OSSLSHA3_256.cpp | 2 + src/lib/crypto/OSSLSHA3_384.cpp | 2 + src/lib/crypto/OSSLSHA3_512.cpp | 2 + src/lib/crypto/test/HashTests.cpp | 2 + src/lib/crypto/test/HashTests.h | 4 ++ src/lib/test/AsymEncryptDecryptTests.cpp | 2 + src/lib/test/DigestTests.cpp | 2 + src/lib/test/SignVerifyTests.cpp | 82 +++++++++++++++++++++++- 22 files changed, 280 insertions(+), 2 deletions(-) create mode 100644 m4/acx_openssl_sha3.m4 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/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..bfb009325 --- /dev/null +++ b/m4/acx_openssl_sha3.m4 @@ -0,0 +1,40 @@ +AC_DEFUN([ACX_OPENSSL_SHA3],[ + AC_MSG_CHECKING(for OpenSSL SHA3 support) + + tmp_CPPFLAGS=$CPPFLAGS + tmp_LIBS=$LIBS + + CPPFLAGS="$CPPFLAGS $CRYPTO_INCLUDES" + LIBS="$CRYPTO_LIBS $LIBS" + + AC_LANG_PUSH([C]) + AC_CACHE_VAL([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; + } + ]]) + ],[ + AC_MSG_RESULT([yes]) + acx_cv_lib_openssl_sha3_support=yes + ],[ + AC_MSG_RESULT([no]) + 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/lib/SoftHSM.cpp b/src/lib/SoftHSM.cpp index 2dbd5e70b..1f4fdf15a 100644 --- a/src/lib/SoftHSM.cpp +++ b/src/lib/SoftHSM.cpp @@ -775,10 +775,12 @@ void SoftHSM::prepareSupportedMechanisms(std::mapulMinKeySize = 0; pInfo->ulMaxKeySize = 0; @@ -1187,6 +1201,7 @@ 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; @@ -1207,6 +1222,7 @@ CK_RV SoftHSM::C_GetMechanismInfo(CK_SLOT_ID slotID, CK_MECHANISM_TYPE type, CK_ pInfo->ulMaxKeySize = 512; pInfo->flags = CKF_SIGN | CKF_VERIFY; break; +#endif case CKM_RSA_PKCS_KEY_PAIR_GEN: pInfo->ulMinKeySize = rsaMinSize; pInfo->ulMaxKeySize = rsaMaxSize; @@ -1230,10 +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 @@ -1242,10 +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; @@ -1369,10 +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; @@ -1405,10 +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; @@ -3911,6 +3935,7 @@ 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; @@ -3923,6 +3948,7 @@ CK_RV SoftHSM::C_DigestInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechan case CKM_SHA3_512: algo = HashAlgo::SHA3_512; break; +#endif #ifdef WITH_GOST case CKM_GOSTR3411: algo = HashAlgo::GOST; @@ -4176,10 +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 @@ -4281,6 +4309,7 @@ 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; @@ -4305,6 +4334,7 @@ CK_RV SoftHSM::MacSignInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechani minSize = 64; algo = MacAlgo::HMAC_SHA3_512; break; +#endif #ifdef WITH_GOST case CKM_GOSTR3411_HMAC: if (keyType != CKK_GENERIC_SECRET && keyType != CKK_GOST28147) @@ -4476,6 +4506,7 @@ 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; @@ -4496,6 +4527,7 @@ CK_RV SoftHSM::AsymSignInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechan bAllowMultiPartOp = true; isRSA = true; break; +#endif #ifdef WITH_RAW_PSS case CKM_RSA_PKCS_PSS: if (pMechanism->pParameter == NULL_PTR || @@ -4533,6 +4565,7 @@ 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; @@ -4553,6 +4586,7 @@ CK_RV SoftHSM::AsymSignInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechan rsaPssParam.mgfAlg = AsymRSAMGF::MGF1_SHA3_512; allowedMgf = CKG_MGF1_SHA3_512; break; +#endif default: ERROR_MSG("Invalid RSA-PSS hash"); return CKR_ARGUMENTS_BAD; @@ -4654,6 +4688,7 @@ 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) || @@ -4722,6 +4757,7 @@ CK_RV SoftHSM::AsymSignInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechan bAllowMultiPartOp = true; isRSA = true; break; +#endif case CKM_DSA: mechanism = AsymMech::DSA; bAllowMultiPartOp = false; @@ -4752,6 +4788,7 @@ 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; @@ -4772,6 +4809,7 @@ CK_RV SoftHSM::AsymSignInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechan bAllowMultiPartOp = true; isDSA = true; break; +#endif #ifdef WITH_ECC case CKM_ECDSA: mechanism = AsymMech::ECDSA; @@ -4803,6 +4841,7 @@ 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; @@ -4824,6 +4863,7 @@ CK_RV SoftHSM::AsymSignInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechan isECDSA = true; break; #endif +#endif #ifdef WITH_GOST case CKM_GOSTR3410: mechanism = AsymMech::GOST; @@ -5543,6 +5583,7 @@ 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; @@ -5567,6 +5608,7 @@ CK_RV SoftHSM::MacVerifyInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMecha minSize = 64; algo = MacAlgo::HMAC_SHA3_512; break; +#endif #ifdef WITH_GOST case CKM_GOSTR3411_HMAC: if (keyType != CKK_GENERIC_SECRET && keyType != CKK_GOST28147) @@ -5738,6 +5780,7 @@ 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; @@ -5758,6 +5801,7 @@ CK_RV SoftHSM::AsymVerifyInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMech bAllowMultiPartOp = true; isRSA = true; break; +#endif #ifdef WITH_RAW_PSS case CKM_RSA_PKCS_PSS: if (pMechanism->pParameter == NULL_PTR || @@ -5795,6 +5839,7 @@ 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; @@ -5815,6 +5860,7 @@ CK_RV SoftHSM::AsymVerifyInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMech rsaPssParam.mgfAlg = AsymRSAMGF::MGF1_SHA3_512; expectedMgf = CKG_MGF1_SHA3_512; break; +#endif default: return CKR_ARGUMENTS_BAD; } @@ -5915,6 +5961,7 @@ 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) || @@ -5983,6 +6030,7 @@ CK_RV SoftHSM::AsymVerifyInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMech bAllowMultiPartOp = true; isRSA = true; break; +#endif case CKM_DSA: mechanism = AsymMech::DSA; bAllowMultiPartOp = false; @@ -6013,6 +6061,7 @@ 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; @@ -6033,6 +6082,7 @@ CK_RV SoftHSM::AsymVerifyInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMech bAllowMultiPartOp = true; isDSA = true; break; +#endif #ifdef WITH_ECC case CKM_ECDSA: mechanism = AsymMech::ECDSA; @@ -6064,6 +6114,7 @@ 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; @@ -6085,6 +6136,7 @@ CK_RV SoftHSM::AsymVerifyInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMech isECDSA = true; break; #endif +#endif #ifdef WITH_GOST case CKM_GOSTR3410: mechanism = AsymMech::GOST; @@ -15336,6 +15388,7 @@ 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; @@ -15352,6 +15405,7 @@ CK_RV SoftHSM::BuildRSAOAEPParam(const CK_RSA_PKCS_OAEP_PARAMS *params, mechanismParam->hashAlg = HashAlgo::SHA3_512; if (hashLen) *hashLen = 64; break; +#endif default: ERROR_MSG("hash algorithm not supported for OAEP"); return CKR_ARGUMENTS_BAD; @@ -15373,6 +15427,7 @@ 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; @@ -15385,6 +15440,7 @@ CK_RV SoftHSM::BuildRSAOAEPParam(const CK_RSA_PKCS_OAEP_PARAMS *params, 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/BotanCryptoFactory.cpp b/src/lib/crypto/BotanCryptoFactory.cpp index 70b4e4645..fbe1dfce3 100644 --- a/src/lib/crypto/BotanCryptoFactory.cpp +++ b/src/lib/crypto/BotanCryptoFactory.cpp @@ -48,10 +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" @@ -181,6 +183,7 @@ 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: @@ -189,6 +192,7 @@ HashAlgorithm* BotanCryptoFactory::getHashAlgorithm(HashAlgo::Type algorithm) return new BotanSHA3_384(); case HashAlgo::SHA3_512: return new BotanSHA3_512(); +#endif #ifdef WITH_GOST case HashAlgo::GOST: return new BotanGOSTR3411(); @@ -221,6 +225,7 @@ 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: @@ -229,6 +234,7 @@ MacAlgorithm* BotanCryptoFactory::getMacAlgorithm(MacAlgo::Type algorithm) 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/BotanMAC.cpp b/src/lib/crypto/BotanMAC.cpp index 5d3f2eb58..246819c86 100644 --- a/src/lib/crypto/BotanMAC.cpp +++ b/src/lib/crypto/BotanMAC.cpp @@ -93,6 +93,7 @@ size_t BotanHMACSHA512::getMacSize() const return 64; } +#ifdef WITH_SHA3 std::string BotanHMACSHA3_224::getAlgorithm() const { return "HMAC(SHA-3(224))"; @@ -132,6 +133,7 @@ size_t BotanHMACSHA3_512::getMacSize() const { return 64; } +#endif #ifdef WITH_GOST std::string BotanHMACGOSTR3411::getAlgorithm() const diff --git a/src/lib/crypto/BotanSHA3_224.cpp b/src/lib/crypto/BotanSHA3_224.cpp index b98ff3bbc..86f87af09 100644 --- a/src/lib/crypto/BotanSHA3_224.cpp +++ b/src/lib/crypto/BotanSHA3_224.cpp @@ -31,6 +31,7 @@ *****************************************************************************/ #include "config.h" +#ifdef WITH_SHA3 #include "BotanSHA3_224.h" int BotanSHA3_224::getHashSize() @@ -42,3 +43,4 @@ const char* BotanSHA3_224::getHashName() const { return "SHA-3(224)"; } +#endif diff --git a/src/lib/crypto/BotanSHA3_256.cpp b/src/lib/crypto/BotanSHA3_256.cpp index 99c3a772d..086705847 100644 --- a/src/lib/crypto/BotanSHA3_256.cpp +++ b/src/lib/crypto/BotanSHA3_256.cpp @@ -31,6 +31,7 @@ *****************************************************************************/ #include "config.h" +#ifdef WITH_SHA3 #include "BotanSHA3_256.h" int BotanSHA3_256::getHashSize() @@ -42,3 +43,4 @@ const char* BotanSHA3_256::getHashName() const { return "SHA-3(256)"; } +#endif diff --git a/src/lib/crypto/BotanSHA3_384.cpp b/src/lib/crypto/BotanSHA3_384.cpp index 577a2a9a6..7bb248fa0 100644 --- a/src/lib/crypto/BotanSHA3_384.cpp +++ b/src/lib/crypto/BotanSHA3_384.cpp @@ -31,6 +31,7 @@ *****************************************************************************/ #include "config.h" +#ifdef WITH_SHA3 #include "BotanSHA3_384.h" int BotanSHA3_384::getHashSize() @@ -42,3 +43,4 @@ const char* BotanSHA3_384::getHashName() const { return "SHA-3(384)"; } +#endif diff --git a/src/lib/crypto/BotanSHA3_512.cpp b/src/lib/crypto/BotanSHA3_512.cpp index 7719b6c84..a85a07cc9 100644 --- a/src/lib/crypto/BotanSHA3_512.cpp +++ b/src/lib/crypto/BotanSHA3_512.cpp @@ -31,6 +31,7 @@ *****************************************************************************/ #include "config.h" +#ifdef WITH_SHA3 #include "BotanSHA3_512.h" int BotanSHA3_512::getHashSize() @@ -42,3 +43,4 @@ const char* BotanSHA3_512::getHashName() const { return "SHA-3(512)"; } +#endif diff --git a/src/lib/crypto/OSSLCryptoFactory.cpp b/src/lib/crypto/OSSLCryptoFactory.cpp index 6995d6672..b70eec4e7 100644 --- a/src/lib/crypto/OSSLCryptoFactory.cpp +++ b/src/lib/crypto/OSSLCryptoFactory.cpp @@ -42,10 +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" @@ -397,6 +399,7 @@ 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: @@ -405,6 +408,7 @@ HashAlgorithm* OSSLCryptoFactory::getHashAlgorithm(HashAlgo::Type algorithm) return new OSSLSHA3_384(); case HashAlgo::SHA3_512: return new OSSLSHA3_512(); +#endif #ifdef WITH_GOST case HashAlgo::GOST: return new OSSLGOSTR3411(); @@ -435,6 +439,7 @@ 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: @@ -443,6 +448,7 @@ MacAlgorithm* OSSLCryptoFactory::getMacAlgorithm(MacAlgo::Type algorithm) 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/OSSLHMAC.cpp b/src/lib/crypto/OSSLHMAC.cpp index 3175c9071..bb3c6225d 100644 --- a/src/lib/crypto/OSSLHMAC.cpp +++ b/src/lib/crypto/OSSLHMAC.cpp @@ -96,6 +96,7 @@ size_t OSSLHMACSHA512::getMacSize() const return 64; } +#ifdef WITH_SHA3 const EVP_MD* OSSLHMACSHA3_224::getEVPHash() const { return EVP_sha3_224(); @@ -135,6 +136,7 @@ size_t OSSLHMACSHA3_512::getMacSize() const { return 64; } +#endif #ifdef WITH_GOST const EVP_MD* OSSLHMACGOSTR3411::getEVPHash() const diff --git a/src/lib/crypto/OSSLRSA.cpp b/src/lib/crypto/OSSLRSA.cpp index 9bc8a251f..4304947c5 100644 --- a/src/lib/crypto/OSSLRSA.cpp +++ b/src/lib/crypto/OSSLRSA.cpp @@ -177,6 +177,7 @@ 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; @@ -193,6 +194,7 @@ bool OSSLRSA::sign(PrivateKey* privateKey, const ByteString& dataToSign, hash = EVP_sha3_512(); allowedLen = 64; break; +#endif default: return false; } @@ -214,6 +216,7 @@ 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; @@ -226,6 +229,7 @@ bool OSSLRSA::sign(PrivateKey* privateKey, const ByteString& dataToSign, case AsymRSAMGF::MGF1_SHA3_512: mgf = EVP_sha3_512(); break; +#endif default: return false; } @@ -790,6 +794,7 @@ 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; @@ -806,6 +811,7 @@ bool OSSLRSA::signFinal(ByteString& signature) hash = EVP_sha3_512(); rsaPadding = RSA_PKCS1_PADDING; break; +#endif case AsymMech::RSA_SHA1_PKCS_PSS: rsaPadding = RSA_PKCS1_PSS_PADDING; hash = EVP_sha1(); @@ -826,6 +832,7 @@ 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(); @@ -842,6 +849,7 @@ bool OSSLRSA::signFinal(ByteString& signature) rsaPadding = RSA_PKCS1_PSS_PADDING; hash = EVP_sha3_512(); break; +#endif case AsymMech::RSA_SSL: rsaPadding = RSA_PKCS1_PADDING; hash = EVP_md5_sha1(); @@ -985,6 +993,7 @@ 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; @@ -1001,6 +1010,7 @@ bool OSSLRSA::verify(PublicKey* publicKey, const ByteString& originalData, hash = EVP_sha3_512(); allowedLen = 64; break; +#endif default: return false; } @@ -1021,6 +1031,7 @@ 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; @@ -1033,6 +1044,7 @@ bool OSSLRSA::verify(PublicKey* publicKey, const ByteString& originalData, case AsymRSAMGF::MGF1_SHA3_512: mgf = EVP_sha3_512(); break; +#endif default: return false; } @@ -1585,6 +1597,7 @@ 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(); @@ -1601,6 +1614,7 @@ bool OSSLRSA::verifyFinal(const ByteString& signature) rsaPadding = RSA_PKCS1_PADDING; hash = EVP_sha3_512(); break; +#endif case AsymMech::RSA_SHA1_PKCS_PSS: rsaPadding = RSA_PKCS1_PSS_PADDING; hash = EVP_sha1(); @@ -1621,6 +1635,7 @@ 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(); @@ -1637,6 +1652,7 @@ bool OSSLRSA::verifyFinal(const ByteString& signature) rsaPadding = RSA_PKCS1_PSS_PADDING; hash = EVP_sha3_512(); break; +#endif case AsymMech::RSA_SSL: rsaPadding = RSA_PKCS1_PADDING; hash = EVP_md5_sha1(); @@ -1753,6 +1769,7 @@ 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; @@ -1769,6 +1786,7 @@ bool OSSLRSA::encrypt(PublicKey* publicKey, const ByteString& data, hash = EVP_sha3_512(); hashLen = 64; break; +#endif default: return false; } @@ -1789,6 +1807,7 @@ 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; @@ -1801,6 +1820,7 @@ bool OSSLRSA::encrypt(PublicKey* publicKey, const ByteString& data, case AsymRSAMGF::MGF1_SHA3_512: mgf = EVP_sha3_512(); break; +#endif default: return false; } @@ -1951,6 +1971,7 @@ 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; @@ -1963,6 +1984,7 @@ bool OSSLRSA::decrypt(PrivateKey* privateKey, const ByteString& encryptedData, case HashAlgo::SHA3_512: hash = EVP_sha3_512(); break; +#endif default: return false; } @@ -1983,6 +2005,7 @@ 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; @@ -1995,6 +2018,7 @@ bool OSSLRSA::decrypt(PrivateKey* privateKey, const ByteString& encryptedData, 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 index 5d0180df0..7894e1cb6 100644 --- a/src/lib/crypto/OSSLSHA3_224.cpp +++ b/src/lib/crypto/OSSLSHA3_224.cpp @@ -31,6 +31,7 @@ *****************************************************************************/ #include "config.h" +#ifdef WITH_SHA3 #include "OSSLSHA3_224.h" #include @@ -43,3 +44,4 @@ const EVP_MD* OSSLSHA3_224::getEVPHash() const { return EVP_sha3_224(); } +#endif diff --git a/src/lib/crypto/OSSLSHA3_256.cpp b/src/lib/crypto/OSSLSHA3_256.cpp index 5bd69c2d9..273313bac 100644 --- a/src/lib/crypto/OSSLSHA3_256.cpp +++ b/src/lib/crypto/OSSLSHA3_256.cpp @@ -31,6 +31,7 @@ *****************************************************************************/ #include "config.h" +#ifdef WITH_SHA3 #include "OSSLSHA3_256.h" #include @@ -43,3 +44,4 @@ const EVP_MD* OSSLSHA3_256::getEVPHash() const { return EVP_sha3_256(); } +#endif diff --git a/src/lib/crypto/OSSLSHA3_384.cpp b/src/lib/crypto/OSSLSHA3_384.cpp index c1b23ebf1..f134ad567 100644 --- a/src/lib/crypto/OSSLSHA3_384.cpp +++ b/src/lib/crypto/OSSLSHA3_384.cpp @@ -31,6 +31,7 @@ *****************************************************************************/ #include "config.h" +#ifdef WITH_SHA3 #include "OSSLSHA3_384.h" #include @@ -43,3 +44,4 @@ const EVP_MD* OSSLSHA3_384::getEVPHash() const { return EVP_sha3_384(); } +#endif diff --git a/src/lib/crypto/OSSLSHA3_512.cpp b/src/lib/crypto/OSSLSHA3_512.cpp index ef7b8d7fd..5dddd1673 100644 --- a/src/lib/crypto/OSSLSHA3_512.cpp +++ b/src/lib/crypto/OSSLSHA3_512.cpp @@ -31,6 +31,7 @@ *****************************************************************************/ #include "config.h" +#ifdef WITH_SHA3 #include "OSSLSHA3_512.h" #include @@ -43,3 +44,4 @@ const EVP_MD* OSSLSHA3_512::getEVPHash() const { return EVP_sha3_512(); } +#endif diff --git a/src/lib/crypto/test/HashTests.cpp b/src/lib/crypto/test/HashTests.cpp index 33bbc7b22..70b151f4c 100644 --- a/src/lib/crypto/test/HashTests.cpp +++ b/src/lib/crypto/test/HashTests.cpp @@ -233,6 +233,7 @@ void HashTests::testSHA384() rng = NULL; } +#ifdef WITH_SHA3 void HashTests::testSHA3_224() { CPPUNIT_ASSERT((hash = CryptoFactory::i()->getHashAlgorithm(HashAlgo::SHA3_224)) != NULL); @@ -336,6 +337,7 @@ void HashTests::testSHA3_512() CryptoFactory::i()->recycleHashAlgorithm(hash); hash = NULL; } +#endif void HashTests::testSHA512() { diff --git a/src/lib/crypto/test/HashTests.h b/src/lib/crypto/test/HashTests.h index 86bede39a..639367cf8 100644 --- a/src/lib/crypto/test/HashTests.h +++ b/src/lib/crypto/test/HashTests.h @@ -47,10 +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(); @@ -62,10 +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 fbebc0120..fe16986f6 100644 --- a/src/lib/test/AsymEncryptDecryptTests.cpp +++ b/src/lib/test/AsymEncryptDecryptTests.cpp @@ -253,6 +253,7 @@ 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; @@ -273,4 +274,5 @@ void AsymEncryptDecryptTests::testRsaEncryptDecrypt() 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 e96668295..5606d62a5 100644 --- a/src/lib/test/DigestTests.cpp +++ b/src/lib/test/DigestTests.cpp @@ -292,10 +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 e83147655..8684b946d 100644 --- a/src/lib/test/SignVerifyTests.cpp +++ b/src/lib/test/SignVerifyTests.cpp @@ -389,10 +389,12 @@ void SignVerifyTests::testRsaSignVerify() { CKM_SHA256, CKG_MGF1_SHA256, 32 }, { CKM_SHA384, CKG_MGF1_SHA384, 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 @@ -435,10 +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])); @@ -446,10 +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])); @@ -457,10 +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); @@ -476,19 +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); @@ -504,19 +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); @@ -532,19 +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 @@ -589,20 +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); @@ -612,20 +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); @@ -635,20 +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); @@ -659,20 +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); @@ -682,20 +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); @@ -705,20 +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); @@ -729,20 +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); @@ -752,20 +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); @@ -775,20 +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); @@ -799,20 +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); @@ -822,20 +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); @@ -845,20 +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 @@ -1203,6 +1271,7 @@ 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); @@ -1219,6 +1288,7 @@ void SignVerifyTests::testMacSignVerify() 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); @@ -1416,7 +1486,11 @@ void SignVerifyTests::testSignInitWrongKeyType() } // DSA mechanisms with EC key - CK_MECHANISM_TYPE dsaMechs[] = { CKM_DSA, CKM_DSA_SHA1, CKM_DSA_SHA256, CKM_DSA_SHA3_256 }; + 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 }; @@ -1510,7 +1584,11 @@ void SignVerifyTests::testVerifyInitWrongKeyType() } // DSA mechanisms with EC key - CK_MECHANISM_TYPE dsaMechs[] = { CKM_DSA, CKM_DSA_SHA1, CKM_DSA_SHA256, CKM_DSA_SHA3_256 }; + 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 }; From 41cd8d2a81c61a5eeb714bb22ee19d27b280b47e Mon Sep 17 00:00:00 2001 From: Alexandre Laroche Date: Wed, 22 Jul 2026 20:37:31 -0400 Subject: [PATCH 03/10] Fix RSA-PSS salt length bound to use actual hash size getCipherRawPss() hardcoded the salt-length upper bound (bitLength+6)/8-2-20 assuming a 20-byte SHA-1 digest, even though the function already computes allowedLen per hash algorithm just above. For any non-SHA1 hash (SHA-224/256/384/512, SHA3-224/256/384/512) this let sLen exceed the true PKCS#1 v2.1 RSASSA-PSS bound (emLen - hLen - 2), miscomputing the maximum allowed salt length. Use allowedLen instead of the hardcoded 20. --- src/lib/crypto/BotanRSA.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/lib/crypto/BotanRSA.cpp b/src/lib/crypto/BotanRSA.cpp index adca212ef..345a5894b 100644 --- a/src/lib/crypto/BotanRSA.cpp +++ b/src/lib/crypto/BotanRSA.cpp @@ -1503,7 +1503,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); From 875d335300046a39600cf066e2cd07055a32dc89 Mon Sep 17 00:00:00 2001 From: Alexandre Laroche Date: Wed, 22 Jul 2026 21:48:08 -0400 Subject: [PATCH 04/10] Fix SHA3 detection to report result on cached configure runs AC_CACHE_VAL skips its body once acx_cv_lib_openssl_sha3_support is cached, so the AC_MSG_RESULT calls inside it never ran on repeat configure invocations, leaving "checking for OpenSSL SHA3 support..." without a yes/no. Switch to AC_CACHE_CHECK, which prints the cached result unconditionally instead of only on a cold cache. --- m4/acx_openssl_sha3.m4 | 6 +----- 1 file changed, 1 insertion(+), 5 deletions(-) diff --git a/m4/acx_openssl_sha3.m4 b/m4/acx_openssl_sha3.m4 index bfb009325..ca68df4b1 100644 --- a/m4/acx_openssl_sha3.m4 +++ b/m4/acx_openssl_sha3.m4 @@ -1,6 +1,4 @@ AC_DEFUN([ACX_OPENSSL_SHA3],[ - AC_MSG_CHECKING(for OpenSSL SHA3 support) - tmp_CPPFLAGS=$CPPFLAGS tmp_LIBS=$LIBS @@ -8,7 +6,7 @@ AC_DEFUN([ACX_OPENSSL_SHA3],[ LIBS="$CRYPTO_LIBS $LIBS" AC_LANG_PUSH([C]) - AC_CACHE_VAL([acx_cv_lib_openssl_sha3_support],[ + 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([[ @@ -25,10 +23,8 @@ AC_DEFUN([ACX_OPENSSL_SHA3],[ } ]]) ],[ - AC_MSG_RESULT([yes]) acx_cv_lib_openssl_sha3_support=yes ],[ - AC_MSG_RESULT([no]) acx_cv_lib_openssl_sha3_support=no ]) ]) From 223d3d8db66b76fc762ec47be23aad98e4c4aa76 Mon Sep 17 00:00:00 2001 From: Alexandre Laroche Date: Wed, 22 Jul 2026 22:05:23 -0400 Subject: [PATCH 05/10] Add missing WITH_SHA3 cmakedefine to config.h.in.cmake Every other optional crypto feature added alongside SHA3 (ECC, EDDSA, ML-DSA, ML-KEM) has a #cmakedefine entry here; SHA3 was missing one. --- config.h.in.cmake | 3 +++ 1 file changed, 3 insertions(+) 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@ From 663cf204a218ee13c58f92e373028f6ad5d6594e Mon Sep 17 00:00:00 2001 From: Alexandre Laroche Date: Mon, 27 Jul 2026 07:58:49 -0400 Subject: [PATCH 06/10] Factor RSA-PSS mechanism parameter checks into a dedicated method Addresses review comment on PR #894: the mechanism-param type/hash/MGF validation and salt-length bound check were duplicated across all 10 PSS hash variants in both signInit and verifyInit. --- src/lib/crypto/BotanRSA.cpp | 408 ++++-------------------------------- src/lib/crypto/BotanRSA.h | 1 + 2 files changed, 47 insertions(+), 362 deletions(-) diff --git a/src/lib/crypto/BotanRSA.cpp b/src/lib/crypto/BotanRSA.cpp index 345a5894b..2d9214f07 100644 --- a/src/lib/crypto/BotanRSA.cpp +++ b/src/lib/crypto/BotanRSA.cpp @@ -144,6 +144,34 @@ bool BotanRSA::sign(PrivateKey* privateKey, const ByteString& dataToSign, return true; } +// 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. +bool BotanRSA::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; +} + bool BotanRSA::signInit(PrivateKey* privateKey, const AsymMech::Type mechanism, const MechanismParam* mechanismParam /*= NULL */) { @@ -166,7 +194,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) { @@ -201,27 +228,8 @@ bool BotanRSA::signInit(PrivateKey* privateKey, const AsymMech::Type mechanism, 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::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)) + if (!checkPssParams(mechanismParam, HashAlgo::SHA1, AsymRSAMGF::MGF1_SHA1, 20, 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; @@ -230,27 +238,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 (!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; @@ -259,27 +248,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)) - { - 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)) + if (!checkPssParams(mechanismParam, HashAlgo::SHA256, AsymRSAMGF::MGF1_SHA256, 32, 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; @@ -288,27 +258,8 @@ 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))) - { - 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)) + if (!checkPssParams(mechanismParam, HashAlgo::SHA384, AsymRSAMGF::MGF1_SHA384, 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-48)) - { - ERROR_MSG("sLen (%lu) is too large for current key size (%lu)", - (unsigned long)sLen, privateKey->getBitLength()); ByteString dummy; AsymmetricAlgorithm::signFinal(dummy); return false; @@ -317,27 +268,8 @@ bool BotanRSA::signInit(PrivateKey* privateKey, const AsymMech::Type mechanism, emsa = request.str(); break; case AsymMech::RSA_SHA512_PKCS_PSS: - if ((mechanismParam == NULL) || (!mechanismParam->isOfType(RSAPssMechanismParam::type))) + if (!checkPssParams(mechanismParam, HashAlgo::SHA512, AsymRSAMGF::MGF1_SHA512, 64, 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)) - { - 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)) - { - ERROR_MSG("sLen (%lu) is too large for current key size (%lu)", - (unsigned long)sLen, privateKey->getBitLength()); ByteString dummy; AsymmetricAlgorithm::signFinal(dummy); return false; @@ -346,27 +278,8 @@ bool BotanRSA::signInit(PrivateKey* privateKey, const AsymMech::Type mechanism, emsa = request.str(); break; case AsymMech::RSA_SHA3_224_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::SHA3_224)|| - (pssParam->mgfAlg != AsymRSAMGF::MGF1_SHA3_224)) + if (!checkPssParams(mechanismParam, HashAlgo::SHA3_224, AsymRSAMGF::MGF1_SHA3_224, 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; @@ -375,27 +288,8 @@ bool BotanRSA::signInit(PrivateKey* privateKey, const AsymMech::Type mechanism, emsa = request.str(); break; case AsymMech::RSA_SHA3_256_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::SHA3_256)|| - (pssParam->mgfAlg != AsymRSAMGF::MGF1_SHA3_256)) + if (!checkPssParams(mechanismParam, HashAlgo::SHA3_256, AsymRSAMGF::MGF1_SHA3_256, 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; @@ -404,27 +298,8 @@ bool BotanRSA::signInit(PrivateKey* privateKey, const AsymMech::Type mechanism, emsa = request.str(); break; case AsymMech::RSA_SHA3_384_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::SHA3_384)|| - (pssParam->mgfAlg != AsymRSAMGF::MGF1_SHA3_384)) - { - 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)) + if (!checkPssParams(mechanismParam, HashAlgo::SHA3_384, AsymRSAMGF::MGF1_SHA3_384, 48, 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; @@ -433,27 +308,8 @@ bool BotanRSA::signInit(PrivateKey* privateKey, const AsymMech::Type mechanism, emsa = request.str(); break; case AsymMech::RSA_SHA3_512_PKCS_PSS: - if ((mechanismParam == NULL) || (!mechanismParam->isOfType(RSAPssMechanismParam::type))) + if (!checkPssParams(mechanismParam, HashAlgo::SHA3_512, AsymRSAMGF::MGF1_SHA3_512, 64, 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::SHA3_512)|| - (pssParam->mgfAlg != AsymRSAMGF::MGF1_SHA3_512)) - { - 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)) - { - ERROR_MSG("sLen (%lu) is too large for current key size (%lu)", - (unsigned long)sLen, privateKey->getBitLength()); ByteString dummy; AsymmetricAlgorithm::signFinal(dummy); return false; @@ -674,7 +530,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) { @@ -709,27 +564,8 @@ bool BotanRSA::verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, emsa = "EMSA3(SHA-3(512))"; break; case AsymMech::RSA_SHA1_PKCS_PSS: - if ((mechanismParam == NULL) || (!mechanismParam->isOfType(RSAPssMechanismParam::type))) + if (!checkPssParams(mechanismParam, HashAlgo::SHA1, AsymRSAMGF::MGF1_SHA1, 20, 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::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)) - { - ERROR_MSG("sLen (%lu) is too large for current key size (%lu)", - (unsigned long)sLen, publicKey->getBitLength()); ByteString dummy; AsymmetricAlgorithm::verifyFinal(dummy); return false; @@ -738,27 +574,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))) - { - 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)) + if (!checkPssParams(mechanismParam, HashAlgo::SHA224, AsymRSAMGF::MGF1_SHA224, 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-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; @@ -767,27 +584,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))) - { - 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)) + if (!checkPssParams(mechanismParam, HashAlgo::SHA256, AsymRSAMGF::MGF1_SHA256, 32, 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; @@ -796,27 +594,8 @@ 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 (!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)) - { - 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; @@ -825,27 +604,8 @@ bool BotanRSA::verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, emsa = request.str(); break; case AsymMech::RSA_SHA512_PKCS_PSS: - if ((mechanismParam == NULL) || (!mechanismParam->isOfType(RSAPssMechanismParam::type))) + if (!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::SHA512)|| - (pssParam->mgfAlg != AsymRSAMGF::MGF1_SHA512)) - { - 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)) - { - ERROR_MSG("sLen (%lu) is too large for current key size (%lu)", - (unsigned long)sLen, publicKey->getBitLength()); ByteString dummy; AsymmetricAlgorithm::verifyFinal(dummy); return false; @@ -854,27 +614,8 @@ bool BotanRSA::verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, emsa = request.str(); break; case AsymMech::RSA_SHA3_224_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::SHA3_224)|| - (pssParam->mgfAlg != AsymRSAMGF::MGF1_SHA3_224)) - { - 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)) + if (!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; @@ -883,27 +624,8 @@ bool BotanRSA::verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, emsa = request.str(); break; case AsymMech::RSA_SHA3_256_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::SHA3_256)|| - (pssParam->mgfAlg != AsymRSAMGF::MGF1_SHA3_256)) - { - 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)) + if (!checkPssParams(mechanismParam, HashAlgo::SHA3_256, AsymRSAMGF::MGF1_SHA3_256, 32, 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; @@ -912,27 +634,8 @@ bool BotanRSA::verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, emsa = request.str(); break; case AsymMech::RSA_SHA3_384_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::SHA3_384)|| - (pssParam->mgfAlg != AsymRSAMGF::MGF1_SHA3_384)) - { - 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)) + if (!checkPssParams(mechanismParam, HashAlgo::SHA3_384, AsymRSAMGF::MGF1_SHA3_384, 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; @@ -941,27 +644,8 @@ bool BotanRSA::verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, emsa = request.str(); break; case AsymMech::RSA_SHA3_512_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::SHA3_512)|| - (pssParam->mgfAlg != AsymRSAMGF::MGF1_SHA3_512)) - { - 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)) + if (!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; diff --git a/src/lib/crypto/BotanRSA.h b/src/lib/crypto/BotanRSA.h index 6511c6ce0..2144e1074 100644 --- a/src/lib/crypto/BotanRSA.h +++ b/src/lib/crypto/BotanRSA.h @@ -87,6 +87,7 @@ class BotanRSA : public AsymmetricAlgorithm std::string getCipherRawPss(size_t bitLength, size_t dataSize, const MechanismParam* mechanismParam); #endif std::string getCipherOaep(size_t bitLength, size_t dataSize, const MechanismParam* mechanismParam); + bool checkPssParams(const MechanismParam* mechanismParam, HashAlgo::Type hashAlg, AsymRSAMGF::Type mgfAlg, size_t digestSize, size_t keyBitLength, size_t& sLen); }; #endif // !_SOFTHSM_V2_BOTANRSA_H From f13e1b4afbefcdeb55d5e7727e472e1b46ae380b Mon Sep 17 00:00:00 2001 From: Alexandre Laroche Date: Mon, 27 Jul 2026 08:39:09 -0400 Subject: [PATCH 07/10] Factor RSA-PSS mechanism parameter checks into a dedicated method (OSSLRSA) Antoine pointed out on PR #894 that the same duplication factored out of BotanRSA in the previous commit exists in OSSLRSA's signInit and verifyInit. Applies the same checkPssParams() helper there. --- src/lib/crypto/OSSLRSA.cpp | 409 +++++-------------------------------- src/lib/crypto/OSSLRSA.h | 1 + 2 files changed, 47 insertions(+), 363 deletions(-) diff --git a/src/lib/crypto/OSSLRSA.cpp b/src/lib/crypto/OSSLRSA.cpp index 4304947c5..4859e3cb2 100644 --- a/src/lib/crypto/OSSLRSA.cpp +++ b/src/lib/crypto/OSSLRSA.cpp @@ -337,6 +337,34 @@ bool OSSLRSA::sign(PrivateKey* privateKey, const ByteString& dataToSign, } } +// 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. +bool OSSLRSA::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; +} + bool OSSLRSA::signInit(PrivateKey *privateKey, const AsymMech::Type mechanism, const MechanismParam* mechanismParam /*= NULL*/) { @@ -358,7 +386,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: @@ -392,27 +419,8 @@ bool OSSLRSA::signInit(PrivateKey *privateKey, const AsymMech::Type mechanism, hash1 = HashAlgo::SHA3_512; break; case AsymMech::RSA_SHA1_PKCS_PSS: - if ((mechanismParam == NULL) || (!mechanismParam->isOfType(RSAPssMechanismParam::type))) + if (!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; @@ -420,27 +428,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))) + if (!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; @@ -448,27 +437,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))) - { - 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)) + if (!checkPssParams(mechanismParam, HashAlgo::SHA256, AsymRSAMGF::MGF1_SHA256, 32, 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; @@ -476,27 +446,8 @@ 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 (!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)) - { - 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)) - { - ERROR_MSG("sLen (%lu) is too large for current key size (%lu)", - (unsigned long)sLen, privateKey->getBitLength()); ByteString dummy; AsymmetricAlgorithm::signFinal(dummy); return false; @@ -504,27 +455,8 @@ bool OSSLRSA::signInit(PrivateKey *privateKey, const AsymMech::Type mechanism, hash1 = HashAlgo::SHA384; break; case AsymMech::RSA_SHA512_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::SHA512)|| - (pssParam->mgfAlg != AsymRSAMGF::MGF1_SHA512)) - { - 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)) + if (!checkPssParams(mechanismParam, HashAlgo::SHA512, AsymRSAMGF::MGF1_SHA512, 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; @@ -532,27 +464,8 @@ bool OSSLRSA::signInit(PrivateKey *privateKey, const AsymMech::Type mechanism, hash1 = HashAlgo::SHA512; break; case AsymMech::RSA_SHA3_224_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::SHA3_224)|| - (pssParam->mgfAlg != AsymRSAMGF::MGF1_SHA3_224)) - { - 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)) + if (!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; @@ -560,27 +473,8 @@ bool OSSLRSA::signInit(PrivateKey *privateKey, const AsymMech::Type mechanism, hash1 = HashAlgo::SHA3_224; break; case AsymMech::RSA_SHA3_256_PKCS_PSS: - if ((mechanismParam == NULL) || (!mechanismParam->isOfType(RSAPssMechanismParam::type))) + if (!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::SHA3_256)|| - (pssParam->mgfAlg != AsymRSAMGF::MGF1_SHA3_256)) - { - 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; @@ -588,27 +482,8 @@ bool OSSLRSA::signInit(PrivateKey *privateKey, const AsymMech::Type mechanism, hash1 = HashAlgo::SHA3_256; break; case AsymMech::RSA_SHA3_384_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::SHA3_384)|| - (pssParam->mgfAlg != AsymRSAMGF::MGF1_SHA3_384)) - { - 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)) + if (!checkPssParams(mechanismParam, HashAlgo::SHA3_384, AsymRSAMGF::MGF1_SHA3_384, 48, 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; @@ -616,27 +491,8 @@ bool OSSLRSA::signInit(PrivateKey *privateKey, const AsymMech::Type mechanism, hash1 = HashAlgo::SHA3_384; break; case AsymMech::RSA_SHA3_512_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::SHA3_512)|| - (pssParam->mgfAlg != AsymRSAMGF::MGF1_SHA3_512)) + if (!checkPssParams(mechanismParam, HashAlgo::SHA3_512, AsymRSAMGF::MGF1_SHA3_512, 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 - 64)) - { - ERROR_MSG("sLen (%lu) is too large for current key size (%lu)", - (unsigned long)sLen, privateKey->getBitLength()); ByteString dummy; AsymmetricAlgorithm::signFinal(dummy); return false; @@ -1160,8 +1016,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: @@ -1195,27 +1049,8 @@ bool OSSLRSA::verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, hash1 = HashAlgo::SHA3_512; break; case AsymMech::RSA_SHA1_PKCS_PSS: - if ((mechanismParam == NULL) || (!mechanismParam->isOfType(RSAPssMechanismParam::type))) + if (!checkPssParams(mechanismParam, HashAlgo::SHA1, AsymRSAMGF::MGF1_SHA1, 20, 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::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)) - { - ERROR_MSG("sLen (%lu) is too large for current key size (%lu)", - (unsigned long)sLen, publicKey->getBitLength()); ByteString dummy; AsymmetricAlgorithm::verifyFinal(dummy); return false; @@ -1223,27 +1058,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))) - { - 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)) + if (!checkPssParams(mechanismParam, HashAlgo::SHA224, AsymRSAMGF::MGF1_SHA224, 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 - 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; @@ -1251,27 +1067,8 @@ 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)) - { - 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)) + if (!checkPssParams(mechanismParam, HashAlgo::SHA256, AsymRSAMGF::MGF1_SHA256, 32, 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; @@ -1279,55 +1076,17 @@ bool OSSLRSA::verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, hash1 = HashAlgo::SHA256; break; case AsymMech::RSA_SHA384_PKCS_PSS: - if ((mechanismParam == NULL) || (!mechanismParam->isOfType(RSAPssMechanismParam::type))) + if (!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)) - { - 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; break; case AsymMech::RSA_SHA512_PKCS_PSS: - if ((mechanismParam == NULL) || (!mechanismParam->isOfType(RSAPssMechanismParam::type))) + if (!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::SHA512)|| - (pssParam->mgfAlg != AsymRSAMGF::MGF1_SHA512)) - { - 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)) - { - ERROR_MSG("sLen (%lu) is too large for current key size (%lu)", - (unsigned long)sLen, publicKey->getBitLength()); ByteString dummy; AsymmetricAlgorithm::verifyFinal(dummy); return false; @@ -1335,27 +1094,8 @@ bool OSSLRSA::verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, hash1 = HashAlgo::SHA512; break; case AsymMech::RSA_SHA3_224_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::SHA3_224)|| - (pssParam->mgfAlg != AsymRSAMGF::MGF1_SHA3_224)) - { - 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)) + if (!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; @@ -1363,27 +1103,8 @@ bool OSSLRSA::verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, hash1 = HashAlgo::SHA3_224; break; case AsymMech::RSA_SHA3_256_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::SHA3_256)|| - (pssParam->mgfAlg != AsymRSAMGF::MGF1_SHA3_256)) - { - 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)) + if (!checkPssParams(mechanismParam, HashAlgo::SHA3_256, AsymRSAMGF::MGF1_SHA3_256, 32, 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; @@ -1391,27 +1112,8 @@ bool OSSLRSA::verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, hash1 = HashAlgo::SHA3_256; break; case AsymMech::RSA_SHA3_384_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::SHA3_384)|| - (pssParam->mgfAlg != AsymRSAMGF::MGF1_SHA3_384)) - { - 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)) + if (!checkPssParams(mechanismParam, HashAlgo::SHA3_384, AsymRSAMGF::MGF1_SHA3_384, 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; @@ -1419,27 +1121,8 @@ bool OSSLRSA::verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, hash1 = HashAlgo::SHA3_384; break; case AsymMech::RSA_SHA3_512_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::SHA3_512)|| - (pssParam->mgfAlg != AsymRSAMGF::MGF1_SHA3_512)) - { - 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)) + if (!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; diff --git a/src/lib/crypto/OSSLRSA.h b/src/lib/crypto/OSSLRSA.h index d087d0e4c..5471039b1 100644 --- a/src/lib/crypto/OSSLRSA.h +++ b/src/lib/crypto/OSSLRSA.h @@ -83,6 +83,7 @@ class OSSLRSA : public AsymmetricAlgorithm HashAlgorithm* pCurrentHash; HashAlgorithm* pSecondHash; size_t sLen; + bool checkPssParams(const MechanismParam* mechanismParam, HashAlgo::Type hashAlg, AsymRSAMGF::Type mgfAlg, size_t digestSize, size_t keyBitLength, size_t& sLen); }; #endif // !_SOFTHSM_V2_OSSLRSA_H From 25639832d97d7f4720d0982c7d50ff47a4d2e7fc Mon Sep 17 00:00:00 2001 From: Alexandre Laroche Date: Mon, 27 Jul 2026 16:48:33 -0400 Subject: [PATCH 08/10] Move RSA-PSS parameter check into a shared RSAUtil class Antoine noted on PR #894 that BotanRSA::checkPssParams and OSSLRSA::checkPssParams were identical, and suggested factoring it into a dedicated utility class the way MLDSAUtil/MLKEMUtil already do for their algorithms. Adds RSAUtil::checkPssParams and has both backends call it instead of keeping their own copy. --- src/lib/crypto/BotanRSA.cpp | 65 ++++++++++------------------------- src/lib/crypto/BotanRSA.h | 1 - src/lib/crypto/CMakeLists.txt | 1 + src/lib/crypto/Makefile.am | 1 + src/lib/crypto/OSSLRSA.cpp | 65 ++++++++++------------------------- src/lib/crypto/OSSLRSA.h | 1 - src/lib/crypto/RSAUtil.cpp | 40 +++++++++++++++++++++ src/lib/crypto/RSAUtil.h | 31 +++++++++++++++++ 8 files changed, 111 insertions(+), 94 deletions(-) create mode 100644 src/lib/crypto/RSAUtil.cpp create mode 100644 src/lib/crypto/RSAUtil.h diff --git a/src/lib/crypto/BotanRSA.cpp b/src/lib/crypto/BotanRSA.cpp index 2d9214f07..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 @@ -144,34 +145,6 @@ bool BotanRSA::sign(PrivateKey* privateKey, const ByteString& dataToSign, return true; } -// 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. -bool BotanRSA::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; -} - bool BotanRSA::signInit(PrivateKey* privateKey, const AsymMech::Type mechanism, const MechanismParam* mechanismParam /*= NULL */) { @@ -228,7 +201,7 @@ bool BotanRSA::signInit(PrivateKey* privateKey, const AsymMech::Type mechanism, emsa = "EMSA3(SHA-3(512))"; break; case AsymMech::RSA_SHA1_PKCS_PSS: - if (!checkPssParams(mechanismParam, HashAlgo::SHA1, AsymRSAMGF::MGF1_SHA1, 20, privateKey->getBitLength(), sLen)) + if (!RSAUtil::checkPssParams(mechanismParam, HashAlgo::SHA1, AsymRSAMGF::MGF1_SHA1, 20, privateKey->getBitLength(), sLen)) { ByteString dummy; AsymmetricAlgorithm::signFinal(dummy); @@ -238,7 +211,7 @@ bool BotanRSA::signInit(PrivateKey* privateKey, const AsymMech::Type mechanism, emsa = request.str(); break; case AsymMech::RSA_SHA224_PKCS_PSS: - if (!checkPssParams(mechanismParam, HashAlgo::SHA224, AsymRSAMGF::MGF1_SHA224, 28, privateKey->getBitLength(), sLen)) + if (!RSAUtil::checkPssParams(mechanismParam, HashAlgo::SHA224, AsymRSAMGF::MGF1_SHA224, 28, privateKey->getBitLength(), sLen)) { ByteString dummy; AsymmetricAlgorithm::signFinal(dummy); @@ -248,7 +221,7 @@ bool BotanRSA::signInit(PrivateKey* privateKey, const AsymMech::Type mechanism, emsa = request.str(); break; case AsymMech::RSA_SHA256_PKCS_PSS: - if (!checkPssParams(mechanismParam, HashAlgo::SHA256, AsymRSAMGF::MGF1_SHA256, 32, privateKey->getBitLength(), sLen)) + if (!RSAUtil::checkPssParams(mechanismParam, HashAlgo::SHA256, AsymRSAMGF::MGF1_SHA256, 32, privateKey->getBitLength(), sLen)) { ByteString dummy; AsymmetricAlgorithm::signFinal(dummy); @@ -258,7 +231,7 @@ bool BotanRSA::signInit(PrivateKey* privateKey, const AsymMech::Type mechanism, emsa = request.str(); break; case AsymMech::RSA_SHA384_PKCS_PSS: - if (!checkPssParams(mechanismParam, HashAlgo::SHA384, AsymRSAMGF::MGF1_SHA384, 48, privateKey->getBitLength(), sLen)) + if (!RSAUtil::checkPssParams(mechanismParam, HashAlgo::SHA384, AsymRSAMGF::MGF1_SHA384, 48, privateKey->getBitLength(), sLen)) { ByteString dummy; AsymmetricAlgorithm::signFinal(dummy); @@ -268,7 +241,7 @@ bool BotanRSA::signInit(PrivateKey* privateKey, const AsymMech::Type mechanism, emsa = request.str(); break; case AsymMech::RSA_SHA512_PKCS_PSS: - if (!checkPssParams(mechanismParam, HashAlgo::SHA512, AsymRSAMGF::MGF1_SHA512, 64, privateKey->getBitLength(), sLen)) + if (!RSAUtil::checkPssParams(mechanismParam, HashAlgo::SHA512, AsymRSAMGF::MGF1_SHA512, 64, privateKey->getBitLength(), sLen)) { ByteString dummy; AsymmetricAlgorithm::signFinal(dummy); @@ -278,7 +251,7 @@ bool BotanRSA::signInit(PrivateKey* privateKey, const AsymMech::Type mechanism, emsa = request.str(); break; case AsymMech::RSA_SHA3_224_PKCS_PSS: - if (!checkPssParams(mechanismParam, HashAlgo::SHA3_224, AsymRSAMGF::MGF1_SHA3_224, 28, privateKey->getBitLength(), sLen)) + if (!RSAUtil::checkPssParams(mechanismParam, HashAlgo::SHA3_224, AsymRSAMGF::MGF1_SHA3_224, 28, privateKey->getBitLength(), sLen)) { ByteString dummy; AsymmetricAlgorithm::signFinal(dummy); @@ -288,7 +261,7 @@ bool BotanRSA::signInit(PrivateKey* privateKey, const AsymMech::Type mechanism, emsa = request.str(); break; case AsymMech::RSA_SHA3_256_PKCS_PSS: - if (!checkPssParams(mechanismParam, HashAlgo::SHA3_256, AsymRSAMGF::MGF1_SHA3_256, 32, privateKey->getBitLength(), sLen)) + if (!RSAUtil::checkPssParams(mechanismParam, HashAlgo::SHA3_256, AsymRSAMGF::MGF1_SHA3_256, 32, privateKey->getBitLength(), sLen)) { ByteString dummy; AsymmetricAlgorithm::signFinal(dummy); @@ -298,7 +271,7 @@ bool BotanRSA::signInit(PrivateKey* privateKey, const AsymMech::Type mechanism, emsa = request.str(); break; case AsymMech::RSA_SHA3_384_PKCS_PSS: - if (!checkPssParams(mechanismParam, HashAlgo::SHA3_384, AsymRSAMGF::MGF1_SHA3_384, 48, privateKey->getBitLength(), sLen)) + if (!RSAUtil::checkPssParams(mechanismParam, HashAlgo::SHA3_384, AsymRSAMGF::MGF1_SHA3_384, 48, privateKey->getBitLength(), sLen)) { ByteString dummy; AsymmetricAlgorithm::signFinal(dummy); @@ -308,7 +281,7 @@ bool BotanRSA::signInit(PrivateKey* privateKey, const AsymMech::Type mechanism, emsa = request.str(); break; case AsymMech::RSA_SHA3_512_PKCS_PSS: - if (!checkPssParams(mechanismParam, HashAlgo::SHA3_512, AsymRSAMGF::MGF1_SHA3_512, 64, privateKey->getBitLength(), sLen)) + if (!RSAUtil::checkPssParams(mechanismParam, HashAlgo::SHA3_512, AsymRSAMGF::MGF1_SHA3_512, 64, privateKey->getBitLength(), sLen)) { ByteString dummy; AsymmetricAlgorithm::signFinal(dummy); @@ -564,7 +537,7 @@ bool BotanRSA::verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, emsa = "EMSA3(SHA-3(512))"; break; case AsymMech::RSA_SHA1_PKCS_PSS: - if (!checkPssParams(mechanismParam, HashAlgo::SHA1, AsymRSAMGF::MGF1_SHA1, 20, publicKey->getBitLength(), sLen)) + if (!RSAUtil::checkPssParams(mechanismParam, HashAlgo::SHA1, AsymRSAMGF::MGF1_SHA1, 20, publicKey->getBitLength(), sLen)) { ByteString dummy; AsymmetricAlgorithm::verifyFinal(dummy); @@ -574,7 +547,7 @@ bool BotanRSA::verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, emsa = request.str(); break; case AsymMech::RSA_SHA224_PKCS_PSS: - if (!checkPssParams(mechanismParam, HashAlgo::SHA224, AsymRSAMGF::MGF1_SHA224, 28, publicKey->getBitLength(), sLen)) + if (!RSAUtil::checkPssParams(mechanismParam, HashAlgo::SHA224, AsymRSAMGF::MGF1_SHA224, 28, publicKey->getBitLength(), sLen)) { ByteString dummy; AsymmetricAlgorithm::verifyFinal(dummy); @@ -584,7 +557,7 @@ bool BotanRSA::verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, emsa = request.str(); break; case AsymMech::RSA_SHA256_PKCS_PSS: - if (!checkPssParams(mechanismParam, HashAlgo::SHA256, AsymRSAMGF::MGF1_SHA256, 32, publicKey->getBitLength(), sLen)) + if (!RSAUtil::checkPssParams(mechanismParam, HashAlgo::SHA256, AsymRSAMGF::MGF1_SHA256, 32, publicKey->getBitLength(), sLen)) { ByteString dummy; AsymmetricAlgorithm::verifyFinal(dummy); @@ -594,7 +567,7 @@ bool BotanRSA::verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, emsa = request.str(); break; case AsymMech::RSA_SHA384_PKCS_PSS: - if (!checkPssParams(mechanismParam, HashAlgo::SHA384, AsymRSAMGF::MGF1_SHA384, 48, publicKey->getBitLength(), sLen)) + if (!RSAUtil::checkPssParams(mechanismParam, HashAlgo::SHA384, AsymRSAMGF::MGF1_SHA384, 48, publicKey->getBitLength(), sLen)) { ByteString dummy; AsymmetricAlgorithm::verifyFinal(dummy); @@ -604,7 +577,7 @@ bool BotanRSA::verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, emsa = request.str(); break; case AsymMech::RSA_SHA512_PKCS_PSS: - if (!checkPssParams(mechanismParam, HashAlgo::SHA512, AsymRSAMGF::MGF1_SHA512, 64, publicKey->getBitLength(), sLen)) + if (!RSAUtil::checkPssParams(mechanismParam, HashAlgo::SHA512, AsymRSAMGF::MGF1_SHA512, 64, publicKey->getBitLength(), sLen)) { ByteString dummy; AsymmetricAlgorithm::verifyFinal(dummy); @@ -614,7 +587,7 @@ bool BotanRSA::verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, emsa = request.str(); break; case AsymMech::RSA_SHA3_224_PKCS_PSS: - if (!checkPssParams(mechanismParam, HashAlgo::SHA3_224, AsymRSAMGF::MGF1_SHA3_224, 28, publicKey->getBitLength(), sLen)) + if (!RSAUtil::checkPssParams(mechanismParam, HashAlgo::SHA3_224, AsymRSAMGF::MGF1_SHA3_224, 28, publicKey->getBitLength(), sLen)) { ByteString dummy; AsymmetricAlgorithm::verifyFinal(dummy); @@ -624,7 +597,7 @@ bool BotanRSA::verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, emsa = request.str(); break; case AsymMech::RSA_SHA3_256_PKCS_PSS: - if (!checkPssParams(mechanismParam, HashAlgo::SHA3_256, AsymRSAMGF::MGF1_SHA3_256, 32, publicKey->getBitLength(), sLen)) + if (!RSAUtil::checkPssParams(mechanismParam, HashAlgo::SHA3_256, AsymRSAMGF::MGF1_SHA3_256, 32, publicKey->getBitLength(), sLen)) { ByteString dummy; AsymmetricAlgorithm::verifyFinal(dummy); @@ -634,7 +607,7 @@ bool BotanRSA::verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, emsa = request.str(); break; case AsymMech::RSA_SHA3_384_PKCS_PSS: - if (!checkPssParams(mechanismParam, HashAlgo::SHA3_384, AsymRSAMGF::MGF1_SHA3_384, 48, publicKey->getBitLength(), sLen)) + if (!RSAUtil::checkPssParams(mechanismParam, HashAlgo::SHA3_384, AsymRSAMGF::MGF1_SHA3_384, 48, publicKey->getBitLength(), sLen)) { ByteString dummy; AsymmetricAlgorithm::verifyFinal(dummy); @@ -644,7 +617,7 @@ bool BotanRSA::verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, emsa = request.str(); break; case AsymMech::RSA_SHA3_512_PKCS_PSS: - if (!checkPssParams(mechanismParam, HashAlgo::SHA3_512, AsymRSAMGF::MGF1_SHA3_512, 64, publicKey->getBitLength(), sLen)) + if (!RSAUtil::checkPssParams(mechanismParam, HashAlgo::SHA3_512, AsymRSAMGF::MGF1_SHA3_512, 64, publicKey->getBitLength(), sLen)) { ByteString dummy; AsymmetricAlgorithm::verifyFinal(dummy); diff --git a/src/lib/crypto/BotanRSA.h b/src/lib/crypto/BotanRSA.h index 2144e1074..6511c6ce0 100644 --- a/src/lib/crypto/BotanRSA.h +++ b/src/lib/crypto/BotanRSA.h @@ -87,7 +87,6 @@ class BotanRSA : public AsymmetricAlgorithm std::string getCipherRawPss(size_t bitLength, size_t dataSize, const MechanismParam* mechanismParam); #endif std::string getCipherOaep(size_t bitLength, size_t dataSize, const MechanismParam* mechanismParam); - bool checkPssParams(const MechanismParam* mechanismParam, HashAlgo::Type hashAlg, AsymRSAMGF::Type mgfAlg, size_t digestSize, size_t keyBitLength, size_t& sLen); }; #endif // !_SOFTHSM_V2_BOTANRSA_H diff --git a/src/lib/crypto/CMakeLists.txt b/src/lib/crypto/CMakeLists.txt index 5e61bae0a..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 ) diff --git a/src/lib/crypto/Makefile.am b/src/lib/crypto/Makefile.am index bceb1e44e..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@ diff --git a/src/lib/crypto/OSSLRSA.cpp b/src/lib/crypto/OSSLRSA.cpp index 4859e3cb2..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 @@ -337,34 +338,6 @@ bool OSSLRSA::sign(PrivateKey* privateKey, const ByteString& dataToSign, } } -// 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. -bool OSSLRSA::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; -} - bool OSSLRSA::signInit(PrivateKey *privateKey, const AsymMech::Type mechanism, const MechanismParam* mechanismParam /*= NULL*/) { @@ -419,7 +392,7 @@ bool OSSLRSA::signInit(PrivateKey *privateKey, const AsymMech::Type mechanism, hash1 = HashAlgo::SHA3_512; break; case AsymMech::RSA_SHA1_PKCS_PSS: - if (!checkPssParams(mechanismParam, HashAlgo::SHA1, AsymRSAMGF::MGF1_SHA1, 20, privateKey->getBitLength(), sLen)) + if (!RSAUtil::checkPssParams(mechanismParam, HashAlgo::SHA1, AsymRSAMGF::MGF1_SHA1, 20, privateKey->getBitLength(), sLen)) { ByteString dummy; AsymmetricAlgorithm::signFinal(dummy); @@ -428,7 +401,7 @@ bool OSSLRSA::signInit(PrivateKey *privateKey, const AsymMech::Type mechanism, hash1 = HashAlgo::SHA1; break; case AsymMech::RSA_SHA224_PKCS_PSS: - if (!checkPssParams(mechanismParam, HashAlgo::SHA224, AsymRSAMGF::MGF1_SHA224, 28, privateKey->getBitLength(), sLen)) + if (!RSAUtil::checkPssParams(mechanismParam, HashAlgo::SHA224, AsymRSAMGF::MGF1_SHA224, 28, privateKey->getBitLength(), sLen)) { ByteString dummy; AsymmetricAlgorithm::signFinal(dummy); @@ -437,7 +410,7 @@ bool OSSLRSA::signInit(PrivateKey *privateKey, const AsymMech::Type mechanism, hash1 = HashAlgo::SHA224; break; case AsymMech::RSA_SHA256_PKCS_PSS: - if (!checkPssParams(mechanismParam, HashAlgo::SHA256, AsymRSAMGF::MGF1_SHA256, 32, privateKey->getBitLength(), sLen)) + if (!RSAUtil::checkPssParams(mechanismParam, HashAlgo::SHA256, AsymRSAMGF::MGF1_SHA256, 32, privateKey->getBitLength(), sLen)) { ByteString dummy; AsymmetricAlgorithm::signFinal(dummy); @@ -446,7 +419,7 @@ bool OSSLRSA::signInit(PrivateKey *privateKey, const AsymMech::Type mechanism, hash1 = HashAlgo::SHA256; break; case AsymMech::RSA_SHA384_PKCS_PSS: - if (!checkPssParams(mechanismParam, HashAlgo::SHA384, AsymRSAMGF::MGF1_SHA384, 48, privateKey->getBitLength(), sLen)) + if (!RSAUtil::checkPssParams(mechanismParam, HashAlgo::SHA384, AsymRSAMGF::MGF1_SHA384, 48, privateKey->getBitLength(), sLen)) { ByteString dummy; AsymmetricAlgorithm::signFinal(dummy); @@ -455,7 +428,7 @@ bool OSSLRSA::signInit(PrivateKey *privateKey, const AsymMech::Type mechanism, hash1 = HashAlgo::SHA384; break; case AsymMech::RSA_SHA512_PKCS_PSS: - if (!checkPssParams(mechanismParam, HashAlgo::SHA512, AsymRSAMGF::MGF1_SHA512, 64, privateKey->getBitLength(), sLen)) + if (!RSAUtil::checkPssParams(mechanismParam, HashAlgo::SHA512, AsymRSAMGF::MGF1_SHA512, 64, privateKey->getBitLength(), sLen)) { ByteString dummy; AsymmetricAlgorithm::signFinal(dummy); @@ -464,7 +437,7 @@ bool OSSLRSA::signInit(PrivateKey *privateKey, const AsymMech::Type mechanism, hash1 = HashAlgo::SHA512; break; case AsymMech::RSA_SHA3_224_PKCS_PSS: - if (!checkPssParams(mechanismParam, HashAlgo::SHA3_224, AsymRSAMGF::MGF1_SHA3_224, 28, privateKey->getBitLength(), sLen)) + if (!RSAUtil::checkPssParams(mechanismParam, HashAlgo::SHA3_224, AsymRSAMGF::MGF1_SHA3_224, 28, privateKey->getBitLength(), sLen)) { ByteString dummy; AsymmetricAlgorithm::signFinal(dummy); @@ -473,7 +446,7 @@ bool OSSLRSA::signInit(PrivateKey *privateKey, const AsymMech::Type mechanism, hash1 = HashAlgo::SHA3_224; break; case AsymMech::RSA_SHA3_256_PKCS_PSS: - if (!checkPssParams(mechanismParam, HashAlgo::SHA3_256, AsymRSAMGF::MGF1_SHA3_256, 32, privateKey->getBitLength(), sLen)) + if (!RSAUtil::checkPssParams(mechanismParam, HashAlgo::SHA3_256, AsymRSAMGF::MGF1_SHA3_256, 32, privateKey->getBitLength(), sLen)) { ByteString dummy; AsymmetricAlgorithm::signFinal(dummy); @@ -482,7 +455,7 @@ bool OSSLRSA::signInit(PrivateKey *privateKey, const AsymMech::Type mechanism, hash1 = HashAlgo::SHA3_256; break; case AsymMech::RSA_SHA3_384_PKCS_PSS: - if (!checkPssParams(mechanismParam, HashAlgo::SHA3_384, AsymRSAMGF::MGF1_SHA3_384, 48, privateKey->getBitLength(), sLen)) + if (!RSAUtil::checkPssParams(mechanismParam, HashAlgo::SHA3_384, AsymRSAMGF::MGF1_SHA3_384, 48, privateKey->getBitLength(), sLen)) { ByteString dummy; AsymmetricAlgorithm::signFinal(dummy); @@ -491,7 +464,7 @@ bool OSSLRSA::signInit(PrivateKey *privateKey, const AsymMech::Type mechanism, hash1 = HashAlgo::SHA3_384; break; case AsymMech::RSA_SHA3_512_PKCS_PSS: - if (!checkPssParams(mechanismParam, HashAlgo::SHA3_512, AsymRSAMGF::MGF1_SHA3_512, 64, privateKey->getBitLength(), sLen)) + if (!RSAUtil::checkPssParams(mechanismParam, HashAlgo::SHA3_512, AsymRSAMGF::MGF1_SHA3_512, 64, privateKey->getBitLength(), sLen)) { ByteString dummy; AsymmetricAlgorithm::signFinal(dummy); @@ -1049,7 +1022,7 @@ bool OSSLRSA::verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, hash1 = HashAlgo::SHA3_512; break; case AsymMech::RSA_SHA1_PKCS_PSS: - if (!checkPssParams(mechanismParam, HashAlgo::SHA1, AsymRSAMGF::MGF1_SHA1, 20, publicKey->getBitLength(), sLen)) + if (!RSAUtil::checkPssParams(mechanismParam, HashAlgo::SHA1, AsymRSAMGF::MGF1_SHA1, 20, publicKey->getBitLength(), sLen)) { ByteString dummy; AsymmetricAlgorithm::verifyFinal(dummy); @@ -1058,7 +1031,7 @@ bool OSSLRSA::verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, hash1 = HashAlgo::SHA1; break; case AsymMech::RSA_SHA224_PKCS_PSS: - if (!checkPssParams(mechanismParam, HashAlgo::SHA224, AsymRSAMGF::MGF1_SHA224, 28, publicKey->getBitLength(), sLen)) + if (!RSAUtil::checkPssParams(mechanismParam, HashAlgo::SHA224, AsymRSAMGF::MGF1_SHA224, 28, publicKey->getBitLength(), sLen)) { ByteString dummy; AsymmetricAlgorithm::verifyFinal(dummy); @@ -1067,7 +1040,7 @@ bool OSSLRSA::verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, hash1 = HashAlgo::SHA224; break; case AsymMech::RSA_SHA256_PKCS_PSS: - if (!checkPssParams(mechanismParam, HashAlgo::SHA256, AsymRSAMGF::MGF1_SHA256, 32, publicKey->getBitLength(), sLen)) + if (!RSAUtil::checkPssParams(mechanismParam, HashAlgo::SHA256, AsymRSAMGF::MGF1_SHA256, 32, publicKey->getBitLength(), sLen)) { ByteString dummy; AsymmetricAlgorithm::verifyFinal(dummy); @@ -1076,7 +1049,7 @@ bool OSSLRSA::verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, hash1 = HashAlgo::SHA256; break; case AsymMech::RSA_SHA384_PKCS_PSS: - if (!checkPssParams(mechanismParam, HashAlgo::SHA384, AsymRSAMGF::MGF1_SHA384, 48, publicKey->getBitLength(), sLen)) + if (!RSAUtil::checkPssParams(mechanismParam, HashAlgo::SHA384, AsymRSAMGF::MGF1_SHA384, 48, publicKey->getBitLength(), sLen)) { ByteString dummy; AsymmetricAlgorithm::verifyFinal(dummy); @@ -1085,7 +1058,7 @@ bool OSSLRSA::verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, hash1 = HashAlgo::SHA384; break; case AsymMech::RSA_SHA512_PKCS_PSS: - if (!checkPssParams(mechanismParam, HashAlgo::SHA512, AsymRSAMGF::MGF1_SHA512, 64, publicKey->getBitLength(), sLen)) + if (!RSAUtil::checkPssParams(mechanismParam, HashAlgo::SHA512, AsymRSAMGF::MGF1_SHA512, 64, publicKey->getBitLength(), sLen)) { ByteString dummy; AsymmetricAlgorithm::verifyFinal(dummy); @@ -1094,7 +1067,7 @@ bool OSSLRSA::verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, hash1 = HashAlgo::SHA512; break; case AsymMech::RSA_SHA3_224_PKCS_PSS: - if (!checkPssParams(mechanismParam, HashAlgo::SHA3_224, AsymRSAMGF::MGF1_SHA3_224, 28, publicKey->getBitLength(), sLen)) + if (!RSAUtil::checkPssParams(mechanismParam, HashAlgo::SHA3_224, AsymRSAMGF::MGF1_SHA3_224, 28, publicKey->getBitLength(), sLen)) { ByteString dummy; AsymmetricAlgorithm::verifyFinal(dummy); @@ -1103,7 +1076,7 @@ bool OSSLRSA::verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, hash1 = HashAlgo::SHA3_224; break; case AsymMech::RSA_SHA3_256_PKCS_PSS: - if (!checkPssParams(mechanismParam, HashAlgo::SHA3_256, AsymRSAMGF::MGF1_SHA3_256, 32, publicKey->getBitLength(), sLen)) + if (!RSAUtil::checkPssParams(mechanismParam, HashAlgo::SHA3_256, AsymRSAMGF::MGF1_SHA3_256, 32, publicKey->getBitLength(), sLen)) { ByteString dummy; AsymmetricAlgorithm::verifyFinal(dummy); @@ -1112,7 +1085,7 @@ bool OSSLRSA::verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, hash1 = HashAlgo::SHA3_256; break; case AsymMech::RSA_SHA3_384_PKCS_PSS: - if (!checkPssParams(mechanismParam, HashAlgo::SHA3_384, AsymRSAMGF::MGF1_SHA3_384, 48, publicKey->getBitLength(), sLen)) + if (!RSAUtil::checkPssParams(mechanismParam, HashAlgo::SHA3_384, AsymRSAMGF::MGF1_SHA3_384, 48, publicKey->getBitLength(), sLen)) { ByteString dummy; AsymmetricAlgorithm::verifyFinal(dummy); @@ -1121,7 +1094,7 @@ bool OSSLRSA::verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, hash1 = HashAlgo::SHA3_384; break; case AsymMech::RSA_SHA3_512_PKCS_PSS: - if (!checkPssParams(mechanismParam, HashAlgo::SHA3_512, AsymRSAMGF::MGF1_SHA3_512, 64, publicKey->getBitLength(), sLen)) + if (!RSAUtil::checkPssParams(mechanismParam, HashAlgo::SHA3_512, AsymRSAMGF::MGF1_SHA3_512, 64, publicKey->getBitLength(), sLen)) { ByteString dummy; AsymmetricAlgorithm::verifyFinal(dummy); diff --git a/src/lib/crypto/OSSLRSA.h b/src/lib/crypto/OSSLRSA.h index 5471039b1..d087d0e4c 100644 --- a/src/lib/crypto/OSSLRSA.h +++ b/src/lib/crypto/OSSLRSA.h @@ -83,7 +83,6 @@ class OSSLRSA : public AsymmetricAlgorithm HashAlgorithm* pCurrentHash; HashAlgorithm* pSecondHash; size_t sLen; - bool checkPssParams(const MechanismParam* mechanismParam, HashAlgo::Type hashAlg, AsymRSAMGF::Type mgfAlg, size_t digestSize, size_t keyBitLength, size_t& sLen); }; #endif // !_SOFTHSM_V2_OSSLRSA_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 From accc4d752bc60d59705b12077d6119b4cf8cb1ab Mon Sep 17 00:00:00 2001 From: Alexandre Laroche Date: Mon, 27 Jul 2026 22:11:39 -0400 Subject: [PATCH 09/10] Use short SPDX copyright header for new SHA3 files bukka pointed out on PR #894 that new files should use the short "Copyright (c) 2026 SoftHSMv2 contributors / SPDX-License-Identifier: BSD-2-Clause" header (as used by RSAUtil.h etc.) instead of the long boilerplate BSD license text copied from the file each was based on. --- src/lib/crypto/BotanSHA3_224.cpp | 24 ++---------------------- src/lib/crypto/BotanSHA3_224.h | 24 ++---------------------- src/lib/crypto/BotanSHA3_256.cpp | 24 ++---------------------- src/lib/crypto/BotanSHA3_256.h | 24 ++---------------------- src/lib/crypto/BotanSHA3_384.cpp | 24 ++---------------------- src/lib/crypto/BotanSHA3_384.h | 24 ++---------------------- src/lib/crypto/BotanSHA3_512.cpp | 24 ++---------------------- src/lib/crypto/BotanSHA3_512.h | 24 ++---------------------- src/lib/crypto/OSSLSHA3_224.cpp | 24 ++---------------------- src/lib/crypto/OSSLSHA3_224.h | 24 ++---------------------- src/lib/crypto/OSSLSHA3_256.cpp | 24 ++---------------------- src/lib/crypto/OSSLSHA3_256.h | 24 ++---------------------- src/lib/crypto/OSSLSHA3_384.cpp | 24 ++---------------------- src/lib/crypto/OSSLSHA3_384.h | 24 ++---------------------- src/lib/crypto/OSSLSHA3_512.cpp | 24 ++---------------------- src/lib/crypto/OSSLSHA3_512.h | 24 ++---------------------- 16 files changed, 32 insertions(+), 352 deletions(-) diff --git a/src/lib/crypto/BotanSHA3_224.cpp b/src/lib/crypto/BotanSHA3_224.cpp index 86f87af09..73de7dd12 100644 --- a/src/lib/crypto/BotanSHA3_224.cpp +++ b/src/lib/crypto/BotanSHA3_224.cpp @@ -1,27 +1,7 @@ /* - * Copyright (c) 2010 .SE (The Internet Infrastructure Foundation) - * All rights reserved. + * Copyright (c) 2026 SoftHSMv2 contributors * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR - * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED - * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY - * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE - * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER - * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR - * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN - * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * SPDX-License-Identifier: BSD-2-Clause */ /***************************************************************************** diff --git a/src/lib/crypto/BotanSHA3_224.h b/src/lib/crypto/BotanSHA3_224.h index b0157d442..8847549c3 100644 --- a/src/lib/crypto/BotanSHA3_224.h +++ b/src/lib/crypto/BotanSHA3_224.h @@ -1,27 +1,7 @@ /* - * Copyright (c) 2010 .SE (The Internet Infrastructure Foundation) - * All rights reserved. + * Copyright (c) 2026 SoftHSMv2 contributors * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR - * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED - * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY - * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE - * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER - * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR - * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN - * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * SPDX-License-Identifier: BSD-2-Clause */ /***************************************************************************** diff --git a/src/lib/crypto/BotanSHA3_256.cpp b/src/lib/crypto/BotanSHA3_256.cpp index 086705847..7b247d815 100644 --- a/src/lib/crypto/BotanSHA3_256.cpp +++ b/src/lib/crypto/BotanSHA3_256.cpp @@ -1,27 +1,7 @@ /* - * Copyright (c) 2010 .SE (The Internet Infrastructure Foundation) - * All rights reserved. + * Copyright (c) 2026 SoftHSMv2 contributors * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR - * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED - * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY - * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE - * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER - * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR - * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN - * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * SPDX-License-Identifier: BSD-2-Clause */ /***************************************************************************** diff --git a/src/lib/crypto/BotanSHA3_256.h b/src/lib/crypto/BotanSHA3_256.h index 9faac7659..d49dfd454 100644 --- a/src/lib/crypto/BotanSHA3_256.h +++ b/src/lib/crypto/BotanSHA3_256.h @@ -1,27 +1,7 @@ /* - * Copyright (c) 2010 .SE (The Internet Infrastructure Foundation) - * All rights reserved. + * Copyright (c) 2026 SoftHSMv2 contributors * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR - * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED - * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY - * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE - * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER - * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR - * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN - * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * SPDX-License-Identifier: BSD-2-Clause */ /***************************************************************************** diff --git a/src/lib/crypto/BotanSHA3_384.cpp b/src/lib/crypto/BotanSHA3_384.cpp index 7bb248fa0..12d3abb6a 100644 --- a/src/lib/crypto/BotanSHA3_384.cpp +++ b/src/lib/crypto/BotanSHA3_384.cpp @@ -1,27 +1,7 @@ /* - * Copyright (c) 2010 .SE (The Internet Infrastructure Foundation) - * All rights reserved. + * Copyright (c) 2026 SoftHSMv2 contributors * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR - * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED - * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY - * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE - * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER - * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR - * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN - * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * SPDX-License-Identifier: BSD-2-Clause */ /***************************************************************************** diff --git a/src/lib/crypto/BotanSHA3_384.h b/src/lib/crypto/BotanSHA3_384.h index 7299f2350..dbe8462e8 100644 --- a/src/lib/crypto/BotanSHA3_384.h +++ b/src/lib/crypto/BotanSHA3_384.h @@ -1,27 +1,7 @@ /* - * Copyright (c) 2010 .SE (The Internet Infrastructure Foundation) - * All rights reserved. + * Copyright (c) 2026 SoftHSMv2 contributors * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR - * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED - * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY - * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE - * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER - * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR - * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN - * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * SPDX-License-Identifier: BSD-2-Clause */ /***************************************************************************** diff --git a/src/lib/crypto/BotanSHA3_512.cpp b/src/lib/crypto/BotanSHA3_512.cpp index a85a07cc9..8e73eafdd 100644 --- a/src/lib/crypto/BotanSHA3_512.cpp +++ b/src/lib/crypto/BotanSHA3_512.cpp @@ -1,27 +1,7 @@ /* - * Copyright (c) 2010 .SE (The Internet Infrastructure Foundation) - * All rights reserved. + * Copyright (c) 2026 SoftHSMv2 contributors * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR - * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED - * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY - * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE - * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER - * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR - * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN - * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * SPDX-License-Identifier: BSD-2-Clause */ /***************************************************************************** diff --git a/src/lib/crypto/BotanSHA3_512.h b/src/lib/crypto/BotanSHA3_512.h index 3c155951f..053a47e3d 100644 --- a/src/lib/crypto/BotanSHA3_512.h +++ b/src/lib/crypto/BotanSHA3_512.h @@ -1,27 +1,7 @@ /* - * Copyright (c) 2010 .SE (The Internet Infrastructure Foundation) - * All rights reserved. + * Copyright (c) 2026 SoftHSMv2 contributors * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR - * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED - * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY - * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE - * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER - * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR - * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN - * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * SPDX-License-Identifier: BSD-2-Clause */ /***************************************************************************** diff --git a/src/lib/crypto/OSSLSHA3_224.cpp b/src/lib/crypto/OSSLSHA3_224.cpp index 7894e1cb6..5c4bb2742 100644 --- a/src/lib/crypto/OSSLSHA3_224.cpp +++ b/src/lib/crypto/OSSLSHA3_224.cpp @@ -1,27 +1,7 @@ /* - * Copyright (c) 2010 SURFnet bv - * All rights reserved. + * Copyright (c) 2026 SoftHSMv2 contributors * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR - * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED - * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY - * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE - * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER - * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR - * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN - * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * SPDX-License-Identifier: BSD-2-Clause */ /***************************************************************************** diff --git a/src/lib/crypto/OSSLSHA3_224.h b/src/lib/crypto/OSSLSHA3_224.h index 5fbc35a91..0c9859dca 100644 --- a/src/lib/crypto/OSSLSHA3_224.h +++ b/src/lib/crypto/OSSLSHA3_224.h @@ -1,27 +1,7 @@ /* - * Copyright (c) 2010 SURFnet bv - * All rights reserved. + * Copyright (c) 2026 SoftHSMv2 contributors * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR - * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED - * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY - * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE - * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER - * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR - * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN - * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * SPDX-License-Identifier: BSD-2-Clause */ /***************************************************************************** diff --git a/src/lib/crypto/OSSLSHA3_256.cpp b/src/lib/crypto/OSSLSHA3_256.cpp index 273313bac..cc8cae1e0 100644 --- a/src/lib/crypto/OSSLSHA3_256.cpp +++ b/src/lib/crypto/OSSLSHA3_256.cpp @@ -1,27 +1,7 @@ /* - * Copyright (c) 2010 SURFnet bv - * All rights reserved. + * Copyright (c) 2026 SoftHSMv2 contributors * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR - * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED - * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY - * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE - * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER - * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR - * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN - * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * SPDX-License-Identifier: BSD-2-Clause */ /***************************************************************************** diff --git a/src/lib/crypto/OSSLSHA3_256.h b/src/lib/crypto/OSSLSHA3_256.h index cbe9911fd..683e52d92 100644 --- a/src/lib/crypto/OSSLSHA3_256.h +++ b/src/lib/crypto/OSSLSHA3_256.h @@ -1,27 +1,7 @@ /* - * Copyright (c) 2010 SURFnet bv - * All rights reserved. + * Copyright (c) 2026 SoftHSMv2 contributors * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR - * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED - * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY - * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE - * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER - * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR - * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN - * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * SPDX-License-Identifier: BSD-2-Clause */ /***************************************************************************** diff --git a/src/lib/crypto/OSSLSHA3_384.cpp b/src/lib/crypto/OSSLSHA3_384.cpp index f134ad567..3746aac77 100644 --- a/src/lib/crypto/OSSLSHA3_384.cpp +++ b/src/lib/crypto/OSSLSHA3_384.cpp @@ -1,27 +1,7 @@ /* - * Copyright (c) 2010 SURFnet bv - * All rights reserved. + * Copyright (c) 2026 SoftHSMv2 contributors * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR - * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED - * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY - * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE - * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER - * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR - * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN - * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * SPDX-License-Identifier: BSD-2-Clause */ /***************************************************************************** diff --git a/src/lib/crypto/OSSLSHA3_384.h b/src/lib/crypto/OSSLSHA3_384.h index c3bf6aa6e..957c740cd 100644 --- a/src/lib/crypto/OSSLSHA3_384.h +++ b/src/lib/crypto/OSSLSHA3_384.h @@ -1,27 +1,7 @@ /* - * Copyright (c) 2010 SURFnet bv - * All rights reserved. + * Copyright (c) 2026 SoftHSMv2 contributors * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR - * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED - * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY - * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE - * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER - * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR - * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN - * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * SPDX-License-Identifier: BSD-2-Clause */ /***************************************************************************** diff --git a/src/lib/crypto/OSSLSHA3_512.cpp b/src/lib/crypto/OSSLSHA3_512.cpp index 5dddd1673..d51bfadf0 100644 --- a/src/lib/crypto/OSSLSHA3_512.cpp +++ b/src/lib/crypto/OSSLSHA3_512.cpp @@ -1,27 +1,7 @@ /* - * Copyright (c) 2010 SURFnet bv - * All rights reserved. + * Copyright (c) 2026 SoftHSMv2 contributors * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR - * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED - * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY - * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE - * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER - * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR - * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN - * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * SPDX-License-Identifier: BSD-2-Clause */ /***************************************************************************** diff --git a/src/lib/crypto/OSSLSHA3_512.h b/src/lib/crypto/OSSLSHA3_512.h index 0b1aacff5..d546f90e8 100644 --- a/src/lib/crypto/OSSLSHA3_512.h +++ b/src/lib/crypto/OSSLSHA3_512.h @@ -1,27 +1,7 @@ /* - * Copyright (c) 2010 SURFnet bv - * All rights reserved. + * Copyright (c) 2026 SoftHSMv2 contributors * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR - * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED - * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY - * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE - * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER - * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR - * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN - * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * SPDX-License-Identifier: BSD-2-Clause */ /***************************************************************************** From 9b8b40cf11888e406a24e83f53e01c27d2c2d1c2 Mon Sep 17 00:00:00 2001 From: Alexandre Laroche Date: Mon, 27 Jul 2026 22:11:44 -0400 Subject: [PATCH 10/10] Wire up SHA3 detection in the CMake build MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit bukka asked on PR #894 how WITH_SHA3 gets enabled via CMake — it didn't; config.h.in.cmake referenced @WITH_SHA3@ but nothing ever set it, so CMake builds silently compiled out all SHA3 support. Mirrors the autotools logic (m4/acx_crypto_backend.m4, acx_openssl_sha3.m4): Botan always has SHA3 so it's set unconditionally, OpenSSL gets a try_run sanity check requiring OpenSSL >= 1.1.1 / LibreSSL >= 3.8.0. Verified with a real CMake configure+build: OpenSSL backend builds clean and cryptotest/p11test (81 tests, SHA3 PSS included) pass. --- cmake/modules/CompilerOptions.cmake | 21 +++++++++++++++++++++ cmake/modules/tests/test_openssl_sha3.c | 16 ++++++++++++++++ 2 files changed, 37 insertions(+) create mode 100644 cmake/modules/tests/test_openssl_sha3.c 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; +}