diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 153565e65..16477b291 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -76,14 +76,14 @@ jobs: make check || (find . -name test-suite.log -exec cat {} \; && false) linux_ossl_35: - name: Linux with OpenSSL 3.5.6 + name: Linux with OpenSSL 3.5.5 runs-on: ubuntu-24.04 steps: - uses: actions/checkout@v4 - name: Prepare env: - OPENSSL_VERSION: 3.5.6 - OPENSSL_SHA256: "deae7c80cba99c4b4f940ecadb3c3338b13cb77418409238e57d7f31f2a3b736" + OPENSSL_VERSION: 3.5.5 + OPENSSL_SHA256: "b28c91532a8b65a1f983b4c28b7488174e4a01008e29ce8e69bd789f28bc2a89" OPENSSL_INSTALL_DIR: /usr/local/openssl-3.5 LDFLAGS: "-Wl,-rpath,/usr/local/openssl-3.5/lib64 -L/usr/local/openssl-3.5/lib64" PKG_CONFIG_PATH: "/usr/local/openssl-3.5/lib64/pkgconfig" @@ -97,7 +97,7 @@ jobs: cd openssl-${{ env.OPENSSL_VERSION }} ./config shared zlib no-ssl3 no-weak-ssl-ciphers --prefix=${{ env.OPENSSL_INSTALL_DIR }} --openssldir=${{ env.OPENSSL_INSTALL_DIR }} make -j$(nproc) > build.log - sudo make install_sw > install.log + sudo make install > install.log cd ${{ env.OPENSSL_INSTALL_DIR }} sudo ln -sf lib64 lib - name: Build diff --git a/.gitignore b/.gitignore index 6f96816dd..767f07852 100644 --- a/.gitignore +++ b/.gitignore @@ -1,3 +1,5 @@ +# VsCode +.vscode # Automake, autoconf, libtool Makefile Makefile.in diff --git a/src/lib/SoftHSM.cpp b/src/lib/SoftHSM.cpp index 8ef2121e1..1ce08e6b6 100644 --- a/src/lib/SoftHSM.cpp +++ b/src/lib/SoftHSM.cpp @@ -47,6 +47,7 @@ #include "DESKey.h" #include "RNG.h" #include "RSAParameters.h" +#include "RSAMechanismParam.h" #include "RSAPublicKey.h" #include "RSAPrivateKey.h" #include "DSAParameters.h" @@ -242,7 +243,7 @@ static CK_RV extractObjectInformation(CK_ATTRIBUTE_PTR pTemplate, case CKA_CLASS: if (pTemplate[i].ulValueLen == sizeof(CK_OBJECT_CLASS)) { - memcpy(&objClass, pTemplate[i].pValue, sizeof(objClass)); + objClass = *(CK_OBJECT_CLASS_PTR)pTemplate[i].pValue; bHasClass = true; } break; @@ -2092,8 +2093,7 @@ CK_RV SoftHSM::C_FindObjectsInit(CK_SESSION_HANDLE hSession, CK_ATTRIBUTE_PTR pT { if (sizeof(CK_ULONG) != pTemplate[i].ulValueLen) break; - CK_ULONG ulTemplateValue; - memcpy(&ulTemplateValue, pTemplate[i].pValue, sizeof(ulTemplateValue)); + CK_ULONG ulTemplateValue = *(CK_ULONG_PTR)pTemplate[i].pValue; if (attr.getUnsignedLongValue() != ulTemplateValue) break; } @@ -2522,6 +2522,7 @@ CK_RV SoftHSM::AsymEncryptInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMec // Get the asymmetric algorithm matching the mechanism AsymMech::Type mechanism; bool isRSA = false; + MechanismParam* mechanismParam = NULL; switch(pMechanism->mechanism) { case CKM_RSA_PKCS: if (keyType != CKK_RSA) @@ -2572,8 +2573,23 @@ CK_RV SoftHSM::AsymEncryptInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMec } else { - return CKR_MECHANISM_INVALID; - } + return CKR_MECHANISM_INVALID; + } + // set mechanism parameters + if (pMechanism->mechanism == CKM_RSA_PKCS_OAEP) + { + RSAOaepMechanismParam* rsaOaepMechanismParam = new RSAOaepMechanismParam; + rv = BuildRSAOAEPParam((CK_RSA_PKCS_OAEP_PARAMS *)pMechanism->pParameter, + rsaOaepMechanismParam); + if (rv != CKR_OK) + { + delete rsaOaepMechanismParam; + asymCrypto->recyclePublicKey(publicKey); + CryptoFactory::i()->recycleAsymmetricAlgorithm(asymCrypto); + return rv; + } + mechanismParam = rsaOaepMechanismParam; + } session->setOpType(SESSION_OP_ENCRYPT); session->setAsymmetricCryptoOp(asymCrypto); @@ -2581,7 +2597,11 @@ CK_RV SoftHSM::AsymEncryptInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMec session->setAllowMultiPartOp(false); session->setAllowSinglePartOp(true); session->setPublicKey(publicKey); - + if (mechanismParam != NULL) + { + session->setMechanismParam(mechanismParam); + delete mechanismParam; + } return CKR_OK; } @@ -2677,7 +2697,9 @@ static CK_RV AsymEncrypt(Session* session, CK_BYTE_PTR pData, CK_ULONG ulDataLen { AsymmetricAlgorithm* asymCrypto = session->getAsymmetricCryptoOp(); AsymMech::Type mechanism = session->getMechanism(); + MechanismParam* mechanismParam = session->getMechanismParam(); PublicKey* publicKey = session->getPublicKey(); + if (asymCrypto == NULL || !session->getAllowSinglePartOp() || publicKey == NULL) { session->resetOp(); @@ -2712,7 +2734,7 @@ static CK_RV AsymEncrypt(Session* session, CK_BYTE_PTR pData, CK_ULONG ulDataLen data += ByteString(pData, ulDataLen); // Encrypt the data - if (!asymCrypto->encrypt(publicKey,data,encryptedData,mechanism)) + if (!asymCrypto->encrypt(publicKey,data,encryptedData,mechanism, mechanismParam)) { session->resetOp(); return CKR_GENERAL_ERROR; @@ -3255,6 +3277,7 @@ CK_RV SoftHSM::AsymDecryptInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMec // Get the asymmetric algorithm matching the mechanism AsymMech::Type mechanism = AsymMech::Unknown; + MechanismParam* mechanismParam = NULL; bool isRSA = false; switch(pMechanism->mechanism) { case CKM_RSA_PKCS: @@ -3314,14 +3337,32 @@ CK_RV SoftHSM::AsymDecryptInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMec { session->setReAuthentication(true); } - + // set mechanism parameters + if (pMechanism->mechanism == CKM_RSA_PKCS_OAEP) + { + RSAOaepMechanismParam* rsaOaepMechanismParam = new RSAOaepMechanismParam; + rv = BuildRSAOAEPParam((CK_RSA_PKCS_OAEP_PARAMS *)pMechanism->pParameter, + rsaOaepMechanismParam); + if (rv != CKR_OK) + { + delete rsaOaepMechanismParam; + asymCrypto->recyclePrivateKey(privateKey); + CryptoFactory::i()->recycleAsymmetricAlgorithm(asymCrypto); + return rv; + } + mechanismParam = rsaOaepMechanismParam; + } session->setOpType(SESSION_OP_DECRYPT); session->setAsymmetricCryptoOp(asymCrypto); session->setMechanism(mechanism); session->setAllowMultiPartOp(false); session->setAllowSinglePartOp(true); session->setPrivateKey(privateKey); - + if (mechanismParam != NULL) + { + session->setMechanismParam(mechanismParam); + delete mechanismParam; + } return CKR_OK; } @@ -3409,7 +3450,9 @@ static CK_RV AsymDecrypt(Session* session, CK_BYTE_PTR pEncryptedData, CK_ULONG { AsymmetricAlgorithm* asymCrypto = session->getAsymmetricCryptoOp(); AsymMech::Type mechanism = session->getMechanism(); + MechanismParam* mechanismParam = session->getMechanismParam(); PrivateKey* privateKey = session->getPrivateKey(); + if (asymCrypto == NULL || !session->getAllowSinglePartOp() || privateKey == NULL) { session->resetOp(); @@ -3443,7 +3486,7 @@ static CK_RV AsymDecrypt(Session* session, CK_BYTE_PTR pEncryptedData, CK_ULONG ByteString data; // Decrypt the data - if (!asymCrypto->decrypt(privateKey,encryptedData,data,mechanism)) + if (!asymCrypto->decrypt(privateKey,encryptedData,data,mechanism,mechanismParam)) { session->resetOp(); return CKR_ENCRYPTED_DATA_INVALID; @@ -4191,30 +4234,23 @@ CK_RV SoftHSM::AsymSignInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechan if (!isMechanismPermitted(key, pMechanism->mechanism)) return CKR_MECHANISM_INVALID; - // Get key info - CK_KEY_TYPE keyType = key->getUnsignedLongValue(CKA_KEY_TYPE, CKK_VENDOR_DEFINED); - // Get the asymmetric algorithm matching the mechanism AsymMech::Type mechanism = AsymMech::Unknown; - void* param = NULL; - size_t paramLen = 0; MechanismParam* mechanismParam = NULL; - RSA_PKCS_PSS_PARAMS pssParam; + RSAPssMechanismParam rsaPssParam; bool bAllowMultiPartOp; bool isRSA = false; bool isDSA = false; #ifdef WITH_ECC bool isECDSA = false; #endif -#ifdef WITH_GOST - bool isGOST = false; -#endif #ifdef WITH_EDDSA bool isEDDSA = false; #endif #ifdef WITH_ML_DSA bool isMLDSA = false; MLDSAMechanismParam mldsaParam; + CK_KEY_TYPE keyType; #endif switch(pMechanism->mechanism) { case CKM_RSA_PKCS: @@ -4272,28 +4308,28 @@ CK_RV SoftHSM::AsymSignInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechan switch(CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->hashAlg) { case CKM_SHA_1: - pssParam.hashAlg = HashAlgo::SHA1; - pssParam.mgf = AsymRSAMGF::MGF1_SHA1; + rsaPssParam.hashAlg = HashAlgo::SHA1; + rsaPssParam.mgfAlg = AsymRSAMGF::MGF1_SHA1; allowedMgf = CKG_MGF1_SHA1; break; case CKM_SHA224: - pssParam.hashAlg = HashAlgo::SHA224; - pssParam.mgf = AsymRSAMGF::MGF1_SHA224; + rsaPssParam.hashAlg = HashAlgo::SHA224; + rsaPssParam.mgfAlg = AsymRSAMGF::MGF1_SHA224; allowedMgf = CKG_MGF1_SHA224; break; case CKM_SHA256: - pssParam.hashAlg = HashAlgo::SHA256; - pssParam.mgf = AsymRSAMGF::MGF1_SHA256; + rsaPssParam.hashAlg = HashAlgo::SHA256; + rsaPssParam.mgfAlg = AsymRSAMGF::MGF1_SHA256; allowedMgf = CKG_MGF1_SHA256; break; case CKM_SHA384: - pssParam.hashAlg = HashAlgo::SHA384; - pssParam.mgf = AsymRSAMGF::MGF1_SHA384; + rsaPssParam.hashAlg = HashAlgo::SHA384; + rsaPssParam.mgfAlg = AsymRSAMGF::MGF1_SHA384; allowedMgf = CKG_MGF1_SHA384; break; case CKM_SHA512: - pssParam.hashAlg = HashAlgo::SHA512; - pssParam.mgf = AsymRSAMGF::MGF1_SHA512; + rsaPssParam.hashAlg = HashAlgo::SHA512; + rsaPssParam.mgfAlg = AsymRSAMGF::MGF1_SHA512; allowedMgf = CKG_MGF1_SHA512; break; default: @@ -4306,9 +4342,8 @@ CK_RV SoftHSM::AsymSignInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechan return CKR_ARGUMENTS_BAD; } - pssParam.sLen = CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->sLen; - param = &pssParam; - paramLen = sizeof(pssParam); + rsaPssParam.sLen = CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->sLen; + mechanismParam = &rsaPssParam; bAllowMultiPartOp = false; isRSA = true; break; @@ -4323,11 +4358,10 @@ CK_RV SoftHSM::AsymSignInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechan return CKR_ARGUMENTS_BAD; } mechanism = AsymMech::RSA_SHA1_PKCS_PSS; - pssParam.hashAlg = HashAlgo::SHA1; - pssParam.mgf = AsymRSAMGF::MGF1_SHA1; - pssParam.sLen = CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->sLen; - param = &pssParam; - paramLen = sizeof(pssParam); + rsaPssParam.hashAlg = HashAlgo::SHA1; + rsaPssParam.mgfAlg = AsymRSAMGF::MGF1_SHA1; + rsaPssParam.sLen = CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->sLen; + mechanismParam = &rsaPssParam; bAllowMultiPartOp = true; isRSA = true; break; @@ -4341,11 +4375,10 @@ CK_RV SoftHSM::AsymSignInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechan return CKR_ARGUMENTS_BAD; } mechanism = AsymMech::RSA_SHA224_PKCS_PSS; - pssParam.hashAlg = HashAlgo::SHA224; - pssParam.mgf = AsymRSAMGF::MGF1_SHA224; - pssParam.sLen = CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->sLen; - param = &pssParam; - paramLen = sizeof(pssParam); + rsaPssParam.hashAlg = HashAlgo::SHA224; + rsaPssParam.mgfAlg = AsymRSAMGF::MGF1_SHA224; + rsaPssParam.sLen = CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->sLen; + mechanismParam = &rsaPssParam; bAllowMultiPartOp = true; isRSA = true; break; @@ -4359,11 +4392,10 @@ CK_RV SoftHSM::AsymSignInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechan return CKR_ARGUMENTS_BAD; } mechanism = AsymMech::RSA_SHA256_PKCS_PSS; - pssParam.hashAlg = HashAlgo::SHA256; - pssParam.mgf = AsymRSAMGF::MGF1_SHA256; - pssParam.sLen = CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->sLen; - param = &pssParam; - paramLen = sizeof(pssParam); + rsaPssParam.hashAlg = HashAlgo::SHA256; + rsaPssParam.mgfAlg = AsymRSAMGF::MGF1_SHA256; + rsaPssParam.sLen = CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->sLen; + mechanismParam = &rsaPssParam; bAllowMultiPartOp = true; isRSA = true; break; @@ -4377,11 +4409,10 @@ CK_RV SoftHSM::AsymSignInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechan return CKR_ARGUMENTS_BAD; } mechanism = AsymMech::RSA_SHA384_PKCS_PSS; - pssParam.hashAlg = HashAlgo::SHA384; - pssParam.mgf = AsymRSAMGF::MGF1_SHA384; - pssParam.sLen = CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->sLen; - param = &pssParam; - paramLen = sizeof(pssParam); + rsaPssParam.hashAlg = HashAlgo::SHA384; + rsaPssParam.mgfAlg = AsymRSAMGF::MGF1_SHA384; + rsaPssParam.sLen = CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->sLen; + mechanismParam = &rsaPssParam; bAllowMultiPartOp = true; isRSA = true; break; @@ -4395,11 +4426,10 @@ CK_RV SoftHSM::AsymSignInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechan return CKR_ARGUMENTS_BAD; } mechanism = AsymMech::RSA_SHA512_PKCS_PSS; - pssParam.hashAlg = HashAlgo::SHA512; - pssParam.mgf = AsymRSAMGF::MGF1_SHA512; - pssParam.sLen = CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->sLen; - param = &pssParam; - paramLen = sizeof(pssParam); + rsaPssParam.hashAlg = HashAlgo::SHA512; + rsaPssParam.mgfAlg = AsymRSAMGF::MGF1_SHA512; + rsaPssParam.sLen = CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->sLen; + mechanismParam = &rsaPssParam; bAllowMultiPartOp = true; isRSA = true; break; @@ -4469,12 +4499,10 @@ CK_RV SoftHSM::AsymSignInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechan case CKM_GOSTR3410: mechanism = AsymMech::GOST; bAllowMultiPartOp = false; - isGOST = true; break; case CKM_GOSTR3410_WITH_GOSTR3411: mechanism = AsymMech::GOST_GOST; bAllowMultiPartOp = true; - isGOST = true; break; #endif #ifdef WITH_EDDSA @@ -4486,8 +4514,14 @@ CK_RV SoftHSM::AsymSignInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechan #endif #ifdef WITH_ML_DSA case CKM_ML_DSA: + // Get key info + keyType = key->getUnsignedLongValue(CKA_KEY_TYPE, CKK_VENDOR_DEFINED); + if (keyType != CKK_ML_DSA) + { + return CKR_KEY_TYPE_INCONSISTENT; + } mechanism = AsymMech::MLDSA; - bAllowMultiPartOp = true; + bAllowMultiPartOp = false; isMLDSA = true; if (pMechanism->pParameter == NULL_PTR) { @@ -4520,7 +4554,6 @@ CK_RV SoftHSM::AsymSignInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechan return CKR_ARGUMENTS_BAD; } mldsaParam.additionalContext = ByteString(ckSignAdditionalContext->pContext, ckSignAdditionalContext->ulContextLen); - DEBUG_MSG("Sign MLDSA additionalContextLen=%lu, hedgeType=%d", (unsigned long)mldsaParam.additionalContext.size(), mldsaParam.hedgeType); } mechanismParam = &mldsaParam; } @@ -4534,9 +4567,6 @@ CK_RV SoftHSM::AsymSignInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechan PrivateKey* privateKey = NULL; if (isRSA) { - if (keyType != CKK_RSA) - return CKR_KEY_TYPE_INCONSISTENT; - asymCrypto = CryptoFactory::i()->getAsymmetricAlgorithm(AsymAlgo::RSA); if (asymCrypto == NULL) return CKR_MECHANISM_INVALID; @@ -4556,9 +4586,6 @@ CK_RV SoftHSM::AsymSignInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechan } else if (isDSA) { - if (keyType != CKK_DSA) - return CKR_KEY_TYPE_INCONSISTENT; - asymCrypto = CryptoFactory::i()->getAsymmetricAlgorithm(AsymAlgo::DSA); if (asymCrypto == NULL) return CKR_MECHANISM_INVALID; @@ -4579,9 +4606,6 @@ CK_RV SoftHSM::AsymSignInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechan #ifdef WITH_ECC else if (isECDSA) { - if (keyType != CKK_EC) - return CKR_KEY_TYPE_INCONSISTENT; - asymCrypto = CryptoFactory::i()->getAsymmetricAlgorithm(AsymAlgo::ECDSA); if (asymCrypto == NULL) return CKR_MECHANISM_INVALID; @@ -4603,9 +4627,6 @@ CK_RV SoftHSM::AsymSignInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechan #ifdef WITH_EDDSA else if (isEDDSA) { - if (keyType != CKK_EC_EDWARDS) - return CKR_KEY_TYPE_INCONSISTENT; - asymCrypto = CryptoFactory::i()->getAsymmetricAlgorithm(AsymAlgo::EDDSA); if (asymCrypto == NULL) return CKR_MECHANISM_INVALID; @@ -4627,9 +4648,6 @@ CK_RV SoftHSM::AsymSignInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechan #ifdef WITH_ML_DSA else if (isMLDSA) { - if (keyType != CKK_ML_DSA) - return CKR_KEY_TYPE_INCONSISTENT; - asymCrypto = CryptoFactory::i()->getAsymmetricAlgorithm(AsymAlgo::MLDSA); if (asymCrypto == NULL) return CKR_MECHANISM_INVALID; @@ -4648,12 +4666,9 @@ CK_RV SoftHSM::AsymSignInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechan } } #endif -#ifdef WITH_GOST - else if (isGOST) + else { - if (keyType != CKK_GOSTR3410) - return CKR_KEY_TYPE_INCONSISTENT; - +#ifdef WITH_GOST asymCrypto = CryptoFactory::i()->getAsymmetricAlgorithm(AsymAlgo::GOST); if (asymCrypto == NULL) return CKR_MECHANISM_INVALID; @@ -4670,15 +4685,13 @@ CK_RV SoftHSM::AsymSignInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechan CryptoFactory::i()->recycleAsymmetricAlgorithm(asymCrypto); return CKR_GENERAL_ERROR; } - } -#endif - else - { +#else return CKR_MECHANISM_INVALID; - } +#endif + } // Initialize signing - if (bAllowMultiPartOp && !asymCrypto->signInit(privateKey,mechanism,param,paramLen,mechanismParam)) + if (bAllowMultiPartOp && !asymCrypto->signInit(privateKey,mechanism,mechanismParam)) { asymCrypto->recyclePrivateKey(privateKey); CryptoFactory::i()->recycleAsymmetricAlgorithm(asymCrypto); @@ -4694,7 +4707,6 @@ CK_RV SoftHSM::AsymSignInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechan session->setOpType(SESSION_OP_SIGN); session->setAsymmetricCryptoOp(asymCrypto); session->setMechanism(mechanism); - session->setParameters(param, paramLen); session->setMechanismParam(mechanismParam); session->setAllowMultiPartOp(bAllowMultiPartOp); session->setAllowSinglePartOp(true); @@ -4775,8 +4787,6 @@ static CK_RV AsymSign(Session* session, CK_BYTE_PTR pData, CK_ULONG ulDataLen, C AsymmetricAlgorithm* asymCrypto = session->getAsymmetricCryptoOp(); AsymMech::Type mechanism = session->getMechanism(); PrivateKey* privateKey = session->getPrivateKey(); - size_t paramLen; - void* param = session->getParameters(paramLen); MechanismParam* mechanismParam = session->getMechanismParam(); if (asymCrypto == NULL || !session->getAllowSinglePartOp() || privateKey == NULL) { @@ -4827,7 +4837,7 @@ static CK_RV AsymSign(Session* session, CK_BYTE_PTR pData, CK_ULONG ulDataLen, C return CKR_GENERAL_ERROR; } } - else if (!asymCrypto->sign(privateKey,data,signature,mechanism,param,paramLen,mechanismParam)) + else if (!asymCrypto->sign(privateKey,data,signature,mechanism,mechanismParam)) { session->resetOp(); return CKR_GENERAL_ERROR; @@ -5292,30 +5302,23 @@ CK_RV SoftHSM::AsymVerifyInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMech if (!isMechanismPermitted(key, pMechanism->mechanism)) return CKR_MECHANISM_INVALID; - // Get key info - CK_KEY_TYPE keyType = key->getUnsignedLongValue(CKA_KEY_TYPE, CKK_VENDOR_DEFINED); - // Get the asymmetric algorithm matching the mechanism AsymMech::Type mechanism = AsymMech::Unknown; - void* param = NULL; - size_t paramLen = 0; MechanismParam* mechanismParam = NULL; - RSA_PKCS_PSS_PARAMS pssParam; + RSAPssMechanismParam rsaPssParam; bool bAllowMultiPartOp; bool isRSA = false; bool isDSA = false; #ifdef WITH_ECC bool isECDSA = false; #endif -#ifdef WITH_GOST - bool isGOST = false; -#endif #ifdef WITH_EDDSA bool isEDDSA = false; #endif #ifdef WITH_ML_DSA bool isMLDSA = false; MLDSAMechanismParam mldsaParam; + CK_KEY_TYPE keyType; #endif switch(pMechanism->mechanism) { case CKM_RSA_PKCS: @@ -5373,28 +5376,28 @@ CK_RV SoftHSM::AsymVerifyInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMech unsigned long expectedMgf; switch(CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->hashAlg) { case CKM_SHA_1: - pssParam.hashAlg = HashAlgo::SHA1; - pssParam.mgf = AsymRSAMGF::MGF1_SHA1; + rsaPssParam.hashAlg = HashAlgo::SHA1; + rsaPssParam.mgfAlg = AsymRSAMGF::MGF1_SHA1; expectedMgf = CKG_MGF1_SHA1; break; case CKM_SHA224: - pssParam.hashAlg = HashAlgo::SHA224; - pssParam.mgf = AsymRSAMGF::MGF1_SHA224; + rsaPssParam.hashAlg = HashAlgo::SHA224; + rsaPssParam.mgfAlg = AsymRSAMGF::MGF1_SHA224; expectedMgf = CKG_MGF1_SHA224; break; case CKM_SHA256: - pssParam.hashAlg = HashAlgo::SHA256; - pssParam.mgf = AsymRSAMGF::MGF1_SHA256; + rsaPssParam.hashAlg = HashAlgo::SHA256; + rsaPssParam.mgfAlg = AsymRSAMGF::MGF1_SHA256; expectedMgf = CKG_MGF1_SHA256; break; case CKM_SHA384: - pssParam.hashAlg = HashAlgo::SHA384; - pssParam.mgf = AsymRSAMGF::MGF1_SHA384; + rsaPssParam.hashAlg = HashAlgo::SHA384; + rsaPssParam.mgfAlg = AsymRSAMGF::MGF1_SHA384; expectedMgf = CKG_MGF1_SHA384; break; case CKM_SHA512: - pssParam.hashAlg = HashAlgo::SHA512; - pssParam.mgf = AsymRSAMGF::MGF1_SHA512; + rsaPssParam.hashAlg = HashAlgo::SHA512; + rsaPssParam.mgfAlg = AsymRSAMGF::MGF1_SHA512; expectedMgf = CKG_MGF1_SHA512; break; default: @@ -5405,9 +5408,8 @@ CK_RV SoftHSM::AsymVerifyInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMech return CKR_ARGUMENTS_BAD; } - pssParam.sLen = CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->sLen; - param = &pssParam; - paramLen = sizeof(pssParam); + rsaPssParam.sLen = CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->sLen; + mechanismParam = &rsaPssParam; bAllowMultiPartOp = false; isRSA = true; break; @@ -5422,11 +5424,10 @@ CK_RV SoftHSM::AsymVerifyInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMech return CKR_ARGUMENTS_BAD; } mechanism = AsymMech::RSA_SHA1_PKCS_PSS; - pssParam.hashAlg = HashAlgo::SHA1; - pssParam.mgf = AsymRSAMGF::MGF1_SHA1; - pssParam.sLen = CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->sLen; - param = &pssParam; - paramLen = sizeof(pssParam); + rsaPssParam.hashAlg = HashAlgo::SHA1; + rsaPssParam.mgfAlg = AsymRSAMGF::MGF1_SHA1; + rsaPssParam.sLen = CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->sLen; + mechanismParam = &rsaPssParam; bAllowMultiPartOp = true; isRSA = true; break; @@ -5440,11 +5441,10 @@ CK_RV SoftHSM::AsymVerifyInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMech return CKR_ARGUMENTS_BAD; } mechanism = AsymMech::RSA_SHA224_PKCS_PSS; - pssParam.hashAlg = HashAlgo::SHA224; - pssParam.mgf = AsymRSAMGF::MGF1_SHA224; - pssParam.sLen = CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->sLen; - param = &pssParam; - paramLen = sizeof(pssParam); + rsaPssParam.hashAlg = HashAlgo::SHA224; + rsaPssParam.mgfAlg = AsymRSAMGF::MGF1_SHA224; + rsaPssParam.sLen = CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->sLen; + mechanismParam = &rsaPssParam; bAllowMultiPartOp = true; isRSA = true; break; @@ -5458,11 +5458,10 @@ CK_RV SoftHSM::AsymVerifyInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMech return CKR_ARGUMENTS_BAD; } mechanism = AsymMech::RSA_SHA256_PKCS_PSS; - pssParam.hashAlg = HashAlgo::SHA256; - pssParam.mgf = AsymRSAMGF::MGF1_SHA256; - pssParam.sLen = CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->sLen; - param = &pssParam; - paramLen = sizeof(pssParam); + rsaPssParam.hashAlg = HashAlgo::SHA256; + rsaPssParam.mgfAlg = AsymRSAMGF::MGF1_SHA256; + rsaPssParam.sLen = CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->sLen; + mechanismParam = &rsaPssParam; bAllowMultiPartOp = true; isRSA = true; break; @@ -5476,11 +5475,10 @@ CK_RV SoftHSM::AsymVerifyInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMech return CKR_ARGUMENTS_BAD; } mechanism = AsymMech::RSA_SHA384_PKCS_PSS; - pssParam.hashAlg = HashAlgo::SHA384; - pssParam.mgf = AsymRSAMGF::MGF1_SHA384; - pssParam.sLen = CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->sLen; - param = &pssParam; - paramLen = sizeof(pssParam); + rsaPssParam.hashAlg = HashAlgo::SHA384; + rsaPssParam.mgfAlg = AsymRSAMGF::MGF1_SHA384; + rsaPssParam.sLen = CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->sLen; + mechanismParam = &rsaPssParam; bAllowMultiPartOp = true; isRSA = true; break; @@ -5494,11 +5492,11 @@ CK_RV SoftHSM::AsymVerifyInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMech return CKR_ARGUMENTS_BAD; } mechanism = AsymMech::RSA_SHA512_PKCS_PSS; - pssParam.hashAlg = HashAlgo::SHA512; - pssParam.mgf = AsymRSAMGF::MGF1_SHA512; - pssParam.sLen = CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->sLen; - param = &pssParam; - paramLen = sizeof(pssParam); + rsaPssParam.hashAlg = HashAlgo::SHA512; + rsaPssParam.mgfAlg = AsymRSAMGF::MGF1_SHA512; + rsaPssParam.sLen = CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->sLen; + mechanismParam = &rsaPssParam; + bAllowMultiPartOp = true; isRSA = true; break; @@ -5568,12 +5566,10 @@ CK_RV SoftHSM::AsymVerifyInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMech case CKM_GOSTR3410: mechanism = AsymMech::GOST; bAllowMultiPartOp = false; - isGOST = true; break; case CKM_GOSTR3410_WITH_GOSTR3411: mechanism = AsymMech::GOST_GOST; bAllowMultiPartOp = true; - isGOST = true; break; #endif #ifdef WITH_EDDSA @@ -5585,6 +5581,12 @@ CK_RV SoftHSM::AsymVerifyInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMech #endif #ifdef WITH_ML_DSA case CKM_ML_DSA: + // Get key info + keyType = key->getUnsignedLongValue(CKA_KEY_TYPE, CKK_VENDOR_DEFINED); + if (keyType != CKK_ML_DSA) + { + return CKR_KEY_TYPE_INCONSISTENT; + } mechanism = AsymMech::MLDSA; bAllowMultiPartOp = false; isMLDSA = true; @@ -5619,7 +5621,6 @@ CK_RV SoftHSM::AsymVerifyInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMech return CKR_ARGUMENTS_BAD; } mldsaParam.additionalContext = ByteString(ckSignAdditionalContext->pContext, ckSignAdditionalContext->ulContextLen); - DEBUG_MSG("Verify MLDSA additionalContextLen=%lu, hedgeType=%d", (unsigned long)mldsaParam.additionalContext.size(), mldsaParam.hedgeType); } mechanismParam = &mldsaParam; } @@ -5633,9 +5634,6 @@ CK_RV SoftHSM::AsymVerifyInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMech PublicKey* publicKey = NULL; if (isRSA) { - if (keyType != CKK_RSA) - return CKR_KEY_TYPE_INCONSISTENT; - asymCrypto = CryptoFactory::i()->getAsymmetricAlgorithm(AsymAlgo::RSA); if (asymCrypto == NULL) return CKR_MECHANISM_INVALID; @@ -5655,9 +5653,6 @@ CK_RV SoftHSM::AsymVerifyInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMech } else if (isDSA) { - if (keyType != CKK_DSA) - return CKR_KEY_TYPE_INCONSISTENT; - asymCrypto = CryptoFactory::i()->getAsymmetricAlgorithm(AsymAlgo::DSA); if (asymCrypto == NULL) return CKR_MECHANISM_INVALID; @@ -5678,9 +5673,6 @@ CK_RV SoftHSM::AsymVerifyInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMech #ifdef WITH_ECC else if (isECDSA) { - if (keyType != CKK_EC) - return CKR_KEY_TYPE_INCONSISTENT; - asymCrypto = CryptoFactory::i()->getAsymmetricAlgorithm(AsymAlgo::ECDSA); if (asymCrypto == NULL) return CKR_MECHANISM_INVALID; @@ -5702,9 +5694,6 @@ CK_RV SoftHSM::AsymVerifyInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMech #ifdef WITH_EDDSA else if (isEDDSA) { - if (keyType != CKK_EC_EDWARDS) - return CKR_KEY_TYPE_INCONSISTENT; - asymCrypto = CryptoFactory::i()->getAsymmetricAlgorithm(AsymAlgo::EDDSA); if (asymCrypto == NULL) return CKR_MECHANISM_INVALID; @@ -5726,9 +5715,6 @@ CK_RV SoftHSM::AsymVerifyInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMech #ifdef WITH_ML_DSA else if (isMLDSA) { - if (keyType != CKK_ML_DSA) - return CKR_KEY_TYPE_INCONSISTENT; - asymCrypto = CryptoFactory::i()->getAsymmetricAlgorithm(AsymAlgo::MLDSA); if (asymCrypto == NULL) return CKR_MECHANISM_INVALID; @@ -5747,12 +5733,9 @@ CK_RV SoftHSM::AsymVerifyInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMech } } #endif -#ifdef WITH_GOST - else if (isGOST) + else { - if (keyType != CKK_GOSTR3410) - return CKR_KEY_TYPE_INCONSISTENT; - +#ifdef WITH_GOST asymCrypto = CryptoFactory::i()->getAsymmetricAlgorithm(AsymAlgo::GOST); if (asymCrypto == NULL) return CKR_MECHANISM_INVALID; @@ -5769,15 +5752,13 @@ CK_RV SoftHSM::AsymVerifyInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMech CryptoFactory::i()->recycleAsymmetricAlgorithm(asymCrypto); return CKR_GENERAL_ERROR; } - } -#endif - else - { +#else return CKR_MECHANISM_INVALID; - } +#endif + } // Initialize verifying - if (bAllowMultiPartOp && !asymCrypto->verifyInit(publicKey,mechanism,param,paramLen,mechanismParam)) + if (bAllowMultiPartOp && !asymCrypto->verifyInit(publicKey,mechanism, mechanismParam)) { asymCrypto->recyclePublicKey(publicKey); CryptoFactory::i()->recycleAsymmetricAlgorithm(asymCrypto); @@ -5787,7 +5768,6 @@ CK_RV SoftHSM::AsymVerifyInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMech session->setOpType(SESSION_OP_VERIFY); session->setAsymmetricCryptoOp(asymCrypto); session->setMechanism(mechanism); - session->setParameters(param, paramLen); session->setMechanismParam(mechanismParam); session->setAllowMultiPartOp(bAllowMultiPartOp); session->setAllowSinglePartOp(true); @@ -5856,8 +5836,6 @@ static CK_RV AsymVerify(Session* session, CK_BYTE_PTR pData, CK_ULONG ulDataLen, AsymmetricAlgorithm* asymCrypto = session->getAsymmetricCryptoOp(); AsymMech::Type mechanism = session->getMechanism(); PublicKey* publicKey = session->getPublicKey(); - size_t paramLen; - void* param = session->getParameters(paramLen); MechanismParam* mechanismParam = session->getMechanismParam(); if (asymCrypto == NULL || !session->getAllowSinglePartOp() || publicKey == NULL) { @@ -5898,7 +5876,7 @@ static CK_RV AsymVerify(Session* session, CK_BYTE_PTR pData, CK_ULONG ulDataLen, return CKR_SIGNATURE_INVALID; } } - else if (!asymCrypto->verify(publicKey,data,signature,mechanism,param,paramLen,mechanismParam)) + else if (!asymCrypto->verify(publicKey,data,signature,mechanism, mechanismParam)) { session->resetOp(); return CKR_SIGNATURE_INVALID; @@ -6713,9 +6691,12 @@ CK_RV SoftHSM::WrapKeyAsym ByteString& wrapped ) { + CK_RV rv = CKR_OK; const size_t bb = 8; AsymAlgo::Type algo = AsymAlgo::Unknown; AsymMech::Type mech = AsymMech::Unknown; + MechanismParam* mechanismParam = NULL; + size_t hashLen = 0; CK_ULONG modulus_length; switch(pMechanism->mechanism) { @@ -6743,10 +6724,8 @@ CK_RV SoftHSM::WrapKeyAsym case CKM_RSA_PKCS_OAEP: mech = AsymMech::RSA_PKCS_OAEP; - // SHA-1 is the only supported option // PKCS#11 2.40 draft 2 section 2.1.8: input length <= k-2-2hashLen - if (keydata.size() > modulus_length - 2 - 2 * 160 / 8) - return CKR_KEY_SIZE_RANGE; + // key length will be check later break; default: @@ -6775,20 +6754,39 @@ CK_RV SoftHSM::WrapKeyAsym break; default: + cipher->recyclePublicKey(publicKey); + CryptoFactory::i()->recycleAsymmetricAlgorithm(cipher); return CKR_MECHANISM_INVALID; } - // Wrap the key - if (!cipher->wrapKey(publicKey, keydata, wrapped, mech)) + if (pMechanism->mechanism == CKM_RSA_PKCS_OAEP) { - cipher->recyclePublicKey(publicKey); - CryptoFactory::i()->recycleAsymmetricAlgorithm(cipher); - return CKR_GENERAL_ERROR; + RSAOaepMechanismParam* rsaOaepMechanismParam = new RSAOaepMechanismParam; + rv = BuildRSAOAEPParam((CK_RSA_PKCS_OAEP_PARAMS *)pMechanism->pParameter, + rsaOaepMechanismParam,&hashLen); + if (rv != CKR_OK) + { + delete rsaOaepMechanismParam; + cipher->recyclePublicKey(publicKey); + CryptoFactory::i()->recycleAsymmetricAlgorithm(cipher); + return rv; + } + if (keydata.size() > modulus_length - 2 - (2 * hashLen)) + { + delete rsaOaepMechanismParam; + cipher->recyclePublicKey(publicKey); + CryptoFactory::i()->recycleAsymmetricAlgorithm(cipher); + return CKR_KEY_SIZE_RANGE; + } + mechanismParam = rsaOaepMechanismParam; } - + // Wrap the key + if (!cipher->wrapKey(publicKey, keydata, wrapped, mech, mechanismParam)) + rv = CKR_GENERAL_ERROR; + delete mechanismParam; cipher->recyclePublicKey(publicKey); CryptoFactory::i()->recycleAsymmetricAlgorithm(cipher); - return CKR_OK; + return rv; } // Internal: Wrap with mechanism RSA_AES_KEY_WRAP @@ -7314,6 +7312,8 @@ CK_RV SoftHSM::UnwrapKeyAsym // Get the symmetric algorithm matching the mechanism AsymAlgo::Type algo = AsymAlgo::Unknown; AsymMech::Type mode = AsymMech::Unknown; + MechanismParam* mechanismParam = NULL; + switch(pMechanism->mechanism) { case CKM_RSA_PKCS: algo = AsymAlgo::RSA; @@ -7350,12 +7350,29 @@ CK_RV SoftHSM::UnwrapKeyAsym break; default: + cipher->recyclePrivateKey(unwrappingkey); + CryptoFactory::i()->recycleAsymmetricAlgorithm(cipher); return CKR_MECHANISM_INVALID; } - + + if (pMechanism->mechanism == CKM_RSA_PKCS_OAEP) + { + RSAOaepMechanismParam* rsaOaepMechanismParam = new RSAOaepMechanismParam; + rv = BuildRSAOAEPParam((CK_RSA_PKCS_OAEP_PARAMS *)pMechanism->pParameter, + rsaOaepMechanismParam); + if (rv != CKR_OK) + { + delete rsaOaepMechanismParam; + cipher->recyclePrivateKey(unwrappingkey); + CryptoFactory::i()->recycleAsymmetricAlgorithm(cipher); + return rv; + } + mechanismParam = rsaOaepMechanismParam; + } // Unwrap the key - if (!cipher->unwrapKey(unwrappingkey, wrapped, keydata, mode)) + if (!cipher->unwrapKey(unwrappingkey, wrapped, keydata, mode, mechanismParam )) rv = CKR_GENERAL_ERROR; + delete mechanismParam; cipher->recyclePrivateKey(unwrappingkey); CryptoFactory::i()->recycleAsymmetricAlgorithm(cipher); return rv; @@ -13721,31 +13738,16 @@ CK_RV SoftHSM::MechParamCheckRSAPKCSOAEP(CK_MECHANISM_PTR pMechanism) ERROR_MSG("pParameter must be of type CK_RSA_PKCS_OAEP_PARAMS"); return CKR_ARGUMENTS_BAD; } - CK_RSA_PKCS_OAEP_PARAMS_PTR params = (CK_RSA_PKCS_OAEP_PARAMS_PTR)pMechanism->pParameter; - if (params->hashAlg != CKM_SHA_1) - { - ERROR_MSG("hashAlg must be CKM_SHA_1"); - return CKR_ARGUMENTS_BAD; - } - if (params->mgf != CKG_MGF1_SHA1) - { - ERROR_MSG("mgf must be CKG_MGF1_SHA1"); - return CKR_ARGUMENTS_BAD; - } + if (params->source != CKZ_DATA_SPECIFIED) { ERROR_MSG("source must be CKZ_DATA_SPECIFIED"); return CKR_ARGUMENTS_BAD; } - if (params->pSourceData != NULL) + if ((params-> pSourceData == NULL)&&(params->ulSourceDataLen != 0)) { - ERROR_MSG("pSourceData must be NULL"); - return CKR_ARGUMENTS_BAD; - } - if (params->ulSourceDataLen != 0) - { - ERROR_MSG("ulSourceDataLen must be 0"); + ERROR_MSG("pSourceData is NULL"); return CKR_ARGUMENTS_BAD; } return CKR_OK; @@ -13777,27 +13779,93 @@ CK_RV SoftHSM::MechParamCheckRSAAESKEYWRAP(CK_MECHANISM_PTR pMechanism) ERROR_MSG("pOAEPParams must be of type CK_RSA_PKCS_OAEP_PARAMS"); return CKR_ARGUMENTS_BAD; } - if (params->pOAEPParams->mgf < 1UL || params->pOAEPParams->mgf > 5UL) + if (params->pOAEPParams->source != CKZ_DATA_SPECIFIED) { - ERROR_MSG("mgf not supported"); + ERROR_MSG("source must be CKZ_DATA_SPECIFIED"); return CKR_ARGUMENTS_BAD; } - if (params->pOAEPParams->source != CKZ_DATA_SPECIFIED) + if ((params->pOAEPParams->pSourceData == NULL) && (params->pOAEPParams->ulSourceDataLen != 0)) + { + ERROR_MSG("pSourceData is NULL"); + return CKR_ARGUMENTS_BAD; + } + return CKR_OK; +} + +CK_RV SoftHSM::BuildRSAOAEPParam(const CK_RSA_PKCS_OAEP_PARAMS *params, + RSAOaepMechanismParam* mechanismParam, + size_t* hashLen) +{ + if (params == NULL) + { + ERROR_MSG("parameters is NULL for RSA OAEP encryption"); + return CKR_ARGUMENTS_BAD; + } + if (params->source != CKZ_DATA_SPECIFIED) { ERROR_MSG("source must be CKZ_DATA_SPECIFIED"); return CKR_ARGUMENTS_BAD; + } + if ((params->pSourceData == NULL) && (params->ulSourceDataLen != 0)) + { + ERROR_MSG("pSourceData is NULL"); + return CKR_ARGUMENTS_BAD; + } + switch (params->hashAlg) + { + case CKM_SHA_1: + mechanismParam->hashAlg = HashAlgo::SHA1; + if (hashLen) *hashLen = 20; + break; + case CKM_SHA224: + mechanismParam->hashAlg = HashAlgo::SHA224; + if (hashLen) *hashLen = 28; + break; + case CKM_SHA256: + mechanismParam->hashAlg = HashAlgo::SHA256; + if (hashLen) *hashLen = 32; + break; + case CKM_SHA384: + mechanismParam->hashAlg = HashAlgo::SHA384; + if (hashLen) *hashLen = 48; + break; + case CKM_SHA512: + mechanismParam->hashAlg = HashAlgo::SHA512; + if (hashLen) *hashLen = 64; + break; + default: + ERROR_MSG("hash algorithm not supported for OAEP"); + return CKR_ARGUMENTS_BAD; } - if (params->pOAEPParams->pSourceData != NULL) + switch (params->mgf) { - ERROR_MSG("pSourceData must be NULL"); + case CKG_MGF1_SHA1: + mechanismParam->mgfAlg = AsymRSAMGF::MGF1_SHA1; + break; + case CKG_MGF1_SHA224: + mechanismParam->mgfAlg = AsymRSAMGF::MGF1_SHA224; + break; + case CKG_MGF1_SHA256: + mechanismParam->mgfAlg = AsymRSAMGF::MGF1_SHA256; + break; + case CKG_MGF1_SHA384: + mechanismParam->mgfAlg = AsymRSAMGF::MGF1_SHA384; + break; + case CKG_MGF1_SHA512: + mechanismParam->mgfAlg = AsymRSAMGF::MGF1_SHA512; + break; + default: + ERROR_MSG("mgf algorithm not supported for OAEP"); return CKR_ARGUMENTS_BAD; } - if (params->pOAEPParams->ulSourceDataLen != 0) + if (params->ulSourceDataLen > MAX_RSA_OAEP_LABEL_LENGTH) { - ERROR_MSG("ulSourceDataLen must be 0"); + ERROR_MSG("OAEP Label too large"); return CKR_ARGUMENTS_BAD; } - + // copy label data to mechanismParam + mechanismParam->label = ByteString(reinterpret_cast(params->pSourceData),params->ulSourceDataLen); + return CKR_OK; } diff --git a/src/lib/SoftHSM.h b/src/lib/SoftHSM.h index ab8ac3cc2..6129dc292 100644 --- a/src/lib/SoftHSM.h +++ b/src/lib/SoftHSM.h @@ -42,6 +42,7 @@ #include "HandleManager.h" #include "RSAPublicKey.h" #include "RSAPrivateKey.h" +#include "RSAMechanismParam.h" #include "DSAPublicKey.h" #include "DSAPrivateKey.h" #include "ECPublicKey.h" @@ -525,7 +526,9 @@ class SoftHSM CK_RV MechParamCheckRSAPKCSOAEP(CK_MECHANISM_PTR pMechanism); CK_RV MechParamCheckRSAAESKEYWRAP(CK_MECHANISM_PTR pMechanism); - + CK_RV BuildRSAOAEPParam(const CK_RSA_PKCS_OAEP_PARAMS* par, + RSAOaepMechanismParam* mechanismParam, + size_t* hashLen = NULL); bool isMechanismPermitted(OSObject* key, CK_MECHANISM_TYPE mechanism); void prepareSupportedMechanisms(std::map &t); bool detectFork(void); diff --git a/src/lib/crypto/AsymmetricAlgorithm.cpp b/src/lib/crypto/AsymmetricAlgorithm.cpp index c18a6b599..de593266e 100644 --- a/src/lib/crypto/AsymmetricAlgorithm.cpp +++ b/src/lib/crypto/AsymmetricAlgorithm.cpp @@ -47,15 +47,13 @@ AsymmetricAlgorithm::AsymmetricAlgorithm() // Signing functions bool AsymmetricAlgorithm::sign(PrivateKey* privateKey, const ByteString& dataToSign, ByteString& signature, const AsymMech::Type mechanism, - const void* param /* = NULL */, const size_t paramLen /* = 0 */, - const MechanismParam* /* mechanismParam = NULL */) + const MechanismParam* mechanismParam /* = NULL */) { // Compose from multi-part operations - return (signInit(privateKey, mechanism, param, paramLen) && signUpdate(dataToSign) && signFinal(signature)); + return (signInit(privateKey, mechanism, mechanismParam) && signUpdate(dataToSign) && signFinal(signature)); } bool AsymmetricAlgorithm::signInit(PrivateKey* privateKey, const AsymMech::Type mechanism, - const void* /* param = NULL */, const size_t /* paramLen = 0 */, const MechanismParam* /* mechanismParam = NULL */) { if ((currentOperation != NONE) || (privateKey == NULL)) @@ -97,16 +95,14 @@ bool AsymmetricAlgorithm::signFinal(ByteString& /*signature*/) // Verification functions bool AsymmetricAlgorithm::verify(PublicKey* publicKey, const ByteString& originalData, const ByteString& signature, const AsymMech::Type mechanism, - const void* param /* = NULL */, const size_t paramLen /* = 0 */, - const MechanismParam* /* mechanismParam = NULL */) + const MechanismParam* mechanismParam /* = NULL */) { // Compose from multi-part operations - return (verifyInit(publicKey, mechanism, param, paramLen) && verifyUpdate(originalData) && verifyFinal(signature)); + return (verifyInit(publicKey, mechanism, mechanismParam) && verifyUpdate(originalData) && verifyFinal(signature)); } bool AsymmetricAlgorithm::verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, - const void* /* param = NULL */, const size_t /* paramLen = 0 */, - const MechanismParam* /* mechanismParam = NULL */) + const MechanismParam* /* mechanismParam = NULL */) { if ((currentOperation != NONE) || (publicKey == NULL)) { @@ -160,20 +156,22 @@ bool AsymmetricAlgorithm::isWrappingMech(AsymMech::Type padding) } // Wrap/Unwrap keys -bool AsymmetricAlgorithm::wrapKey(PublicKey* publicKey, const ByteString& data, ByteString& encryptedData, const AsymMech::Type padding) +bool AsymmetricAlgorithm::wrapKey(PublicKey* publicKey, const ByteString& data, ByteString& encryptedData, const AsymMech::Type padding, + const MechanismParam* mechanismParam) { if (!isWrappingMech(padding)) return false; - return encrypt(publicKey, data, encryptedData, padding); + return encrypt(publicKey, data, encryptedData, padding, mechanismParam); } -bool AsymmetricAlgorithm::unwrapKey(PrivateKey* privateKey, const ByteString& encryptedData, ByteString& data, const AsymMech::Type padding) +bool AsymmetricAlgorithm::unwrapKey(PrivateKey* privateKey, const ByteString& encryptedData, ByteString& data, const AsymMech::Type padding, + const MechanismParam* mechanismParam) { if (!isWrappingMech(padding)) return false; - return decrypt(privateKey, encryptedData, data, padding); + return decrypt(privateKey, encryptedData, data, padding, mechanismParam); } diff --git a/src/lib/crypto/AsymmetricAlgorithm.h b/src/lib/crypto/AsymmetricAlgorithm.h index dafa75ebd..107a2359c 100644 --- a/src/lib/crypto/AsymmetricAlgorithm.h +++ b/src/lib/crypto/AsymmetricAlgorithm.h @@ -115,13 +115,6 @@ struct AsymRSAMGF }; }; -struct RSA_PKCS_PSS_PARAMS -{ - HashAlgo::Type hashAlg; - AsymRSAMGF::Type mgf; - size_t sLen; -}; - class AsymmetricAlgorithm { public: @@ -132,26 +125,29 @@ class AsymmetricAlgorithm virtual ~AsymmetricAlgorithm() { } // Signing functions - virtual bool sign(PrivateKey* privateKey, const ByteString& dataToSign, ByteString& signature, const AsymMech::Type mechanism, const void* param = NULL, const size_t paramLen = 0, const MechanismParam* mechanismParam = NULL); - virtual bool signInit(PrivateKey* privateKey, const AsymMech::Type mechanism, const void* param = NULL, const size_t paramLen = 0, const MechanismParam* mechanismParam = NULL); + virtual bool sign(PrivateKey* privateKey, const ByteString& dataToSign, ByteString& signature, const AsymMech::Type mechanism, const MechanismParam* mechanismParam = NULL); + virtual bool signInit(PrivateKey* privateKey, const AsymMech::Type mechanism, const MechanismParam* mechanismParam = NULL); virtual bool signUpdate(const ByteString& dataToSign); virtual bool signFinal(ByteString& signature); // Verification functions - virtual bool verify(PublicKey* publicKey, const ByteString& originalData, const ByteString& signature, const AsymMech::Type mechanism, const void* param = NULL, const size_t paramLen = 0, const MechanismParam* mechanismParam = NULL); - virtual bool verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, const void* param = NULL, const size_t paramLen = 0, const MechanismParam* mechanismParam = NULL); + virtual bool verify(PublicKey* publicKey, const ByteString& originalData, const ByteString& signature, const AsymMech::Type mechanism, const MechanismParam* mechanismParam = NULL); + virtual bool verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, const MechanismParam* mechanismParam = NULL); virtual bool verifyUpdate(const ByteString& originalData); virtual bool verifyFinal(const ByteString& signature); // Encryption functions - virtual bool encrypt(PublicKey* publicKey, const ByteString& data, ByteString& encryptedData, const AsymMech::Type padding) = 0; - + virtual bool encrypt(PublicKey* publicKey, const ByteString& data, ByteString& encryptedData, const AsymMech::Type padding, + const MechanismParam* mechanismParam = NULL) = 0; // Decryption functions - virtual bool decrypt(PrivateKey* privateKey, const ByteString& encryptedData, ByteString& data, const AsymMech::Type padding) = 0; + virtual bool decrypt(PrivateKey* privateKey, const ByteString& encryptedData, ByteString& data, const AsymMech::Type padding, + const MechanismParam* mechanismParam = NULL) = 0; // Wrap/Unwrap keys - bool wrapKey(PublicKey* publicKey, const ByteString& data, ByteString& encryptedData, const AsymMech::Type padding); - bool unwrapKey(PrivateKey* privateKey, const ByteString& encryptedData, ByteString& data, const AsymMech::Type padding); + bool wrapKey(PublicKey* publicKey, const ByteString& data, ByteString& encryptedData, const AsymMech::Type padding, + const MechanismParam* mechanismParam = NULL); + bool unwrapKey(PrivateKey* privateKey, const ByteString& encryptedData, ByteString& data, const AsymMech::Type padding, + const MechanismParam* mechanismParam = NULL); // Key factory virtual bool generateKeyPair(AsymmetricKeyPair** ppKeyPair, AsymmetricParameters* parameters, RNG* rng = NULL) = 0; diff --git a/src/lib/crypto/BotanDH.cpp b/src/lib/crypto/BotanDH.cpp index 6e1ec113e..d0cb8f412 100644 --- a/src/lib/crypto/BotanDH.cpp +++ b/src/lib/crypto/BotanDH.cpp @@ -47,8 +47,7 @@ // Signing functions bool BotanDH::signInit(PrivateKey* /*privateKey*/, const AsymMech::Type /*mechanism*/, - const void* /* param = NULL */, const size_t /* paramLen = 0 */, - const MechanismParam* /* mechanismParam */) + const MechanismParam* /* param = NULL */) { ERROR_MSG("DH does not support signing"); @@ -71,8 +70,7 @@ bool BotanDH::signFinal(ByteString& /*signature*/) // Verification functions bool BotanDH::verifyInit(PublicKey* /*publicKey*/, const AsymMech::Type /*mechanism*/, - const void* /* param = NULL */, const size_t /* paramLen = 0 */, - const MechanismParam* /* mechanismParam */) + const MechanismParam* /* param = NULL */) { ERROR_MSG("DH does not support verifying"); @@ -95,7 +93,8 @@ bool BotanDH::verifyFinal(const ByteString& /*signature*/) // Encryption functions bool BotanDH::encrypt(PublicKey* /*publicKey*/, const ByteString& /*data*/, - ByteString& /*encryptedData*/, const AsymMech::Type /*padding*/) + ByteString& /*encryptedData*/, const AsymMech::Type /*padding*/, + const MechanismParam* /* param = NULL */) { ERROR_MSG("DH does not support encryption"); @@ -104,7 +103,8 @@ bool BotanDH::encrypt(PublicKey* /*publicKey*/, const ByteString& /*data*/, // Decryption functions bool BotanDH::decrypt(PrivateKey* /*privateKey*/, const ByteString& /*encryptedData*/, - ByteString& /*data*/, const AsymMech::Type /*padding*/) + ByteString& /*data*/, const AsymMech::Type /*padding*/, + const MechanismParam* /* param = NULL */) { ERROR_MSG("DH does not support decryption"); diff --git a/src/lib/crypto/BotanDH.h b/src/lib/crypto/BotanDH.h index 6f4be4409..215209372 100644 --- a/src/lib/crypto/BotanDH.h +++ b/src/lib/crypto/BotanDH.h @@ -44,20 +44,22 @@ class BotanDH : public AsymmetricAlgorithm virtual ~BotanDH() { } // Signing functions - virtual bool signInit(PrivateKey* privateKey, const AsymMech::Type mechanism, const void* param = NULL, const size_t paramLen = 0, const MechanismParam* mechanismParam = NULL); + virtual bool signInit(PrivateKey* privateKey, const AsymMech::Type mechanism, const MechanismParam* mechanismParam = NULL); virtual bool signUpdate(const ByteString& dataToSign); virtual bool signFinal(ByteString& signature); // Verification functions - virtual bool verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, const void* param = NULL, const size_t paramLen = 0, const MechanismParam* mechanismParam = NULL); + virtual bool verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, const MechanismParam* mechanismParam = NULL); virtual bool verifyUpdate(const ByteString& originalData); virtual bool verifyFinal(const ByteString& signature); // Encryption functions - virtual bool encrypt(PublicKey* publicKey, const ByteString& data, ByteString& encryptedData, const AsymMech::Type padding); + virtual bool encrypt(PublicKey* publicKey, const ByteString& data, ByteString& encryptedData, const AsymMech::Type padding, + const MechanismParam* mechanismParam = NULL); // Decryption functions - virtual bool decrypt(PrivateKey* privateKey, const ByteString& encryptedData, ByteString& data, const AsymMech::Type padding); + virtual bool decrypt(PrivateKey* privateKey, const ByteString& encryptedData, ByteString& data, const AsymMech::Type padding, + const MechanismParam* mechanismParam = NULL); // Key factory virtual bool generateKeyPair(AsymmetricKeyPair** ppKeyPair, AsymmetricParameters* parameters, RNG* rng = NULL); diff --git a/src/lib/crypto/BotanDSA.cpp b/src/lib/crypto/BotanDSA.cpp index bc6325c14..b390c2216 100644 --- a/src/lib/crypto/BotanDSA.cpp +++ b/src/lib/crypto/BotanDSA.cpp @@ -61,8 +61,7 @@ BotanDSA::~BotanDSA() // Signing functions bool BotanDSA::sign(PrivateKey* privateKey, const ByteString& dataToSign, ByteString& signature, const AsymMech::Type mechanism, - const void* param /* = NULL */, const size_t paramLen /* = 0 */, - const MechanismParam* /* mechanismParam */) + const MechanismParam* mechanismParam ) { std::string emsa; @@ -73,7 +72,7 @@ bool BotanDSA::sign(PrivateKey* privateKey, const ByteString& dataToSign, else { // Call default implementation - return AsymmetricAlgorithm::sign(privateKey, dataToSign, signature, mechanism, param, paramLen); + return AsymmetricAlgorithm::sign(privateKey, dataToSign, signature, mechanism, mechanismParam); } // Check if the private key is the right type @@ -134,10 +133,9 @@ bool BotanDSA::sign(PrivateKey* privateKey, const ByteString& dataToSign, } bool BotanDSA::signInit(PrivateKey* privateKey, const AsymMech::Type mechanism, - const void* param /* = NULL */, const size_t paramLen /* = 0 */, - const MechanismParam* /* mechanismParam */) + const MechanismParam* mechanismParam /*= NULL */) { - if (!AsymmetricAlgorithm::signInit(privateKey, mechanism, param, paramLen)) + if (!AsymmetricAlgorithm::signInit(privateKey, mechanism, mechanismParam)) { return false; } @@ -280,8 +278,7 @@ bool BotanDSA::signFinal(ByteString& signature) // Verification functions bool BotanDSA::verify(PublicKey* publicKey, const ByteString& originalData, const ByteString& signature, const AsymMech::Type mechanism, - const void* param /* = NULL */, const size_t paramLen /* = 0 */, - const MechanismParam* /* mechanismParam */) + const MechanismParam* mechanismParam) { std::string emsa; @@ -292,7 +289,7 @@ bool BotanDSA::verify(PublicKey* publicKey, const ByteString& originalData, else { // Call the generic function - return AsymmetricAlgorithm::verify(publicKey, originalData, signature, mechanism, param, paramLen); + return AsymmetricAlgorithm::verify(publicKey, originalData, signature, mechanism, mechanismParam); } // Check if the public key is the right type @@ -350,10 +347,9 @@ bool BotanDSA::verify(PublicKey* publicKey, const ByteString& originalData, } bool BotanDSA::verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, - const void* param /* = NULL */, const size_t paramLen /* = 0 */, - const MechanismParam* /* mechanismParam */) + const MechanismParam* mechanismParam /*= NULL */) { - if (!AsymmetricAlgorithm::verifyInit(publicKey, mechanism, param, paramLen)) + if (!AsymmetricAlgorithm::verifyInit(publicKey, mechanism, mechanismParam)) { return false; } @@ -489,7 +485,8 @@ bool BotanDSA::verifyFinal(const ByteString& signature) // Encryption functions bool BotanDSA::encrypt(PublicKey* /*publicKey*/, const ByteString& /*data*/, - ByteString& /*encryptedData*/, const AsymMech::Type /*padding*/) + ByteString& /*encryptedData*/, const AsymMech::Type /*padding*/, + const MechanismParam* /* param = NULL */) { ERROR_MSG("DSA does not support encryption"); @@ -498,7 +495,8 @@ bool BotanDSA::encrypt(PublicKey* /*publicKey*/, const ByteString& /*data*/, // Decryption functions bool BotanDSA::decrypt(PrivateKey* /*privateKey*/, const ByteString& /*encryptedData*/, - ByteString& /*data*/, const AsymMech::Type /*padding*/) + ByteString& /*data*/, const AsymMech::Type /*padding*/, + const MechanismParam* /* param = NULL */) { ERROR_MSG("DSA does not support decryption"); diff --git a/src/lib/crypto/BotanDSA.h b/src/lib/crypto/BotanDSA.h index 245432042..20f17eaea 100644 --- a/src/lib/crypto/BotanDSA.h +++ b/src/lib/crypto/BotanDSA.h @@ -47,22 +47,24 @@ class BotanDSA : public AsymmetricAlgorithm virtual ~BotanDSA(); // Signing functions - virtual bool sign(PrivateKey* privateKey, const ByteString& dataToSign, ByteString& signature, const AsymMech::Type mechanism, const void* param = NULL, const size_t paramLen = 0, const MechanismParam* mechanismParam = NULL); - virtual bool signInit(PrivateKey* privateKey, const AsymMech::Type mechanism, const void* param = NULL, const size_t paramLen = 0, const MechanismParam* mechanismParam = NULL); + virtual bool sign(PrivateKey* privateKey, const ByteString& dataToSign, ByteString& signature, const AsymMech::Type mechanism, const MechanismParam* mechanismParam = NULL); + virtual bool signInit(PrivateKey* privateKey, const AsymMech::Type mechanism, const MechanismParam* mechanismParam = NULL); virtual bool signUpdate(const ByteString& dataToSign); virtual bool signFinal(ByteString& signature); // Verification functions - virtual bool verify(PublicKey* publicKey, const ByteString& originalData, const ByteString& signature, const AsymMech::Type mechanism, const void* param = NULL, const size_t paramLen = 0, const MechanismParam* mechanismParam = NULL); - virtual bool verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, const void* param = NULL, const size_t paramLen = 0, const MechanismParam* mechanismParam = NULL); + virtual bool verify(PublicKey* publicKey, const ByteString& originalData, const ByteString& signature, const AsymMech::Type mechanism, const MechanismParam* mechanismParam = NULL); + virtual bool verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, const MechanismParam* mechanismParam = NULL); virtual bool verifyUpdate(const ByteString& originalData); virtual bool verifyFinal(const ByteString& signature); // Encryption functions - virtual bool encrypt(PublicKey* publicKey, const ByteString& data, ByteString& encryptedData, const AsymMech::Type padding); + virtual bool encrypt(PublicKey* publicKey, const ByteString& data, ByteString& encryptedData, const AsymMech::Type padding, + const MechanismParam* mechanismParam = NULL); // Decryption functions - virtual bool decrypt(PrivateKey* privateKey, const ByteString& encryptedData, ByteString& data, const AsymMech::Type padding); + virtual bool decrypt(PrivateKey* privateKey, const ByteString& encryptedData, ByteString& data, const AsymMech::Type padding, + const MechanismParam* mechanismParam = NULL); // Key factory virtual bool generateKeyPair(AsymmetricKeyPair** ppKeyPair, AsymmetricParameters* parameters, RNG* rng = NULL); diff --git a/src/lib/crypto/BotanECDH.cpp b/src/lib/crypto/BotanECDH.cpp index 1002b010b..c55595002 100644 --- a/src/lib/crypto/BotanECDH.cpp +++ b/src/lib/crypto/BotanECDH.cpp @@ -48,8 +48,7 @@ // Signing functions bool BotanECDH::signInit(PrivateKey* /*privateKey*/, const AsymMech::Type /*mechanism*/, - const void* /* param = NULL */, const size_t /* paramLen = 0 */, - const MechanismParam* /* mechanismParam */) + const MechanismParam* /*mechanismParam = NULL*/) { ERROR_MSG("ECDH does not support signing"); @@ -72,8 +71,7 @@ bool BotanECDH::signFinal(ByteString& /*signature*/) // Verification functions bool BotanECDH::verifyInit(PublicKey* /*publicKey*/, const AsymMech::Type /*mechanism*/, - const void* /* param = NULL */, const size_t /* paramLen = 0 */, - const MechanismParam* /* mechanismParam */) + const MechanismParam* /*mechanismParam = NULL*/) { ERROR_MSG("ECDH does not support verifying"); @@ -96,7 +94,8 @@ bool BotanECDH::verifyFinal(const ByteString& /*signature*/) // Encryption functions bool BotanECDH::encrypt(PublicKey* /*publicKey*/, const ByteString& /*data*/, - ByteString& /*encryptedData*/, const AsymMech::Type /*padding*/) + ByteString& /*encryptedData*/, const AsymMech::Type /*padding*/, + const MechanismParam* /* param = NULL */) { ERROR_MSG("ECDH does not support encryption"); @@ -105,7 +104,8 @@ bool BotanECDH::encrypt(PublicKey* /*publicKey*/, const ByteString& /*data*/, // Decryption functions bool BotanECDH::decrypt(PrivateKey* /*privateKey*/, const ByteString& /*encryptedData*/, - ByteString& /*data*/, const AsymMech::Type /*padding*/) + ByteString& /*data*/, const AsymMech::Type /*padding*/, + const MechanismParam* /* param = NULL */) { ERROR_MSG("ECDH does not support decryption"); diff --git a/src/lib/crypto/BotanECDH.h b/src/lib/crypto/BotanECDH.h index 4f927bb7a..b680fc5bc 100644 --- a/src/lib/crypto/BotanECDH.h +++ b/src/lib/crypto/BotanECDH.h @@ -44,20 +44,22 @@ class BotanECDH : public AsymmetricAlgorithm virtual ~BotanECDH() { } // Signing functions - virtual bool signInit(PrivateKey* privateKey, const AsymMech::Type mechanism, const void* param = NULL, const size_t paramLen = 0, const MechanismParam* mechanismParam = NULL); + virtual bool signInit(PrivateKey* privateKey, const AsymMech::Type mechanism, const MechanismParam* mechanismParam = NULL); virtual bool signUpdate(const ByteString& dataToSign); virtual bool signFinal(ByteString& signature); // Verification functions - virtual bool verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, const void* param = NULL, const size_t paramLen = 0, const MechanismParam* mechanismParam = NULL); + virtual bool verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, const MechanismParam* mechanismParam = NULL); virtual bool verifyUpdate(const ByteString& originalData); virtual bool verifyFinal(const ByteString& signature); // Encryption functions - virtual bool encrypt(PublicKey* publicKey, const ByteString& data, ByteString& encryptedData, const AsymMech::Type padding); + virtual bool encrypt(PublicKey* publicKey, const ByteString& data, ByteString& encryptedData, const AsymMech::Type padding, + const MechanismParam* mechanismParam = NULL); // Decryption functions - virtual bool decrypt(PrivateKey* privateKey, const ByteString& encryptedData, ByteString& data, const AsymMech::Type padding); + virtual bool decrypt(PrivateKey* privateKey, const ByteString& encryptedData, ByteString& data, const AsymMech::Type padding, + const MechanismParam* mechanismParam = NULL); // Key factory virtual bool generateKeyPair(AsymmetricKeyPair** ppKeyPair, AsymmetricParameters* parameters, RNG* rng = NULL); diff --git a/src/lib/crypto/BotanECDSA.cpp b/src/lib/crypto/BotanECDSA.cpp index 5f38e550c..ce2297989 100644 --- a/src/lib/crypto/BotanECDSA.cpp +++ b/src/lib/crypto/BotanECDSA.cpp @@ -63,7 +63,6 @@ BotanECDSA::~BotanECDSA() // Signing functions bool BotanECDSA::sign(PrivateKey* privateKey, const ByteString& dataToSign, ByteString& signature, const AsymMech::Type mechanism, - const void* /* param = NULL */, const size_t /* paramLen = 0 */, const MechanismParam* /* mechanismParam */) { std::string emsa = "Raw"; @@ -171,8 +170,7 @@ bool BotanECDSA::sign(PrivateKey* privateKey, const ByteString& dataToSign, // Signing functions bool BotanECDSA::signInit(PrivateKey* /*privateKey*/, const AsymMech::Type /*mechanism*/, - const void* /* param = NULL */, const size_t /* paramLen = 0 */, - const MechanismParam* /* mechanismParam */) + const MechanismParam* /*mecahnismParam = NULL*/) { ERROR_MSG("ECDSA does not support multi part signing"); @@ -196,7 +194,6 @@ bool BotanECDSA::signFinal(ByteString& /*signature*/) // Verification functions bool BotanECDSA::verify(PublicKey* publicKey, const ByteString& originalData, const ByteString& signature, const AsymMech::Type mechanism, - const void* /* param = NULL */, const size_t /* paramLen = 0 */, const MechanismParam* /* mechanismParam */) { std::string emsa = "Raw"; @@ -301,8 +298,7 @@ bool BotanECDSA::verify(PublicKey* publicKey, const ByteString& originalData, // Verification functions bool BotanECDSA::verifyInit(PublicKey* /*publicKey*/, const AsymMech::Type /*mechanism*/, - const void* /* param = NULL */, const size_t /* paramLen = 0 */, - const MechanismParam* /* mechanismParam */) + const MechanismParam* /*mecahnismParam = NULL*/) { ERROR_MSG("ECDSA does not support multi part verifying"); @@ -325,7 +321,8 @@ bool BotanECDSA::verifyFinal(const ByteString& /*signature*/) // Encryption functions bool BotanECDSA::encrypt(PublicKey* /*publicKey*/, const ByteString& /*data*/, - ByteString& /*encryptedData*/, const AsymMech::Type /*padding*/) + ByteString& /*encryptedData*/, const AsymMech::Type /*padding*/, + const MechanismParam* /* param = NULL */) { ERROR_MSG("ECDSA does not support encryption"); @@ -334,7 +331,8 @@ bool BotanECDSA::encrypt(PublicKey* /*publicKey*/, const ByteString& /*data*/, // Decryption functions bool BotanECDSA::decrypt(PrivateKey* /*privateKey*/, const ByteString& /*encryptedData*/, - ByteString& /*data*/, const AsymMech::Type /*padding*/) + ByteString& /*data*/, const AsymMech::Type /*padding*/, + const MechanismParam* /* param = NULL */) { ERROR_MSG("ECDSA does not support decryption"); diff --git a/src/lib/crypto/BotanECDSA.h b/src/lib/crypto/BotanECDSA.h index a8dd425a5..33f08c551 100644 --- a/src/lib/crypto/BotanECDSA.h +++ b/src/lib/crypto/BotanECDSA.h @@ -47,22 +47,24 @@ class BotanECDSA : public AsymmetricAlgorithm virtual ~BotanECDSA(); // Signing functions - virtual bool sign(PrivateKey* privateKey, const ByteString& dataToSign, ByteString& signature, const AsymMech::Type mechanism, const void* param = NULL, const size_t paramLen = 0, const MechanismParam* mechanismParam = NULL); - virtual bool signInit(PrivateKey* privateKey, const AsymMech::Type mechanism, const void* param = NULL, const size_t paramLen = 0, const MechanismParam* mechanismParam = NULL); + virtual bool sign(PrivateKey* privateKey, const ByteString& dataToSign, ByteString& signature, const AsymMech::Type mechanism, const MechanismParam* mechanismParam = NULL); + virtual bool signInit(PrivateKey* privateKey, const AsymMech::Type mechanism, const MechanismParam* mechanismParam = NULL); virtual bool signUpdate(const ByteString& dataToSign); virtual bool signFinal(ByteString& signature); // Verification functions - virtual bool verify(PublicKey* publicKey, const ByteString& originalData, const ByteString& signature, const AsymMech::Type mechanism, const void* param = NULL, const size_t paramLen = 0, const MechanismParam* mechanismParam = NULL); - virtual bool verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, const void* param = NULL, const size_t paramLen = 0, const MechanismParam* mechanismParam = NULL); + virtual bool verify(PublicKey* publicKey, const ByteString& originalData, const ByteString& signature, const AsymMech::Type mechanism, const MechanismParam* mechanismParam = NULL); + virtual bool verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, const MechanismParam* mechanismParam = NULL); virtual bool verifyUpdate(const ByteString& originalData); virtual bool verifyFinal(const ByteString& signature); // Encryption functions - virtual bool encrypt(PublicKey* publicKey, const ByteString& data, ByteString& encryptedData, const AsymMech::Type padding); + virtual bool encrypt(PublicKey* publicKey, const ByteString& data, ByteString& encryptedData, const AsymMech::Type padding, + const MechanismParam* mechanismParam = NULL); // Decryption functions - virtual bool decrypt(PrivateKey* privateKey, const ByteString& encryptedData, ByteString& data, const AsymMech::Type padding); + virtual bool decrypt(PrivateKey* privateKey, const ByteString& encryptedData, ByteString& data, const AsymMech::Type padding, + const MechanismParam* mechanismParam = NULL); // Key factory virtual bool generateKeyPair(AsymmetricKeyPair** ppKeyPair, AsymmetricParameters* parameters, RNG* rng = NULL); diff --git a/src/lib/crypto/BotanEDDSA.cpp b/src/lib/crypto/BotanEDDSA.cpp index 663bea9c5..f10a07877 100644 --- a/src/lib/crypto/BotanEDDSA.cpp +++ b/src/lib/crypto/BotanEDDSA.cpp @@ -65,7 +65,6 @@ BotanEDDSA::~BotanEDDSA() // Signing functions bool BotanEDDSA::sign(PrivateKey* privateKey, const ByteString& dataToSign, ByteString& signature, const AsymMech::Type mechanism, - const void* /* param = NULL */, const size_t /* paramLen = 0 */, const MechanismParam* /* mechanismParam */) { std::string emsa; @@ -139,8 +138,7 @@ bool BotanEDDSA::sign(PrivateKey* privateKey, const ByteString& dataToSign, // Signing functions bool BotanEDDSA::signInit(PrivateKey* /*privateKey*/, const AsymMech::Type /*mechanism*/, - const void* /* param = NULL */, const size_t /* paramLen = 0 */, - const MechanismParam* /* mechanismParam */) + const MechanismParam* /* mechanismParam */) { ERROR_MSG("EDDSA does not support multi part signing"); @@ -164,7 +162,6 @@ bool BotanEDDSA::signFinal(ByteString& /*signature*/) // Verification functions bool BotanEDDSA::verify(PublicKey* publicKey, const ByteString& originalData, const ByteString& signature, const AsymMech::Type mechanism, - const void* /* param = NULL */, const size_t /* paramLen = 0 */, const MechanismParam* /* mechanismParam */) { std::string emsa; @@ -236,8 +233,7 @@ bool BotanEDDSA::verify(PublicKey* publicKey, const ByteString& originalData, // Verification functions bool BotanEDDSA::verifyInit(PublicKey* /*publicKey*/, const AsymMech::Type /*mechanism*/, - const void* /* param = NULL */, const size_t /* paramLen = 0 */, - const MechanismParam* /* mechanismParam */) + const MechanismParam* /* mechanismParam */) { ERROR_MSG("EDDSA does not support multi part verifying"); @@ -260,7 +256,8 @@ bool BotanEDDSA::verifyFinal(const ByteString& /*signature*/) // Encryption functions bool BotanEDDSA::encrypt(PublicKey* /*publicKey*/, const ByteString& /*data*/, - ByteString& /*encryptedData*/, const AsymMech::Type /*padding*/) + ByteString& /*encryptedData*/, const AsymMech::Type /*padding*/, + const MechanismParam* /* param = NULL */) { ERROR_MSG("EDDSA does not support encryption"); @@ -269,7 +266,8 @@ bool BotanEDDSA::encrypt(PublicKey* /*publicKey*/, const ByteString& /*data*/, // Decryption functions bool BotanEDDSA::decrypt(PrivateKey* /*privateKey*/, const ByteString& /*encryptedData*/, - ByteString& /*data*/, const AsymMech::Type /*padding*/) + ByteString& /*data*/, const AsymMech::Type /*padding*/, + const MechanismParam* /* param = NULL */) { ERROR_MSG("EDDSA does not support decryption"); diff --git a/src/lib/crypto/BotanEDDSA.h b/src/lib/crypto/BotanEDDSA.h index 8f52c0453..de7af0c7f 100644 --- a/src/lib/crypto/BotanEDDSA.h +++ b/src/lib/crypto/BotanEDDSA.h @@ -47,22 +47,24 @@ class BotanEDDSA : public AsymmetricAlgorithm virtual ~BotanEDDSA(); // Signing functions - virtual bool sign(PrivateKey* privateKey, const ByteString& dataToSign, ByteString& signature, const AsymMech::Type mechanism, const void* param = NULL, const size_t paramLen = 0, const MechanismParam* mechanismParam = NULL); - virtual bool signInit(PrivateKey* privateKey, const AsymMech::Type mechanism, const void* param = NULL, const size_t paramLen = 0, const MechanismParam* mechanismParam = NULL); + virtual bool sign(PrivateKey* privateKey, const ByteString& dataToSign, ByteString& signature, const AsymMech::Type mechanism, const MechanismParam* mechanismParam = NULL); + virtual bool signInit(PrivateKey* privateKey, const AsymMech::Type mechanism, const MechanismParam* mechanismParam = NULL); virtual bool signUpdate(const ByteString& dataToSign); virtual bool signFinal(ByteString& signature); // Verification functions - virtual bool verify(PublicKey* publicKey, const ByteString& originalData, const ByteString& signature, const AsymMech::Type mechanism, const void* param = NULL, const size_t paramLen = 0, const MechanismParam* mechanismParam = NULL); - virtual bool verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, const void* param = NULL, const size_t paramLen = 0, const MechanismParam* mechanismParam = NULL); + virtual bool verify(PublicKey* publicKey, const ByteString& originalData, const ByteString& signature, const AsymMech::Type mechanism, const MechanismParam* mechanismParam = NULL); + virtual bool verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, const MechanismParam* mechanismParam = NULL); virtual bool verifyUpdate(const ByteString& originalData); virtual bool verifyFinal(const ByteString& signature); // Encryption functions - virtual bool encrypt(PublicKey* publicKey, const ByteString& data, ByteString& encryptedData, const AsymMech::Type padding); + virtual bool encrypt(PublicKey* publicKey, const ByteString& data, ByteString& encryptedData, const AsymMech::Type padding, + const MechanismParam* mechanismParam = NULL); // Decryption functions - virtual bool decrypt(PrivateKey* privateKey, const ByteString& encryptedData, ByteString& data, const AsymMech::Type padding); + virtual bool decrypt(PrivateKey* privateKey, const ByteString& encryptedData, ByteString& data, const AsymMech::Type padding, + const MechanismParam* mechanismParam = NULL); // Key factory virtual bool generateKeyPair(AsymmetricKeyPair** ppKeyPair, AsymmetricParameters* parameters, RNG* rng = NULL); diff --git a/src/lib/crypto/BotanGOST.cpp b/src/lib/crypto/BotanGOST.cpp index 62715a421..aa08671ec 100644 --- a/src/lib/crypto/BotanGOST.cpp +++ b/src/lib/crypto/BotanGOST.cpp @@ -62,10 +62,9 @@ BotanGOST::~BotanGOST() // Signing functions bool BotanGOST::signInit(PrivateKey* privateKey, const AsymMech::Type mechanism, - const void* param /* = NULL */, const size_t paramLen /* = 0 */, - const MechanismParam* /* mechanismParam */) + const MechanismParam* mechanismParam /* = NULL */) { - if (!AsymmetricAlgorithm::signInit(privateKey, mechanism, param, paramLen)) + if (!AsymmetricAlgorithm::signInit(privateKey, mechanism, mechanismParam)) { return false; } @@ -198,10 +197,9 @@ bool BotanGOST::signFinal(ByteString& signature) // Verification functions bool BotanGOST::verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, - const void* param /* = NULL */, const size_t paramLen /* = 0 */, - const MechanismParam* /* mechanismParam */) + const MechanismParam* mechanismParam /* = NULL */) { - if (!AsymmetricAlgorithm::verifyInit(publicKey, mechanism, param, paramLen)) + if (!AsymmetricAlgorithm::verifyInit(publicKey, mechanism, mechanismParam)) { return false; } @@ -328,7 +326,8 @@ bool BotanGOST::verifyFinal(const ByteString& signature) // Encryption functions bool BotanGOST::encrypt(PublicKey* /*publicKey*/, const ByteString& /*data*/, - ByteString& /*encryptedData*/, const AsymMech::Type /*padding*/) + ByteString& /*encryptedData*/, const AsymMech::Type /*padding*/, + const MechanismParam* /* param = NULL */) { ERROR_MSG("GOST does not support encryption"); @@ -337,7 +336,8 @@ bool BotanGOST::encrypt(PublicKey* /*publicKey*/, const ByteString& /*data*/, // Decryption functions bool BotanGOST::decrypt(PrivateKey* /*privateKey*/, const ByteString& /*encryptedData*/, - ByteString& /*data*/, const AsymMech::Type /*padding*/) + ByteString& /*data*/, const AsymMech::Type /*padding*/, + const MechanismParam* /* param = NULL */) { ERROR_MSG("GOST does not support decryption"); diff --git a/src/lib/crypto/BotanGOST.h b/src/lib/crypto/BotanGOST.h index 0dc98022d..b939f930e 100644 --- a/src/lib/crypto/BotanGOST.h +++ b/src/lib/crypto/BotanGOST.h @@ -47,20 +47,22 @@ class BotanGOST : public AsymmetricAlgorithm virtual ~BotanGOST(); // Signing functions - virtual bool signInit(PrivateKey* privateKey, const AsymMech::Type mechanism, const void* param = NULL, const size_t paramLen = 0, const MechanismParam* mechanismParam = NULL); + virtual bool signInit(PrivateKey* privateKey, const AsymMech::Type mechanism, const MechanismParam* mechanismParam = NULL); virtual bool signUpdate(const ByteString& dataToSign); virtual bool signFinal(ByteString& signature); // Verification functions - virtual bool verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, const void* param = NULL, const size_t paramLen = 0, const MechanismParam* mechanismParam = NULL); + virtual bool verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, const MechanismParam* mechanismParam = NULL); virtual bool verifyUpdate(const ByteString& originalData); virtual bool verifyFinal(const ByteString& signature); // Encryption functions - virtual bool encrypt(PublicKey* publicKey, const ByteString& data, ByteString& encryptedData, const AsymMech::Type padding); + virtual bool encrypt(PublicKey* publicKey, const ByteString& data, ByteString& encryptedData, const AsymMech::Type padding, + const MechanismParam* mechanismParam = NULL); // Decryption functions - virtual bool decrypt(PrivateKey* privateKey, const ByteString& encryptedData, ByteString& data, const AsymMech::Type padding); + virtual bool decrypt(PrivateKey* privateKey, const ByteString& encryptedData, ByteString& data, const AsymMech::Type padding, + const MechanismParam* mechanismParam = NULL); // Key factory virtual bool generateKeyPair(AsymmetricKeyPair** ppKeyPair, AsymmetricParameters* parameters, RNG* rng = NULL); diff --git a/src/lib/crypto/BotanRSA.cpp b/src/lib/crypto/BotanRSA.cpp index d161bf87a..48607990b 100644 --- a/src/lib/crypto/BotanRSA.cpp +++ b/src/lib/crypto/BotanRSA.cpp @@ -37,6 +37,7 @@ #include "CryptoFactory.h" #include "BotanCryptoFactory.h" #include "RSAParameters.h" +#include "RSAMechanismParam.h" #include "BotanRSAKeyPair.h" #include #include @@ -60,8 +61,7 @@ BotanRSA::~BotanRSA() // Signing functions bool BotanRSA::sign(PrivateKey* privateKey, const ByteString& dataToSign, ByteString& signature, const AsymMech::Type mechanism, - const void* param /* = NULL */, const size_t paramLen /* = 0 */, - const MechanismParam* /* mechanismParam */) + const MechanismParam* mechanismParam /* = NULL */) { std::string emsa = ""; @@ -75,7 +75,7 @@ bool BotanRSA::sign(PrivateKey* privateKey, const ByteString& dataToSign, break; #ifdef WITH_RAW_PSS case AsymMech::RSA_PKCS_PSS: - emsa = getCipherRawPss(privateKey->getBitLength(), dataToSign.size(), param, paramLen); + emsa = getCipherRawPss(privateKey->getBitLength(), dataToSign.size(), mechanismParam); if (emsa == "") { return false; @@ -84,7 +84,7 @@ bool BotanRSA::sign(PrivateKey* privateKey, const ByteString& dataToSign, #endif default: // Call default implementation - return AsymmetricAlgorithm::sign(privateKey, dataToSign, signature, mechanism, param, paramLen); + return AsymmetricAlgorithm::sign(privateKey, dataToSign, signature, mechanism, mechanismParam); } // Check if the private key is the right type @@ -145,10 +145,9 @@ bool BotanRSA::sign(PrivateKey* privateKey, const ByteString& dataToSign, } bool BotanRSA::signInit(PrivateKey* privateKey, const AsymMech::Type mechanism, - const void* param /* = NULL */, const size_t paramLen /* = 0 */, - const MechanismParam* /* mechanismParam */) + const MechanismParam* mechanismParam /*= NULL */) { - if (!AsymmetricAlgorithm::signInit(privateKey, mechanism, param, paramLen)) + if (!AsymmetricAlgorithm::signInit(privateKey, mechanism, mechanismParam)) { return false; } @@ -167,6 +166,7 @@ bool BotanRSA::signInit(PrivateKey* privateKey, const AsymMech::Type mechanism, std::string emsa; std::ostringstream request; size_t sLen; + const RSAPssMechanismParam* pssParam = NULL; switch (mechanism) { @@ -189,16 +189,23 @@ bool BotanRSA::signInit(PrivateKey* privateKey, const AsymMech::Type mechanism, emsa = "EMSA3(SHA-512)"; break; case AsymMech::RSA_SHA1_PKCS_PSS: - if (param == NULL || paramLen != sizeof(RSA_PKCS_PSS_PARAMS) || - ((RSA_PKCS_PSS_PARAMS*) param)->hashAlg != HashAlgo::SHA1 || - ((RSA_PKCS_PSS_PARAMS*) param)->mgf != AsymRSAMGF::MGF1_SHA1) + if ((mechanismParam == NULL) || (!mechanismParam->isOfType(RSAPssMechanismParam::type))) { - ERROR_MSG("Invalid parameters"); + ERROR_MSG("Invalid RSA PSS mechanism parameter type supplied"); ByteString dummy; AsymmetricAlgorithm::signFinal(dummy); return false; } - sLen = ((RSA_PKCS_PSS_PARAMS*) param)->sLen; + 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)", @@ -211,16 +218,23 @@ bool BotanRSA::signInit(PrivateKey* privateKey, const AsymMech::Type mechanism, emsa = request.str(); break; case AsymMech::RSA_SHA224_PKCS_PSS: - if (param == NULL || paramLen != sizeof(RSA_PKCS_PSS_PARAMS) || - ((RSA_PKCS_PSS_PARAMS*) param)->hashAlg != HashAlgo::SHA224 || - ((RSA_PKCS_PSS_PARAMS*) param)->mgf != AsymRSAMGF::MGF1_SHA224) + if ((mechanismParam == NULL) || (!mechanismParam->isOfType(RSAPssMechanismParam::type))) { - ERROR_MSG("Invalid parameters"); + ERROR_MSG("Invalid RSA PSS mechanism parameter type supplied"); ByteString dummy; AsymmetricAlgorithm::signFinal(dummy); return false; } - sLen = ((RSA_PKCS_PSS_PARAMS*) param)->sLen; + 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)", @@ -233,16 +247,23 @@ bool BotanRSA::signInit(PrivateKey* privateKey, const AsymMech::Type mechanism, emsa = request.str(); break; case AsymMech::RSA_SHA256_PKCS_PSS: - if (param == NULL || paramLen != sizeof(RSA_PKCS_PSS_PARAMS) || - ((RSA_PKCS_PSS_PARAMS*) param)->hashAlg != HashAlgo::SHA256 || - ((RSA_PKCS_PSS_PARAMS*) param)->mgf != AsymRSAMGF::MGF1_SHA256) + 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 parameters"); + ERROR_MSG("Invalid RSA PSS mechanism parameters supplied"); ByteString dummy; AsymmetricAlgorithm::signFinal(dummy); return false; } - sLen = ((RSA_PKCS_PSS_PARAMS*) param)->sLen; + sLen = pssParam->sLen; if (sLen > ((privateKey->getBitLength()+6)/8-2-32)) { ERROR_MSG("sLen (%lu) is too large for current key size (%lu)", @@ -255,16 +276,23 @@ bool BotanRSA::signInit(PrivateKey* privateKey, const AsymMech::Type mechanism, emsa = request.str(); break; case AsymMech::RSA_SHA384_PKCS_PSS: - if (param == NULL || paramLen != sizeof(RSA_PKCS_PSS_PARAMS) || - ((RSA_PKCS_PSS_PARAMS*) param)->hashAlg != HashAlgo::SHA384 || - ((RSA_PKCS_PSS_PARAMS*) param)->mgf != AsymRSAMGF::MGF1_SHA384) + if ((mechanismParam == NULL) || (!mechanismParam->isOfType(RSAPssMechanismParam::type))) { - ERROR_MSG("Invalid parameters"); + ERROR_MSG("Invalid RSA PSS mechanism parameter type supplied"); ByteString dummy; AsymmetricAlgorithm::signFinal(dummy); return false; } - sLen = ((RSA_PKCS_PSS_PARAMS*) param)->sLen; + 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)", @@ -277,16 +305,23 @@ bool BotanRSA::signInit(PrivateKey* privateKey, const AsymMech::Type mechanism, emsa = request.str(); break; case AsymMech::RSA_SHA512_PKCS_PSS: - if (param == NULL || paramLen != sizeof(RSA_PKCS_PSS_PARAMS) || - ((RSA_PKCS_PSS_PARAMS*) param)->hashAlg != HashAlgo::SHA512 || - ((RSA_PKCS_PSS_PARAMS*) param)->mgf != AsymRSAMGF::MGF1_SHA512) + 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 parameters"); + ERROR_MSG("Invalid RSA PSS mechanism parameters supplied"); ByteString dummy; AsymmetricAlgorithm::signFinal(dummy); return false; } - sLen = ((RSA_PKCS_PSS_PARAMS*) param)->sLen; + sLen = pssParam->sLen; if (sLen > ((privateKey->getBitLength()+6)/8-2-64)) { ERROR_MSG("sLen (%lu) is too large for current key size (%lu)", @@ -409,8 +444,7 @@ bool BotanRSA::signFinal(ByteString& signature) // Verification functions bool BotanRSA::verify(PublicKey* publicKey, const ByteString& originalData, const ByteString& signature, const AsymMech::Type mechanism, - const void* param /* = NULL */, const size_t paramLen /* = 0 */, - const MechanismParam* /* mechanismParam */) + const MechanismParam* mechanismParam /* = NULL */) { std::string emsa = ""; @@ -424,7 +458,7 @@ bool BotanRSA::verify(PublicKey* publicKey, const ByteString& originalData, break; #ifdef WITH_RAW_PSS case AsymMech::RSA_PKCS_PSS: - emsa = getCipherRawPss(publicKey->getBitLength(), originalData.size(), param, paramLen); + emsa = getCipherRawPss(publicKey->getBitLength(), originalData.size(), mechanismParam); if (emsa == "") { return false; @@ -433,7 +467,7 @@ bool BotanRSA::verify(PublicKey* publicKey, const ByteString& originalData, #endif default: // Call the generic function - return AsymmetricAlgorithm::verify(publicKey, originalData, signature, mechanism, param, paramLen); + return AsymmetricAlgorithm::verify(publicKey, originalData, signature, mechanism, mechanismParam); } // Check if the public key is the right type @@ -491,10 +525,9 @@ bool BotanRSA::verify(PublicKey* publicKey, const ByteString& originalData, } bool BotanRSA::verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, - const void* param /* = NULL */, const size_t paramLen /* = 0 */, - const MechanismParam* /* mechanismParam */) + const MechanismParam* mechanismParam) { - if (!AsymmetricAlgorithm::verifyInit(publicKey, mechanism, param, paramLen)) + if (!AsymmetricAlgorithm::verifyInit(publicKey, mechanism, mechanismParam)) { return false; } @@ -513,6 +546,7 @@ bool BotanRSA::verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, std::string emsa; std::ostringstream request; size_t sLen; + const RSAPssMechanismParam* pssParam = NULL; switch (mechanism) { @@ -535,16 +569,23 @@ bool BotanRSA::verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, emsa = "EMSA3(SHA-512)"; break; case AsymMech::RSA_SHA1_PKCS_PSS: - if (param == NULL || paramLen != sizeof(RSA_PKCS_PSS_PARAMS) || - ((RSA_PKCS_PSS_PARAMS*) param)->hashAlg != HashAlgo::SHA1 || - ((RSA_PKCS_PSS_PARAMS*) param)->mgf != AsymRSAMGF::MGF1_SHA1) + if ((mechanismParam == NULL) || (!mechanismParam->isOfType(RSAPssMechanismParam::type))) { - ERROR_MSG("Invalid parameters"); + ERROR_MSG("Invalid RSA PSS mechanism parameter type supplied"); ByteString dummy; AsymmetricAlgorithm::verifyFinal(dummy); return false; } - sLen = ((RSA_PKCS_PSS_PARAMS*) param)->sLen; + 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)", @@ -557,16 +598,23 @@ bool BotanRSA::verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, emsa = request.str(); break; case AsymMech::RSA_SHA224_PKCS_PSS: - if (param == NULL || paramLen != sizeof(RSA_PKCS_PSS_PARAMS) || - ((RSA_PKCS_PSS_PARAMS*) param)->hashAlg != HashAlgo::SHA224 || - ((RSA_PKCS_PSS_PARAMS*) param)->mgf != AsymRSAMGF::MGF1_SHA224) + if ((mechanismParam == NULL) || (!mechanismParam->isOfType(RSAPssMechanismParam::type))) { - ERROR_MSG("Invalid parameters"); + ERROR_MSG("Invalid RSA PSS mechanism parameter type supplied"); ByteString dummy; AsymmetricAlgorithm::verifyFinal(dummy); return false; } - sLen = ((RSA_PKCS_PSS_PARAMS*) param)->sLen; + pssParam = dynamic_cast(mechanismParam); + if ((pssParam->hashAlg != HashAlgo::SHA224)|| + (pssParam->mgfAlg != AsymRSAMGF::MGF1_SHA224)) + { + ERROR_MSG("Invalid RSA PSS mechanism parameters supplied"); + ByteString dummy; + AsymmetricAlgorithm::verifyFinal(dummy); + return false; + } + sLen = pssParam->sLen; if (sLen > ((publicKey->getBitLength()+6)/8-2-28)) { ERROR_MSG("sLen (%lu) is too large for current key size (%lu)", @@ -579,16 +627,23 @@ bool BotanRSA::verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, emsa = request.str(); break; case AsymMech::RSA_SHA256_PKCS_PSS: - if (param == NULL || paramLen != sizeof(RSA_PKCS_PSS_PARAMS) || - ((RSA_PKCS_PSS_PARAMS*) param)->hashAlg != HashAlgo::SHA256 || - ((RSA_PKCS_PSS_PARAMS*) param)->mgf != AsymRSAMGF::MGF1_SHA256) + 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 parameters"); + ERROR_MSG("Invalid RSA PSS mechanism parameters supplied"); ByteString dummy; AsymmetricAlgorithm::verifyFinal(dummy); return false; } - sLen = ((RSA_PKCS_PSS_PARAMS*) param)->sLen; + sLen = pssParam->sLen; if (sLen > ((publicKey->getBitLength()+6)/8-2-32)) { ERROR_MSG("sLen (%lu) is too large for current key size (%lu)", @@ -601,16 +656,23 @@ bool BotanRSA::verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, emsa = request.str(); break; case AsymMech::RSA_SHA384_PKCS_PSS: - if (param == NULL || paramLen != sizeof(RSA_PKCS_PSS_PARAMS) || - ((RSA_PKCS_PSS_PARAMS*) param)->hashAlg != HashAlgo::SHA384 || - ((RSA_PKCS_PSS_PARAMS*) param)->mgf != AsymRSAMGF::MGF1_SHA384) + 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::SHA384)|| + (pssParam->mgfAlg != AsymRSAMGF::MGF1_SHA384)) { - ERROR_MSG("Invalid parameters"); + ERROR_MSG("Invalid RSA PSS mechanism parameters supplied"); ByteString dummy; AsymmetricAlgorithm::verifyFinal(dummy); return false; } - sLen = ((RSA_PKCS_PSS_PARAMS*) param)->sLen; + sLen = pssParam->sLen; if (sLen > ((publicKey->getBitLength()+6)/8-2-48)) { ERROR_MSG("sLen (%lu) is too large for current key size (%lu)", @@ -623,16 +685,23 @@ bool BotanRSA::verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, emsa = request.str(); break; case AsymMech::RSA_SHA512_PKCS_PSS: - if (param == NULL || paramLen != sizeof(RSA_PKCS_PSS_PARAMS) || - ((RSA_PKCS_PSS_PARAMS*) param)->hashAlg != HashAlgo::SHA512 || - ((RSA_PKCS_PSS_PARAMS*) param)->mgf != AsymRSAMGF::MGF1_SHA512) + 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::SHA512)|| + (pssParam->mgfAlg != AsymRSAMGF::MGF1_SHA512)) { - ERROR_MSG("Invalid parameters"); + ERROR_MSG("Invalid RSA PSS mechanism parameters supplied"); ByteString dummy; AsymmetricAlgorithm::verifyFinal(dummy); return false; } - sLen = ((RSA_PKCS_PSS_PARAMS*) param)->sLen; + sLen = pssParam->sLen; if (sLen > ((publicKey->getBitLength()+6)/8-2-64)) { ERROR_MSG("sLen (%lu) is too large for current key size (%lu)", @@ -748,7 +817,8 @@ bool BotanRSA::verifyFinal(const ByteString& signature) // Encryption functions bool BotanRSA::encrypt(PublicKey* publicKey, const ByteString& data, - ByteString& encryptedData, const AsymMech::Type padding) + ByteString& encryptedData, const AsymMech::Type padding, + const MechanismParam* mechanismParam) { // Check if the public key is the right type if (!publicKey->isOfType(BotanRSAPublicKey::type)) @@ -766,7 +836,7 @@ bool BotanRSA::encrypt(PublicKey* publicKey, const ByteString& data, eme = "PKCS1v15"; break; case AsymMech::RSA_PKCS_OAEP: - eme = "EME1(SHA-160)"; + // eme will be set later break; case AsymMech::RSA: eme = "Raw"; @@ -779,14 +849,19 @@ bool BotanRSA::encrypt(PublicKey* publicKey, const ByteString& data, BotanRSAPublicKey* pk = (BotanRSAPublicKey*) publicKey; Botan::RSA_PublicKey* botanKey = pk->getBotanKey(); - + if (!botanKey) { ERROR_MSG("Could not get the Botan public key"); return false; } - + if (padding == AsymMech::RSA_PKCS_OAEP) + { + eme = getCipherOaep(publicKey->getBitLength(), data.size(), mechanismParam); + if (eme.empty()) + return false; + } Botan::PK_Encryptor_EME* encryptor = NULL; try { @@ -796,7 +871,6 @@ bool BotanRSA::encrypt(PublicKey* publicKey, const ByteString& data, catch (...) { ERROR_MSG("Could not create the encryptor token"); - return false; } @@ -827,7 +901,8 @@ bool BotanRSA::encrypt(PublicKey* publicKey, const ByteString& data, // Decryption functions bool BotanRSA::decrypt(PrivateKey* privateKey, const ByteString& encryptedData, - ByteString& data, const AsymMech::Type padding) + ByteString& data, const AsymMech::Type padding, + const MechanismParam* mechanismParam) { // Check if the private key is the right type if (!privateKey->isOfType(BotanRSAPrivateKey::type)) @@ -845,7 +920,7 @@ bool BotanRSA::decrypt(PrivateKey* privateKey, const ByteString& encryptedData, eme = "PKCS1v15"; break; case AsymMech::RSA_PKCS_OAEP: - eme = "EME1(SHA-160)"; + // eme will be set later break; case AsymMech::RSA: eme = "Raw"; @@ -866,6 +941,13 @@ bool BotanRSA::decrypt(PrivateKey* privateKey, const ByteString& encryptedData, return false; } + if (padding == AsymMech::RSA_PKCS_OAEP) + { + eme = getCipherOaep(privateKey->getBitLength(), 0 ,mechanismParam); + if (eme.empty()) + return false; + } + Botan::PK_Decryptor_EME* decryptor = NULL; try { @@ -898,8 +980,8 @@ bool BotanRSA::decrypt(PrivateKey* privateKey, const ByteString& encryptedData, if (padding == AsymMech::RSA) { // We compensate that Botan removes leading zeros - int modSize = pk->getN().size(); - int decSize = decResult.size(); + size_t modSize = pk->getN().size(); + size_t decSize = decResult.size(); data.resize(modSize); memcpy(&data[0] + modSize - decSize, decResult.data(), decSize); } @@ -1111,17 +1193,25 @@ bool BotanRSA::reconstructParameters(AsymmetricParameters** ppParams, ByteString } #ifdef WITH_RAW_PSS -std::string BotanRSA::getCipherRawPss(size_t bitLength, size_t dataSize, const void* param, const size_t paramLen) +std::string BotanRSA::getCipherRawPss(size_t bitLength, size_t dataSize, const MechanismParam* mechanismParam) { - if (param == NULL || paramLen != sizeof(RSA_PKCS_PSS_PARAMS)) + if (mechanismParam == NULL) + { + ERROR_MSG("RSA PSS mechanism parameter not supplied"); + + return ""; + } + if (!mechanismParam->isOfType(RSAPssMechanismParam::type)) { - ERROR_MSG("Invalid parameters"); + ERROR_MSG("Invalid RSA PSS mechanism parameter type supplied"); + return ""; } std::string hashStr = ""; size_t allowedLen = 0; - switch (((RSA_PKCS_PSS_PARAMS*) param)->hashAlg) + const RSAPssMechanismParam* rsaPssMecahnismParam = dynamic_cast(mechanismParam); + switch (rsaPssMecahnismParam->hashAlg) { case HashAlgo::SHA1: hashStr = "SHA-160"; @@ -1154,7 +1244,7 @@ std::string BotanRSA::getCipherRawPss(size_t bitLength, size_t dataSize, const v return ""; } - size_t sLen = ((RSA_PKCS_PSS_PARAMS*) param)->sLen; + size_t sLen = rsaPssMecahnismParam->sLen; if (sLen > ((bitLength+6)/8-2-20)) { ERROR_MSG("sLen (%lu) is too large for current key size (%lu)", @@ -1167,3 +1257,87 @@ std::string BotanRSA::getCipherRawPss(size_t bitLength, size_t dataSize, const v return request.str(); } #endif + +std::string BotanRSA::getCipherOaep(size_t bitLength, size_t dataSize, const MechanismParam* mechanismParam) +{ + if (mechanismParam == NULL) + { + ERROR_MSG("RSA OAEP mechanism parameter not supplied"); + + return ""; + } + if (!mechanismParam->isOfType(RSAOaepMechanismParam::type)) + { + ERROR_MSG("Invalid RSA OAEP mechanism parameter type supplied"); + + return ""; + } + std::string hashStr = ""; + std::string mgfStr = ""; + size_t hashLen = 0; + const RSAOaepMechanismParam* rsaOaepMecahnismParam = dynamic_cast(mechanismParam); + switch (rsaOaepMecahnismParam->hashAlg) + { + case HashAlgo::SHA1: + hashStr = "SHA-160"; + hashLen = 20; + break; + case HashAlgo::SHA224: + hashStr = "SHA-224"; + hashLen = 28; + break; + case HashAlgo::SHA256: + hashStr = "SHA-256"; + hashLen = 32; + break; + case HashAlgo::SHA384: + hashStr = "SHA-384"; + hashLen = 48; + break; + case HashAlgo::SHA512: + hashStr = "SHA-512"; + hashLen = 64; + break; + default: + ERROR_MSG("Invalid hash parameter"); + return ""; + } + switch (rsaOaepMecahnismParam->mgfAlg) + { + case AsymRSAMGF::MGF1_SHA1: + mgfStr = "SHA-160"; + break; + case AsymRSAMGF::MGF1_SHA224: + mgfStr = "SHA-224"; + break; + case AsymRSAMGF::MGF1_SHA256: + mgfStr = "SHA-256"; + break; + case AsymRSAMGF::MGF1_SHA384: + mgfStr = "SHA-384"; + break; + case AsymRSAMGF::MGF1_SHA512: + mgfStr = "SHA-512"; + break; + default: + ERROR_MSG("Invalid mgf parameter"); + return ""; + } + // The size of the input data cannot be more than the modulus + // length of the key - 2 * hashLen - 2 + if (dataSize + (2 *hashLen + 2) > bitLength/8) + { + ERROR_MSG("Too much data supplied for RSA OAEP encryption"); + return ""; + } + + std::ostringstream request; + request << "OAEP(" << hashStr << ",MGF1(" << mgfStr << ")"; + if (rsaOaepMecahnismParam->label.size() != 0) + { + request <<"," << std::string(rsaOaepMecahnismParam->label.const_byte_str(), + rsaOaepMecahnismParam->label.const_byte_str() + rsaOaepMecahnismParam->label.size()); + } + request << ")"; + return request.str(); +} \ No newline at end of file diff --git a/src/lib/crypto/BotanRSA.h b/src/lib/crypto/BotanRSA.h index 450dcc4eb..6511c6ce0 100644 --- a/src/lib/crypto/BotanRSA.h +++ b/src/lib/crypto/BotanRSA.h @@ -48,22 +48,24 @@ class BotanRSA : public AsymmetricAlgorithm virtual ~BotanRSA(); // Signing functions - virtual bool sign(PrivateKey* privateKey, const ByteString& dataToSign, ByteString& signature, const AsymMech::Type mechanism, const void* param = NULL, const size_t paramLen = 0, const MechanismParam* mechanismParam = NULL); - virtual bool signInit(PrivateKey* privateKey, const AsymMech::Type mechanism, const void* param = NULL, const size_t paramLen = 0, const MechanismParam* mechanismParam = NULL); + virtual bool sign(PrivateKey* privateKey, const ByteString& dataToSign, ByteString& signature, const AsymMech::Type mechanism, const MechanismParam* mechanismParam = NULL); + virtual bool signInit(PrivateKey* privateKey, const AsymMech::Type mechanism, const MechanismParam* mechanismParam = NULL); virtual bool signUpdate(const ByteString& dataToSign); virtual bool signFinal(ByteString& signature); // Verification functions - virtual bool verify(PublicKey* publicKey, const ByteString& originalData, const ByteString& signature, const AsymMech::Type mechanism, const void* param = NULL, const size_t paramLen = 0, const MechanismParam* mechanismParam = NULL); - virtual bool verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, const void* param = NULL, const size_t paramLen = 0, const MechanismParam* mechanismParam = NULL); + virtual bool verify(PublicKey* publicKey, const ByteString& originalData, const ByteString& signature, const AsymMech::Type mechanism, const MechanismParam* mechanismParam = NULL); + virtual bool verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, const MechanismParam* mechanismParam = NULL); virtual bool verifyUpdate(const ByteString& originalData); virtual bool verifyFinal(const ByteString& signature); // Encryption functions - virtual bool encrypt(PublicKey* publicKey, const ByteString& data, ByteString& encryptedData, const AsymMech::Type padding); + virtual bool encrypt(PublicKey* publicKey, const ByteString& data, ByteString& encryptedData, const AsymMech::Type padding, + const MechanismParam* mechanismParam = NULL); // Decryption functions - virtual bool decrypt(PrivateKey* privateKey, const ByteString& encryptedData, ByteString& data, const AsymMech::Type padding); + virtual bool decrypt(PrivateKey* privateKey, const ByteString& encryptedData, ByteString& data, const AsymMech::Type padding, + const MechanismParam* mechanismParam = NULL); // Key factory virtual bool generateKeyPair(AsymmetricKeyPair** ppKeyPair, AsymmetricParameters* parameters, RNG* rng = NULL); @@ -82,8 +84,9 @@ class BotanRSA : public AsymmetricAlgorithm Botan::PK_Verifier* verifier; #ifdef WITH_RAW_PSS - std::string getCipherRawPss(size_t bitLength, size_t dataSize, const void* param, const size_t paramLen); + 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); }; #endif // !_SOFTHSM_V2_BOTANRSA_H diff --git a/src/lib/crypto/CMakeLists.txt b/src/lib/crypto/CMakeLists.txt index 6d7cac985..cd66ff25d 100644 --- a/src/lib/crypto/CMakeLists.txt +++ b/src/lib/crypto/CMakeLists.txt @@ -33,6 +33,7 @@ set(SOURCES AESKey.cpp MLDSAPrivateKey.cpp MLDSAPublicKey.cpp MLDSAUtil.cpp + RSAMechanismParam.cpp RSAParameters.cpp RSAPrivateKey.cpp RSAPublicKey.cpp diff --git a/src/lib/crypto/Makefile.am b/src/lib/crypto/Makefile.am index b40d33f52..29eb18123 100644 --- a/src/lib/crypto/Makefile.am +++ b/src/lib/crypto/Makefile.am @@ -35,6 +35,7 @@ libsofthsm_crypto_la_SOURCES = AESKey.cpp \ MLDSAPrivateKey.cpp \ MLDSAPublicKey.cpp \ MLDSAUtil.cpp \ + RSAMechanismParam.cpp \ RSAParameters.cpp \ RSAPrivateKey.cpp \ RSAPublicKey.cpp \ diff --git a/src/lib/crypto/OSSLCryptoFactory.cpp b/src/lib/crypto/OSSLCryptoFactory.cpp index 7994b2029..d37abafc0 100644 --- a/src/lib/crypto/OSSLCryptoFactory.cpp +++ b/src/lib/crypto/OSSLCryptoFactory.cpp @@ -165,11 +165,6 @@ OSSLCryptoFactory::OSSLCryptoFactory() WARNING_MSG("ENGINE_set_default returned %lu\n", ERR_get_error()); } } - else - { - // Clear OpenSSL error queue if rdrand engine is unavailable - ERR_clear_error(); - } #endif // Initialise the one-and-only RNG diff --git a/src/lib/crypto/OSSLDH.cpp b/src/lib/crypto/OSSLDH.cpp index c6d25e956..43e64eb8e 100644 --- a/src/lib/crypto/OSSLDH.cpp +++ b/src/lib/crypto/OSSLDH.cpp @@ -51,8 +51,7 @@ // Signing functions bool OSSLDH::signInit(PrivateKey* /*privateKey*/, const AsymMech::Type /*mechanism*/, - const void* /* param = NULL */, const size_t /* paramLen = 0 */, - const MechanismParam* /* mechanismParam */) + const MechanismParam* /*mechanismParam*/) { ERROR_MSG("DH does not support signing"); @@ -75,8 +74,7 @@ bool OSSLDH::signFinal(ByteString& /*signature*/) // Verification functions bool OSSLDH::verifyInit(PublicKey* /*publicKey*/, const AsymMech::Type /*mechanism*/, - const void* /* param = NULL */, const size_t /* paramLen = 0 */, - const MechanismParam* /* mechanismParam */) + const MechanismParam* /*mechanismParam*/) { ERROR_MSG("DH does not support verifying"); @@ -99,7 +97,8 @@ bool OSSLDH::verifyFinal(const ByteString& /*signature*/) // Encryption functions bool OSSLDH::encrypt(PublicKey* /*publicKey*/, const ByteString& /*data*/, - ByteString& /*encryptedData*/, const AsymMech::Type /*padding*/) + ByteString& /*encryptedData*/, const AsymMech::Type /*padding*/, + const MechanismParam* /*mechanismParam*/) { ERROR_MSG("DH does not support encryption"); @@ -108,7 +107,8 @@ bool OSSLDH::encrypt(PublicKey* /*publicKey*/, const ByteString& /*data*/, // Decryption functions bool OSSLDH::decrypt(PrivateKey* /*privateKey*/, const ByteString& /*encryptedData*/, - ByteString& /*data*/, const AsymMech::Type /*padding*/) + ByteString& /*data*/, const AsymMech::Type /*padding*/, + const MechanismParam* /*mechanismParam*/) { ERROR_MSG("DH does not support decryption"); diff --git a/src/lib/crypto/OSSLDH.h b/src/lib/crypto/OSSLDH.h index 03be43be3..0a47d0642 100644 --- a/src/lib/crypto/OSSLDH.h +++ b/src/lib/crypto/OSSLDH.h @@ -44,20 +44,22 @@ class OSSLDH : public AsymmetricAlgorithm virtual ~OSSLDH() { } // Signing functions - virtual bool signInit(PrivateKey* privateKey, const AsymMech::Type mechanism, const void* param = NULL, const size_t paramLen = 0, const MechanismParam* mechanismParam = NULL); + virtual bool signInit(PrivateKey* privateKey, const AsymMech::Type mechanism, const MechanismParam* mechanismParam = NULL); virtual bool signUpdate(const ByteString& dataToSign); virtual bool signFinal(ByteString& signature); // Verification functions - virtual bool verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, const void* param = NULL, const size_t paramLen = 0, const MechanismParam* mechanismParam = NULL); + virtual bool verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, const MechanismParam* mechanismParam = NULL); virtual bool verifyUpdate(const ByteString& originalData); virtual bool verifyFinal(const ByteString& signature); // Encryption functions - virtual bool encrypt(PublicKey* publicKey, const ByteString& data, ByteString& encryptedData, const AsymMech::Type padding); + virtual bool encrypt(PublicKey* publicKey, const ByteString& data, ByteString& encryptedData, const AsymMech::Type padding, + const MechanismParam* mechanismParam = NULL); // Decryption functions - virtual bool decrypt(PrivateKey* privateKey, const ByteString& encryptedData, ByteString& data, const AsymMech::Type padding); + virtual bool decrypt(PrivateKey* privateKey, const ByteString& encryptedData, ByteString& data, const AsymMech::Type padding, + const MechanismParam* mechanismParam = NULL); // Key factory virtual bool generateKeyPair(AsymmetricKeyPair** ppKeyPair, AsymmetricParameters* parameters, RNG* rng = NULL); diff --git a/src/lib/crypto/OSSLDSA.cpp b/src/lib/crypto/OSSLDSA.cpp index b71f39c60..7fd40c791 100644 --- a/src/lib/crypto/OSSLDSA.cpp +++ b/src/lib/crypto/OSSLDSA.cpp @@ -61,8 +61,7 @@ OSSLDSA::~OSSLDSA() // Signing functions bool OSSLDSA::sign(PrivateKey* privateKey, const ByteString& dataToSign, ByteString& signature, const AsymMech::Type mechanism, - const void* param /* = NULL */, const size_t paramLen /* = 0 */, - const MechanismParam* /* mechanismParam */) + const MechanismParam* mechanismParam ) { if (mechanism == AsymMech::DSA) { @@ -99,15 +98,14 @@ bool OSSLDSA::sign(PrivateKey* privateKey, const ByteString& dataToSign, else { // Call default implementation - return AsymmetricAlgorithm::sign(privateKey, dataToSign, signature, mechanism, param, paramLen); + return AsymmetricAlgorithm::sign(privateKey, dataToSign, signature, mechanism, mechanismParam); } } bool OSSLDSA::signInit(PrivateKey* privateKey, const AsymMech::Type mechanism, - const void* param /* = NULL */, const size_t paramLen /* = 0 */, - const MechanismParam* /* mechanismParam */) + const MechanismParam* mechanismParam) { - if (!AsymmetricAlgorithm::signInit(privateKey, mechanism, param, paramLen)) + if (!AsymmetricAlgorithm::signInit(privateKey, mechanism, mechanismParam)) { return false; } @@ -240,8 +238,7 @@ bool OSSLDSA::signFinal(ByteString& signature) // Verification functions bool OSSLDSA::verify(PublicKey* publicKey, const ByteString& originalData, const ByteString& signature, const AsymMech::Type mechanism, - const void* param /* = NULL */, const size_t paramLen /* = 0 */, - const MechanismParam* /* mechanismParam */) + const MechanismParam* mechanismParam) { if (mechanism == AsymMech::DSA) { @@ -289,15 +286,14 @@ bool OSSLDSA::verify(PublicKey* publicKey, const ByteString& originalData, else { // Call the generic function - return AsymmetricAlgorithm::verify(publicKey, originalData, signature, mechanism, param, paramLen); + return AsymmetricAlgorithm::verify(publicKey, originalData, signature, mechanism, mechanismParam); } } bool OSSLDSA::verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, - const void* param /* = NULL */, const size_t paramLen /* = 0 */, - const MechanismParam* /* mechanismParam */) + const MechanismParam* mechanismParam) { - if (!AsymmetricAlgorithm::verifyInit(publicKey, mechanism, param, paramLen)) + if (!AsymmetricAlgorithm::verifyInit(publicKey, mechanism, mechanismParam)) { return false; } @@ -441,7 +437,8 @@ bool OSSLDSA::verifyFinal(const ByteString& signature) // Encryption functions bool OSSLDSA::encrypt(PublicKey* /*publicKey*/, const ByteString& /*data*/, - ByteString& /*encryptedData*/, const AsymMech::Type /*padding*/) + ByteString& /*encryptedData*/, const AsymMech::Type /*padding*/, + const MechanismParam* /*mechanismParam*/) { ERROR_MSG("DSA does not support encryption"); @@ -450,7 +447,8 @@ bool OSSLDSA::encrypt(PublicKey* /*publicKey*/, const ByteString& /*data*/, // Decryption functions bool OSSLDSA::decrypt(PrivateKey* /*privateKey*/, const ByteString& /*encryptedData*/, - ByteString& /*data*/, const AsymMech::Type /*padding*/) + ByteString& /*data*/, const AsymMech::Type /*padding*/, + const MechanismParam* /*mechanismParam*/) { ERROR_MSG("DSA does not support decryption"); diff --git a/src/lib/crypto/OSSLDSA.h b/src/lib/crypto/OSSLDSA.h index 5d26e2914..264c008de 100644 --- a/src/lib/crypto/OSSLDSA.h +++ b/src/lib/crypto/OSSLDSA.h @@ -48,22 +48,24 @@ class OSSLDSA : public AsymmetricAlgorithm virtual ~OSSLDSA(); // Signing functions - virtual bool sign(PrivateKey* privateKey, const ByteString& dataToSign, ByteString& signature, const AsymMech::Type mechanism, const void* param = NULL, const size_t paramLen = 0, const MechanismParam* mechanismParam = NULL); - virtual bool signInit(PrivateKey* privateKey, const AsymMech::Type mechanism, const void* param = NULL, const size_t paramLen = 0, const MechanismParam* mechanismParam = NULL); + virtual bool sign(PrivateKey* privateKey, const ByteString& dataToSign, ByteString& signature, const AsymMech::Type mechanism, const MechanismParam* mechanismParam = NULL); + virtual bool signInit(PrivateKey* privateKey, const AsymMech::Type mechanism, const MechanismParam* mechanismParam = NULL); virtual bool signUpdate(const ByteString& dataToSign); virtual bool signFinal(ByteString& signature); // Verification functions - virtual bool verify(PublicKey* publicKey, const ByteString& originalData, const ByteString& signature, const AsymMech::Type mechanism, const void* param = NULL, const size_t paramLen = 0, const MechanismParam* mechanismParam = NULL); - virtual bool verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, const void* param = NULL, const size_t paramLen = 0, const MechanismParam* mechanismParam = NULL); + virtual bool verify(PublicKey* publicKey, const ByteString& originalData, const ByteString& signature, const AsymMech::Type mechanism, const MechanismParam* mechanismParam = NULL); + virtual bool verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, const MechanismParam* mechanismParam = NULL); virtual bool verifyUpdate(const ByteString& originalData); virtual bool verifyFinal(const ByteString& signature); // Encryption functions - virtual bool encrypt(PublicKey* publicKey, const ByteString& data, ByteString& encryptedData, const AsymMech::Type padding); + virtual bool encrypt(PublicKey* publicKey, const ByteString& data, ByteString& encryptedData, const AsymMech::Type padding, + const MechanismParam* mechanismParam = NULL); // Decryption functions - virtual bool decrypt(PrivateKey* privateKey, const ByteString& encryptedData, ByteString& data, const AsymMech::Type padding); + virtual bool decrypt(PrivateKey* privateKey, const ByteString& encryptedData, ByteString& data, const AsymMech::Type padding, + const MechanismParam* mechanismParam = NULL); // Key factory virtual bool generateKeyPair(AsymmetricKeyPair** ppKeyPair, AsymmetricParameters* parameters, RNG* rng = NULL); diff --git a/src/lib/crypto/OSSLECDH.cpp b/src/lib/crypto/OSSLECDH.cpp index 3bba936bc..43fb61333 100644 --- a/src/lib/crypto/OSSLECDH.cpp +++ b/src/lib/crypto/OSSLECDH.cpp @@ -48,8 +48,7 @@ // Signing functions bool OSSLECDH::signInit(PrivateKey* /*privateKey*/, const AsymMech::Type /*mechanism*/, - const void* /* param = NULL */, const size_t /* paramLen = 0 */, - const MechanismParam* /* mechanismParam */) + const MechanismParam* /* mechanismParam = NULL */) { ERROR_MSG("ECDH does not support signing"); @@ -72,8 +71,7 @@ bool OSSLECDH::signFinal(ByteString& /*signature*/) // Verification functions bool OSSLECDH::verifyInit(PublicKey* /*publicKey*/, const AsymMech::Type /*mechanism*/, - const void* /* param = NULL */, const size_t /* paramLen = 0 */, - const MechanismParam* /* mechanismParam */) + const MechanismParam* /* mechanismParam = NULL */) { ERROR_MSG("ECDH does not support verifying"); @@ -96,7 +94,8 @@ bool OSSLECDH::verifyFinal(const ByteString& /*signature*/) // Encryption functions bool OSSLECDH::encrypt(PublicKey* /*publicKey*/, const ByteString& /*data*/, - ByteString& /*encryptedData*/, const AsymMech::Type /*padding*/) + ByteString& /*encryptedData*/, const AsymMech::Type /*padding*/, + const MechanismParam* /*mechanismParam*/) { ERROR_MSG("ECDH does not support encryption"); @@ -105,7 +104,8 @@ bool OSSLECDH::encrypt(PublicKey* /*publicKey*/, const ByteString& /*data*/, // Decryption functions bool OSSLECDH::decrypt(PrivateKey* /*privateKey*/, const ByteString& /*encryptedData*/, - ByteString& /*data*/, const AsymMech::Type /*padding*/) + ByteString& /*data*/, const AsymMech::Type /*padding*/, + const MechanismParam* /*mechanismParam*/) { ERROR_MSG("ECDH does not support decryption"); diff --git a/src/lib/crypto/OSSLECDH.h b/src/lib/crypto/OSSLECDH.h index 91d2edb3d..455a7764d 100644 --- a/src/lib/crypto/OSSLECDH.h +++ b/src/lib/crypto/OSSLECDH.h @@ -44,20 +44,22 @@ class OSSLECDH : public AsymmetricAlgorithm virtual ~OSSLECDH() { } // Signing functions - virtual bool signInit(PrivateKey* privateKey, const AsymMech::Type mechanism, const void* param = NULL, const size_t paramLen = 0, const MechanismParam* mechanismParam = NULL); + virtual bool signInit(PrivateKey* privateKey, const AsymMech::Type mechanism, const MechanismParam* mechanismParam = NULL); virtual bool signUpdate(const ByteString& dataToSign); virtual bool signFinal(ByteString& signature); // Verification functions - virtual bool verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, const void* param = NULL, const size_t paramLen = 0, const MechanismParam* mechanismParam = NULL); + virtual bool verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, const MechanismParam* mechanismParam = NULL); virtual bool verifyUpdate(const ByteString& originalData); virtual bool verifyFinal(const ByteString& signature); // Encryption functions - virtual bool encrypt(PublicKey* publicKey, const ByteString& data, ByteString& encryptedData, const AsymMech::Type padding); + virtual bool encrypt(PublicKey* publicKey, const ByteString& data, ByteString& encryptedData, const AsymMech::Type padding, + const MechanismParam* mechanismParam = NULL); // Decryption functions - virtual bool decrypt(PrivateKey* privateKey, const ByteString& encryptedData, ByteString& data, const AsymMech::Type padding); + virtual bool decrypt(PrivateKey* privateKey, const ByteString& encryptedData, ByteString& data, const AsymMech::Type padding, + const MechanismParam* mechanismParam = NULL); // Key factory virtual bool generateKeyPair(AsymmetricKeyPair** ppKeyPair, AsymmetricParameters* parameters, RNG* rng = NULL); diff --git a/src/lib/crypto/OSSLECDSA.cpp b/src/lib/crypto/OSSLECDSA.cpp index de806e7c5..ca3b639bb 100644 --- a/src/lib/crypto/OSSLECDSA.cpp +++ b/src/lib/crypto/OSSLECDSA.cpp @@ -51,7 +51,6 @@ // Signing functions bool OSSLECDSA::sign(PrivateKey* privateKey, const ByteString& dataToSign, ByteString& signature, const AsymMech::Type mechanism, - const void* /* param = NULL */, const size_t /* paramLen = 0 */, const MechanismParam* /* mechanismParam */) { @@ -160,8 +159,7 @@ bool OSSLECDSA::sign(PrivateKey* privateKey, const ByteString& dataToSign, } bool OSSLECDSA::signInit(PrivateKey* /*privateKey*/, const AsymMech::Type /*mechanism*/, - const void* /* param = NULL */, const size_t /* paramLen = 0 */, - const MechanismParam* /* mechanismParam */) + const MechanismParam* /* mechanismParam = NULL */) { ERROR_MSG("ECDSA does not support multi part signing"); @@ -185,7 +183,6 @@ bool OSSLECDSA::signFinal(ByteString& /*signature*/) // Verification functions bool OSSLECDSA::verify(PublicKey* publicKey, const ByteString& originalData, const ByteString& signature, const AsymMech::Type mechanism, - const void* /* param = NULL */, const size_t /* paramLen = 0 */, const MechanismParam* /* mechanismParam */) { @@ -311,8 +308,7 @@ bool OSSLECDSA::verify(PublicKey* publicKey, const ByteString& originalData, } bool OSSLECDSA::verifyInit(PublicKey* /*publicKey*/, const AsymMech::Type /*mechanism*/, - const void* /* param = NULL */, const size_t /* paramLen = 0 */, - const MechanismParam* /* mechanismParam */) + const MechanismParam* /* mechanismParam = NULL */) { ERROR_MSG("ECDSA does not support multi part verifying"); @@ -335,7 +331,7 @@ bool OSSLECDSA::verifyFinal(const ByteString& /*signature*/) // Encryption functions bool OSSLECDSA::encrypt(PublicKey* /*publicKey*/, const ByteString& /*data*/, - ByteString& /*encryptedData*/, const AsymMech::Type /*padding*/) + ByteString& /*encryptedData*/, const AsymMech::Type /*padding*/, const MechanismParam* /*mechanismParam*/ ) { ERROR_MSG("ECDSA does not support encryption"); @@ -344,7 +340,7 @@ bool OSSLECDSA::encrypt(PublicKey* /*publicKey*/, const ByteString& /*data*/, // Decryption functions bool OSSLECDSA::decrypt(PrivateKey* /*privateKey*/, const ByteString& /*encryptedData*/, - ByteString& /*data*/, const AsymMech::Type /*padding*/) + ByteString& /*data*/, const AsymMech::Type /*padding*/, const MechanismParam* /*mechanismParam*/) { ERROR_MSG("ECDSA does not support decryption"); diff --git a/src/lib/crypto/OSSLECDSA.h b/src/lib/crypto/OSSLECDSA.h index d3f175977..86b24cb10 100644 --- a/src/lib/crypto/OSSLECDSA.h +++ b/src/lib/crypto/OSSLECDSA.h @@ -44,22 +44,24 @@ class OSSLECDSA : public AsymmetricAlgorithm virtual ~OSSLECDSA() { } // Signing functions - virtual bool sign(PrivateKey* privateKey, const ByteString& dataToSign, ByteString& signature, const AsymMech::Type mechanism, const void* param = NULL, const size_t paramLen = 0, const MechanismParam* mechanismParam = NULL); - virtual bool signInit(PrivateKey* privateKey, const AsymMech::Type mechanism, const void* param = NULL, const size_t paramLen = 0, const MechanismParam* mechanismParam = NULL); + virtual bool sign(PrivateKey* privateKey, const ByteString& dataToSign, ByteString& signature, const AsymMech::Type mechanism, const MechanismParam* mechanismParam = NULL); + virtual bool signInit(PrivateKey* privateKey, const AsymMech::Type mechanism, const MechanismParam* mechanismParam = NULL); virtual bool signUpdate(const ByteString& dataToSign); virtual bool signFinal(ByteString& signature); // Verification functions - virtual bool verify(PublicKey* publicKey, const ByteString& originalData, const ByteString& signature, const AsymMech::Type mechanism, const void* param = NULL, const size_t paramLen = 0, const MechanismParam* mechanismParam = NULL); - virtual bool verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, const void* param = NULL, const size_t paramLen = 0, const MechanismParam* mechanismParam = NULL); + virtual bool verify(PublicKey* publicKey, const ByteString& originalData, const ByteString& signature, const AsymMech::Type mechanism, const MechanismParam* mechanismParam = NULL); + virtual bool verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, const MechanismParam* mechanismParam = NULL); virtual bool verifyUpdate(const ByteString& originalData); virtual bool verifyFinal(const ByteString& signature); // Encryption functions - virtual bool encrypt(PublicKey* publicKey, const ByteString& data, ByteString& encryptedData, const AsymMech::Type padding); + virtual bool encrypt(PublicKey* publicKey, const ByteString& data, ByteString& encryptedData, const AsymMech::Type padding, + const MechanismParam* mechanismParam = NULL); // Decryption functions - virtual bool decrypt(PrivateKey* privateKey, const ByteString& encryptedData, ByteString& data, const AsymMech::Type padding); + virtual bool decrypt(PrivateKey* privateKey, const ByteString& encryptedData, ByteString& data, const AsymMech::Type padding, + const MechanismParam* mechanismParam = NULL); // Key factory virtual bool generateKeyPair(AsymmetricKeyPair** ppKeyPair, AsymmetricParameters* parameters, RNG* rng = NULL); diff --git a/src/lib/crypto/OSSLEDDSA.cpp b/src/lib/crypto/OSSLEDDSA.cpp index 214fbf4f9..58cf7aebd 100644 --- a/src/lib/crypto/OSSLEDDSA.cpp +++ b/src/lib/crypto/OSSLEDDSA.cpp @@ -48,7 +48,6 @@ // Signing functions bool OSSLEDDSA::sign(PrivateKey* privateKey, const ByteString& dataToSign, ByteString& signature, const AsymMech::Type mechanism, - const void* /* param = NULL */, const size_t /* paramLen = 0 */, const MechanismParam* /* mechanismParam */) { if (mechanism != AsymMech::EDDSA) @@ -103,8 +102,7 @@ bool OSSLEDDSA::sign(PrivateKey* privateKey, const ByteString& dataToSign, } bool OSSLEDDSA::signInit(PrivateKey* /*privateKey*/, const AsymMech::Type /*mechanism*/, - const void* /* param = NULL */, const size_t /* paramLen = 0 */, - const MechanismParam* /* mechanismParam */) + const MechanismParam* /*mechanismParam = NULL */) { ERROR_MSG("EDDSA does not support multi part signing"); @@ -128,7 +126,6 @@ bool OSSLEDDSA::signFinal(ByteString& /*signature*/) // Verification functions bool OSSLEDDSA::verify(PublicKey* publicKey, const ByteString& originalData, const ByteString& signature, const AsymMech::Type mechanism, - const void* /* param = NULL */, const size_t /* paramLen = 0 */, const MechanismParam* /* mechanismParam */) { if (mechanism != AsymMech::EDDSA) @@ -188,8 +185,7 @@ bool OSSLEDDSA::verify(PublicKey* publicKey, const ByteString& originalData, } bool OSSLEDDSA::verifyInit(PublicKey* /*publicKey*/, const AsymMech::Type /*mechanism*/, - const void* /* param = NULL */, const size_t /* paramLen = 0 */, - const MechanismParam* /* mechanismParam */) + const MechanismParam* /*mechanismParam = NULL */) { ERROR_MSG("EDDSA does not support multi part verifying"); @@ -212,7 +208,7 @@ bool OSSLEDDSA::verifyFinal(const ByteString& /*signature*/) // Encryption functions bool OSSLEDDSA::encrypt(PublicKey* /*publicKey*/, const ByteString& /*data*/, - ByteString& /*encryptedData*/, const AsymMech::Type /*padding*/) + ByteString& /*encryptedData*/, const AsymMech::Type /*padding*/, const MechanismParam* /*mechanismParam*/) { ERROR_MSG("EDDSA does not support encryption"); @@ -221,7 +217,7 @@ bool OSSLEDDSA::encrypt(PublicKey* /*publicKey*/, const ByteString& /*data*/, // Decryption functions bool OSSLEDDSA::decrypt(PrivateKey* /*privateKey*/, const ByteString& /*encryptedData*/, - ByteString& /*data*/, const AsymMech::Type /*padding*/) + ByteString& /*data*/, const AsymMech::Type /*padding*/,const MechanismParam* /*mechanismParam*/) { ERROR_MSG("EDDSA does not support decryption"); diff --git a/src/lib/crypto/OSSLEDDSA.h b/src/lib/crypto/OSSLEDDSA.h index f640080ba..7fbb60309 100644 --- a/src/lib/crypto/OSSLEDDSA.h +++ b/src/lib/crypto/OSSLEDDSA.h @@ -44,22 +44,24 @@ class OSSLEDDSA : public AsymmetricAlgorithm virtual ~OSSLEDDSA() { } // Signing functions - virtual bool sign(PrivateKey* privateKey, const ByteString& dataToSign, ByteString& signature, const AsymMech::Type mechanism, const void* param = NULL, const size_t paramLen = 0, const MechanismParam* mechanismParam = NULL); - virtual bool signInit(PrivateKey* privateKey, const AsymMech::Type mechanism, const void* param = NULL, const size_t paramLen = 0, const MechanismParam* mechanismParam = NULL); + virtual bool sign(PrivateKey* privateKey, const ByteString& dataToSign, ByteString& signature, const AsymMech::Type mechanism, const MechanismParam* mechanismParam = NULL); + virtual bool signInit(PrivateKey* privateKey, const AsymMech::Type mechanism, const MechanismParam* mechanismParam = NULL); virtual bool signUpdate(const ByteString& dataToSign); virtual bool signFinal(ByteString& signature); // Verification functions - virtual bool verify(PublicKey* publicKey, const ByteString& originalData, const ByteString& signature, const AsymMech::Type mechanism, const void* param = NULL, const size_t paramLen = 0, const MechanismParam* mechanismParam = NULL); - virtual bool verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, const void* param = NULL, const size_t paramLen = 0, const MechanismParam* mechanismParam = NULL); + virtual bool verify(PublicKey* publicKey, const ByteString& originalData, const ByteString& signature, const AsymMech::Type mechanism, const MechanismParam* mechanismParam = NULL); + virtual bool verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, const MechanismParam* mechanismParam = NULL); virtual bool verifyUpdate(const ByteString& originalData); virtual bool verifyFinal(const ByteString& signature); // Encryption functions - virtual bool encrypt(PublicKey* publicKey, const ByteString& data, ByteString& encryptedData, const AsymMech::Type padding); + virtual bool encrypt(PublicKey* publicKey, const ByteString& data, ByteString& encryptedData, const AsymMech::Type padding, + const MechanismParam* mechanismParam = NULL); // Decryption functions - virtual bool decrypt(PrivateKey* privateKey, const ByteString& encryptedData, ByteString& data, const AsymMech::Type padding); + virtual bool decrypt(PrivateKey* privateKey, const ByteString& encryptedData, ByteString& data, const AsymMech::Type padding, + const MechanismParam* mechanismParam = NULL); // Key factory virtual bool generateKeyPair(AsymmetricKeyPair** ppKeyPair, AsymmetricParameters* parameters, RNG* rng = NULL); diff --git a/src/lib/crypto/OSSLGOST.cpp b/src/lib/crypto/OSSLGOST.cpp index a544b41a1..d20113003 100644 --- a/src/lib/crypto/OSSLGOST.cpp +++ b/src/lib/crypto/OSSLGOST.cpp @@ -55,8 +55,7 @@ OSSLGOST::~OSSLGOST() // Signing functions bool OSSLGOST::sign(PrivateKey* privateKey, const ByteString& dataToSign, ByteString& signature, const AsymMech::Type mechanism, - const void* param /* = NULL */, const size_t paramLen /* = 0 */, - const MechanismParam* /* mechanismParam */) + const MechanismParam* mechanismParam ) { if (mechanism == AsymMech::GOST) { @@ -122,15 +121,15 @@ bool OSSLGOST::sign(PrivateKey* privateKey, const ByteString& dataToSign, else { // Call default implementation - return AsymmetricAlgorithm::sign(privateKey, dataToSign, signature, mechanism, param, paramLen); + return AsymmetricAlgorithm::sign(privateKey, dataToSign, signature, mechanism, mechanismParam); } } bool OSSLGOST::signInit(PrivateKey* privateKey, const AsymMech::Type mechanism, const void* param /* = NULL */, const size_t paramLen /* = 0 */, - const MechanismParam* /* mechanismParam */) + const MechanismParam* mechanismParam /* = NULL */) { - if (!AsymmetricAlgorithm::signInit(privateKey, mechanism, param, paramLen)) + if (!AsymmetricAlgorithm::signInit(privateKey, mechanism, mechanismParam)) { return false; } @@ -254,8 +253,7 @@ bool OSSLGOST::signFinal(ByteString& signature) // Verification functions bool OSSLGOST::verify(PublicKey* publicKey, const ByteString& originalData, const ByteString& signature, const AsymMech::Type mechanism, - const void* param /* = NULL */, const size_t paramLen /* = 0 */, - const MechanismParam* /* mechanismParam */) + const MechanismParam* mechanismParam ) { if (mechanism == AsymMech::GOST) { @@ -308,15 +306,14 @@ bool OSSLGOST::verify(PublicKey* publicKey, const ByteString& originalData, else { // Call the generic function - return AsymmetricAlgorithm::verify(publicKey, originalData, signature, mechanism, param, paramLen); + return AsymmetricAlgorithm::verify(publicKey, originalData, signature, mechanism, mechanismParam); } } bool OSSLGOST::verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, - const void* param /* = NULL */, const size_t paramLen /* = 0 */, - const MechanismParam* /* mechanismParam */) + const MechanismParam* mechanismParam /*= NULL */) { - if (!AsymmetricAlgorithm::verifyInit(publicKey, mechanism, param, paramLen)) + if (!AsymmetricAlgorithm::verifyInit(publicKey, mechanism, mechanismParam)) { return false; } @@ -432,7 +429,8 @@ bool OSSLGOST::verifyFinal(const ByteString& signature) // Encryption functions bool OSSLGOST::encrypt(PublicKey* /*publicKey*/, const ByteString& /*data*/, - ByteString& /*encryptedData*/, const AsymMech::Type /*padding*/) + ByteString& /*encryptedData*/, const AsymMech::Type /*padding*/, + const MechanismParam* /*mechanismParam*/) { ERROR_MSG("GOST does not support encryption"); @@ -441,7 +439,8 @@ bool OSSLGOST::encrypt(PublicKey* /*publicKey*/, const ByteString& /*data*/, // Decryption functions bool OSSLGOST::decrypt(PrivateKey* /*privateKey*/, const ByteString& /*encryptedData*/, - ByteString& /*data*/, const AsymMech::Type /*padding*/) + ByteString& /*data*/, const AsymMech::Type /*padding*/, + const MechanismParam* /*mechanismParam*/) { ERROR_MSG("GOST does not support decryption"); diff --git a/src/lib/crypto/OSSLGOST.h b/src/lib/crypto/OSSLGOST.h index 5fd81a9e9..953e9c49d 100644 --- a/src/lib/crypto/OSSLGOST.h +++ b/src/lib/crypto/OSSLGOST.h @@ -49,22 +49,24 @@ class OSSLGOST : public AsymmetricAlgorithm ~OSSLGOST(); // Signing functions - virtual bool sign(PrivateKey* privateKey, const ByteString& dataToSign, ByteString& signature, const AsymMech::Type mechanism, const void* param = NULL, const size_t paramLen = 0, const MechanismParam* mechanismParam = NULL); - virtual bool signInit(PrivateKey* privateKey, const AsymMech::Type mechanism, const void* param = NULL, const size_t paramLen = 0, const MechanismParam* mechanismParam = NULL); + virtual bool sign(PrivateKey* privateKey, const ByteString& dataToSign, ByteString& signature, const AsymMech::Type mechanism, const MechanismParam* mechanismParam = NULL); + virtual bool signInit(PrivateKey* privateKey, const AsymMech::Type mechanism, const MechanismParam* mechanismParam = NULL); virtual bool signUpdate(const ByteString& dataToSign); virtual bool signFinal(ByteString& signature); // Verification functions - virtual bool verify(PublicKey* publicKey, const ByteString& originalData, const ByteString& signature, const AsymMech::Type mechanism, const void* param = NULL, const size_t paramLen = 0, const MechanismParam* mechanismParam = NULL); - virtual bool verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, const void* param = NULL, const size_t paramLen = 0, const MechanismParam* mechanismParam = NULL); + virtual bool verify(PublicKey* publicKey, const ByteString& originalData, const ByteString& signature, const AsymMech::Type mechanism, const MechanismParam* mechanismParam = NULL); + virtual bool verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, const MechanismParam* mechanismParam = NULL); virtual bool verifyUpdate(const ByteString& originalData); virtual bool verifyFinal(const ByteString& signature); // Encryption functions - virtual bool encrypt(PublicKey* publicKey, const ByteString& data, ByteString& encryptedData, const AsymMech::Type padding); + virtual bool encrypt(PublicKey* publicKey, const ByteString& data, ByteString& encryptedData, const AsymMech::Type padding, + const MechanismParam* mechanismParam = NULL); // Decryption functions - virtual bool decrypt(PrivateKey* privateKey, const ByteString& encryptedData, ByteString& data, const AsymMech::Type padding); + virtual bool decrypt(PrivateKey* privateKey, const ByteString& encryptedData, ByteString& data, const AsymMech::Type padding, + const MechanismParam* mechanismParam = NULL); // Key factory virtual bool generateKeyPair(AsymmetricKeyPair** ppKeyPair, AsymmetricParameters* parameters, RNG* rng = NULL); diff --git a/src/lib/crypto/OSSLMLDSA.cpp b/src/lib/crypto/OSSLMLDSA.cpp index b19231a9c..a11cfa1d3 100644 --- a/src/lib/crypto/OSSLMLDSA.cpp +++ b/src/lib/crypto/OSSLMLDSA.cpp @@ -27,10 +27,8 @@ int OSSLMLDSA::OSSL_DETERMINISTIC = 1; // Signing functions bool OSSLMLDSA::sign(PrivateKey *privateKey, const ByteString &dataToSign, ByteString &signature, const AsymMech::Type mechanism, - const void * /* param = NULL*/, const size_t /* paramLen = 0 */, const MechanismParam* mechanismParam) { - DEBUG_MSG("sign dataToSign: %s", dataToSign.hex_str().c_str()); if (mechanism != AsymMech::MLDSA) { ERROR_MSG("Invalid mechanism supplied (%i)", mechanism); @@ -156,92 +154,33 @@ bool OSSLMLDSA::sign(PrivateKey *privateKey, const ByteString &dataToSign, return true; } -bool OSSLMLDSA::signInit(PrivateKey * privateKey, const AsymMech::Type mechanism, - const void * param /* = NULL */ , const size_t paramLen /* = 0 */, - const MechanismParam* mechanismParam /* = NULL */) +bool OSSLMLDSA::signInit(PrivateKey * /*privateKey*/, const AsymMech::Type /*mechanism*/, + const MechanismParam* /* mechanismParam */) { - if (!AsymmetricAlgorithm::signInit(privateKey, mechanism, param, paramLen)) - { - return false; - } - - // Check if the private key is the right type - if (!privateKey->isOfType(OSSLMLDSAPrivateKey::type)) - { - ERROR_MSG("Invalid key type supplied"); - - ByteString dummy; - AsymmetricAlgorithm::signFinal(dummy); - - return false; - } - - DEBUG_MSG("signInit mechanismParam != NULL: %d", mechanismParam != NULL); - - if (mechanismParam != NULL && !mechanismParam->isOfType(MLDSAMechanismParam::type)) - { - ERROR_MSG("Invalid mechanism parameter type supplied"); - - ByteString dummy; - AsymmetricAlgorithm::signFinal(dummy); - - return false; - } - - if (mechanismParam != NULL) { - delete mechanismParameters; // safe even if nullptr - mechanismParameters = mechanismParam->clone(); - } else { - delete mechanismParameters; - mechanismParameters = NULL; - } + ERROR_MSG("ML-DSA does not support multi part signing"); - return true; + return false; } -bool OSSLMLDSA::signUpdate(const ByteString & dataToSign) +bool OSSLMLDSA::signUpdate(const ByteString & /*dataToSign*/) { - if (!AsymmetricAlgorithm::signUpdate(dataToSign)) - { - return false; - } - - DEBUG_MSG("signUpdate dataToSign %s", dataToSign.hex_str().c_str()); - - message += dataToSign; - - DEBUG_MSG("signUpdate message %s", message.hex_str().c_str()); + ERROR_MSG("ML-DSA does not support multi part signing"); - return true; + return false; } -bool OSSLMLDSA::signFinal(ByteString & signature) +bool OSSLMLDSA::signFinal(ByteString & /*signature*/) { - DEBUG_MSG("signFinal mechanismParameters != NULL: %d", mechanismParameters != NULL); - int rv = OSSLMLDSA::sign(currentPrivateKey, message, signature, currentMechanism, NULL, 0, mechanismParameters); - DEBUG_MSG("rv=%d", rv); - - delete mechanismParameters; - mechanismParameters = NULL; - - message.resize(0); - - if (!AsymmetricAlgorithm::signFinal(signature)) - { - return false; - } + ERROR_MSG("ML-DSA does not support multi part signing"); - return rv; + return false; } // Verification functions bool OSSLMLDSA::verify(PublicKey *publicKey, const ByteString &originalData, const ByteString &signature, const AsymMech::Type mechanism, - const void * /* param = NULL*/, const size_t /* paramLen = 0 */, const MechanismParam* mechanismParam) { - DEBUG_MSG("verify originalData: %s", originalData.hex_str().c_str()); - DEBUG_MSG("verify signature: %s", signature.hex_str().c_str()); if (mechanism != AsymMech::MLDSA) { ERROR_MSG("Invalid mechanism supplied (%i)", mechanism); @@ -364,87 +303,32 @@ bool OSSLMLDSA::verify(PublicKey *publicKey, const ByteString &originalData, return true; } -bool OSSLMLDSA::verifyInit(PublicKey * publicKey, const AsymMech::Type mechanism, - const void * param /* = NULL */, const size_t paramLen /* = 0 */, - const MechanismParam* mechanismParam /* = NULL */) +bool OSSLMLDSA::verifyInit(PublicKey * /*publicKey*/, const AsymMech::Type /*mechanism*/, + const MechanismParam* /* mechanismParam */) { - if (!AsymmetricAlgorithm::verifyInit(publicKey, mechanism, param, paramLen)) - { - return false; - } - - // Check if the private key is the right type - if (!publicKey->isOfType(OSSLMLDSAPublicKey::type)) - { - ERROR_MSG("Invalid key type supplied"); - - ByteString dummy; - AsymmetricAlgorithm::verifyFinal(dummy); - - return false; - } - - DEBUG_MSG("verifyInit mechanismParam != NULL: %d", mechanismParam != NULL); - - if (mechanismParam != NULL && !mechanismParam->isOfType(MLDSAMechanismParam::type)) - { - ERROR_MSG("Invalid mechanism parameter type supplied"); - - ByteString dummy; - AsymmetricAlgorithm::verifyFinal(dummy); - - return false; - } - - if (mechanismParam != NULL) { - delete mechanismParameters; // safe even if nullptr - mechanismParameters = mechanismParam->clone(); - } else { - delete mechanismParameters; - mechanismParameters = NULL; - } + ERROR_MSG("ML-DSA does not support multi part verifying"); - return true; + return false; } -bool OSSLMLDSA::verifyUpdate(const ByteString & originalData) +bool OSSLMLDSA::verifyUpdate(const ByteString & /*originalData*/) { - if (!AsymmetricAlgorithm::verifyUpdate(originalData)) - { - return false; - } - - DEBUG_MSG("verifyUpdate originalData %s", originalData.hex_str().c_str()); - - message += originalData; - - DEBUG_MSG("verifyUpdate message %s", message.hex_str().c_str()); + ERROR_MSG("ML-DSA does not support multi part verifying"); - return true; + return false; } -bool OSSLMLDSA::verifyFinal(const ByteString & signature) +bool OSSLMLDSA::verifyFinal(const ByteString & /*signature*/) { - DEBUG_MSG("verifyFinal mechanismParameters != NULL: %d", mechanismParameters != NULL); - int rv = OSSLMLDSA::verify(currentPublicKey, message, signature, currentMechanism, NULL, 0, mechanismParameters); - DEBUG_MSG("rv=%d", rv); - - delete mechanismParameters; - mechanismParameters = NULL; - - message.resize(0); - - if (!AsymmetricAlgorithm::verifyFinal(signature)) - { - return false; - } + ERROR_MSG("ML-DSA does not support multi part verifying"); - return rv; + return false; } // Encryption functions bool OSSLMLDSA::encrypt(PublicKey * /*publicKey*/, const ByteString & /*data*/, - ByteString & /*encryptedData*/, const AsymMech::Type /*padding*/) + ByteString & /*encryptedData*/, const AsymMech::Type /*padding*/, + const MechanismParam* /*mechanismParam*/) { ERROR_MSG("ML-DSA does not support encryption"); @@ -453,7 +337,8 @@ bool OSSLMLDSA::encrypt(PublicKey * /*publicKey*/, const ByteString & /*data*/, // Decryption functions bool OSSLMLDSA::decrypt(PrivateKey * /*privateKey*/, const ByteString & /*encryptedData*/, - ByteString & /*data*/, const AsymMech::Type /*padding*/) + ByteString & /*data*/, const AsymMech::Type /*padding*/, + const MechanismParam* /*mechanismParam*/) { ERROR_MSG("ML-DSA does not support decryption"); diff --git a/src/lib/crypto/OSSLMLDSA.h b/src/lib/crypto/OSSLMLDSA.h index 6401d0a06..941aa22c1 100644 --- a/src/lib/crypto/OSSLMLDSA.h +++ b/src/lib/crypto/OSSLMLDSA.h @@ -15,29 +15,29 @@ class OSSLMLDSA : public AsymmetricAlgorithm { public: - OSSLMLDSA() : message(), parameters(NULL), paramLength(0), mechanismParameters(NULL) { } - // Destructor virtual ~OSSLMLDSA() { } // Signing functions - virtual bool sign(PrivateKey *privateKey, const ByteString &dataToSign, ByteString &signature, const AsymMech::Type mechanism, const void *param = NULL, const size_t paramLen = 0, const MechanismParam* mechanismParam = NULL); - virtual bool signInit(PrivateKey* privateKey, const AsymMech::Type mechanism, const void* param = NULL, const size_t paramLen = 0, const MechanismParam* mechanismParam = NULL); + virtual bool sign(PrivateKey *privateKey, const ByteString &dataToSign, ByteString &signature, const AsymMech::Type mechanism, const MechanismParam* mechanismParam = NULL); + virtual bool signInit(PrivateKey* privateKey, const AsymMech::Type mechanism, const MechanismParam* mechanismParam = NULL); virtual bool signUpdate(const ByteString& dataToSign); virtual bool signFinal(ByteString& signature); // Verification functions - virtual bool verify(PublicKey* publicKey, const ByteString& originalData, const ByteString& signature, const AsymMech::Type mechanism, const void* param = NULL, const size_t paramLen = 0, const MechanismParam* mechanismParam = NULL); - virtual bool verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, const void* param = NULL, const size_t paramLen = 0, const MechanismParam* mechanismParam = NULL); + virtual bool verify(PublicKey* publicKey, const ByteString& originalData, const ByteString& signature, const AsymMech::Type mechanism, const MechanismParam* mechanismParam = NULL); + virtual bool verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, const MechanismParam* mechanismParam = NULL); virtual bool verifyUpdate(const ByteString& originalData); virtual bool verifyFinal(const ByteString& signature); // Encryption functions - virtual bool encrypt(PublicKey* publicKey, const ByteString& data, ByteString& encryptedData, const AsymMech::Type padding); + virtual bool encrypt(PublicKey* publicKey, const ByteString& data, ByteString& encryptedData, const AsymMech::Type padding, + const MechanismParam* mechanismParam = NULL); // Decryption functions virtual bool checkEncryptedDataSize(PrivateKey* privateKey, const ByteString& encryptedData, int* errorCode); - virtual bool decrypt(PrivateKey* privateKey, const ByteString& encryptedData, ByteString& data, const AsymMech::Type padding); + virtual bool decrypt(PrivateKey* privateKey, const ByteString& encryptedData, ByteString& data, const AsymMech::Type padding, + const MechanismParam* mechanismParam = NULL); virtual unsigned long getMinKeySize(); virtual unsigned long getMaxKeySize(); @@ -54,10 +54,6 @@ class OSSLMLDSA : public AsymmetricAlgorithm private: static int OSSL_RANDOM; static int OSSL_DETERMINISTIC; - ByteString message; - void* parameters; - size_t paramLength; - const MechanismParam* mechanismParameters; }; #endif // !WITH_ML_DSA diff --git a/src/lib/crypto/OSSLRSA.cpp b/src/lib/crypto/OSSLRSA.cpp index f8463f40c..eb0247c0b 100644 --- a/src/lib/crypto/OSSLRSA.cpp +++ b/src/lib/crypto/OSSLRSA.cpp @@ -36,9 +36,10 @@ #include "OSSLUtil.h" #include "CryptoFactory.h" #include "RSAParameters.h" +#include "RSAMechanismParam.h" #include "OSSLRSAKeyPair.h" #include -#include +#include #include #include @@ -67,8 +68,7 @@ OSSLRSA::~OSSLRSA() // Signing functions bool OSSLRSA::sign(PrivateKey* privateKey, const ByteString& dataToSign, ByteString& signature, const AsymMech::Type mechanism, - const void* param /* = NULL */, const size_t paramLen /* = 0 */, - const MechanismParam* /* mechanismParam */) + const MechanismParam* mechanismParam ) { if (mechanism == AsymMech::RSA_PKCS) { @@ -96,85 +96,115 @@ bool OSSLRSA::sign(PrivateKey* privateKey, const ByteString& dataToSign, } // Perform the signature operation - signature.resize(osslKey->getN().size()); + size_t sigLen = osslKey->getN().size(); - RSA* rsa = osslKey->getOSSLKey(); + EVP_PKEY* rsa = osslKey->getOSSLKey(); - if (!RSA_blinding_on(rsa, NULL)) + EVP_PKEY_CTX* ctx = EVP_PKEY_CTX_new(rsa, NULL); + if (ctx == NULL) { - ERROR_MSG("Failed to turn on blinding for OpenSSL RSA key"); - + ERROR_MSG("An error occurred while creating sign context"); return false; } - int sigLen = RSA_private_encrypt(dataToSign.size(), (unsigned char*) dataToSign.const_byte_str(), &signature[0], rsa, RSA_PKCS1_PADDING); - - RSA_blinding_off(rsa); + if ((EVP_PKEY_sign_init(ctx) <= 0) || + (EVP_PKEY_CTX_set_rsa_padding(ctx, RSA_PKCS1_PADDING) <= 0)) + { + EVP_PKEY_CTX_free(ctx); + ERROR_MSG("An error occurred while set PKCS #1 signature parameters"); + return false; + } - if (sigLen == -1) + signature.resize(sigLen); + if (EVP_PKEY_sign(ctx, signature.byte_str(), &sigLen, (unsigned char *)dataToSign.const_byte_str(), dataToSign.size()) <= 0) { + EVP_PKEY_CTX_free(ctx); ERROR_MSG("An error occurred while performing a PKCS #1 signature"); - return false; } - + EVP_PKEY_CTX_free(ctx); signature.resize(sigLen); - return true; } else if (mechanism == AsymMech::RSA_PKCS_PSS) { - const RSA_PKCS_PSS_PARAMS *pssParam = (RSA_PKCS_PSS_PARAMS*)param; - - // Separate implementation for RSA PKCS #1 signing without hash computation + if (mechanismParam == NULL) + { + ERROR_MSG("RSA OAEP mechanism parameter not supplied"); - // Check if the private key is the right type - if (!privateKey->isOfType(OSSLRSAPrivateKey::type)) + return false; + } + if (!mechanismParam->isOfType(RSAPssMechanismParam::type)) { - ERROR_MSG("Invalid key type supplied"); + ERROR_MSG("Invalid RSA PSS mechanism parameter type supplied"); return false; } + const RSAPssMechanismParam* pssParam = dynamic_cast(mechanismParam); - if (pssParam == NULL || paramLen != sizeof(RSA_PKCS_PSS_PARAMS)) + // Separate implementation for RSA PKCS #1 signing without hash computation + + // Check if the private key is the right type + if (!privateKey->isOfType(OSSLRSAPrivateKey::type)) { - ERROR_MSG("Invalid parameters supplied"); + ERROR_MSG("Invalid key type supplied"); return false; } - size_t allowedLen; const EVP_MD* hash = NULL; + const EVP_MD* mgf = NULL; switch (pssParam->hashAlg) { - case HashAlgo::SHA1: - hash = EVP_sha1(); - allowedLen = 20; - break; - case HashAlgo::SHA224: - hash = EVP_sha224(); - allowedLen = 28; - break; - case HashAlgo::SHA256: - hash = EVP_sha256(); - allowedLen = 32; - break; - case HashAlgo::SHA384: - hash = EVP_sha384(); - allowedLen = 48; - break; - case HashAlgo::SHA512: - hash = EVP_sha512(); - allowedLen = 64; - break; - default: - return false; + case HashAlgo::SHA1: + hash = EVP_sha1(); + allowedLen = 20; + break; + case HashAlgo::SHA224: + hash = EVP_sha224(); + allowedLen = 28; + break; + case HashAlgo::SHA256: + hash = EVP_sha256(); + allowedLen = 32; + break; + case HashAlgo::SHA384: + hash = EVP_sha384(); + allowedLen = 48; + break; + case HashAlgo::SHA512: + hash = EVP_sha512(); + allowedLen = 64; + break; + default: + return false; + } + + switch (pssParam->mgfAlg) + { + case AsymRSAMGF::MGF1_SHA1: + mgf = EVP_sha1(); + break; + case AsymRSAMGF::MGF1_SHA224: + mgf = EVP_sha224(); + break; + case AsymRSAMGF::MGF1_SHA256: + mgf = EVP_sha256(); + break; + case AsymRSAMGF::MGF1_SHA384: + mgf = EVP_sha384(); + break; + case AsymRSAMGF::MGF1_SHA512: + mgf = EVP_sha512(); + break; + default: + return false; } OSSLRSAPrivateKey* osslKey = (OSSLRSAPrivateKey*) privateKey; - RSA* rsa = osslKey->getOSSLKey(); + EVP_PKEY* rsa = osslKey->getOSSLKey(); if (dataToSign.size() != allowedLen) { @@ -184,46 +214,41 @@ bool OSSLRSA::sign(PrivateKey* privateKey, const ByteString& dataToSign, } size_t sParamLen = pssParam->sLen; - if (sParamLen > ((privateKey->getBitLength()+6)/8-2-allowedLen)) + if (sParamLen > ((privateKey->getBitLength() + 6) / 8 - 2 - allowedLen)) { ERROR_MSG("sLen (%lu) is too large for current key size (%lu)", - (unsigned long)sParamLen, privateKey->getBitLength()); + (unsigned long)sParamLen, privateKey->getBitLength()); return false; } - ByteString em; - em.resize(osslKey->getN().size()); - - int status = RSA_padding_add_PKCS1_PSS_mgf1(rsa, &em[0], (unsigned char*) dataToSign.const_byte_str(), hash, hash, pssParam->sLen); - if (!status) + // Perform the signature operation + size_t sigLen = osslKey->getN().size(); + EVP_PKEY_CTX* ctx = EVP_PKEY_CTX_new(rsa, NULL); + if (ctx == NULL) { - ERROR_MSG("Error in RSA PSS padding generation"); - + ERROR_MSG("An error occurred while creating the RSA-PSS signature context"); return false; } - - if (!RSA_blinding_on(rsa, NULL)) + if ((EVP_PKEY_sign_init(ctx) <= 0) || + (EVP_PKEY_CTX_set_rsa_padding(ctx, RSA_PKCS1_PSS_PADDING) <= 0) || + (EVP_PKEY_CTX_set_signature_md(ctx, hash) <= 0) || + (EVP_PKEY_CTX_set_rsa_mgf1_md(ctx, mgf) <= 0) || + (EVP_PKEY_CTX_set_rsa_pss_saltlen(ctx, sParamLen) <= 0)) { - ERROR_MSG("Failed to turn on blinding for OpenSSL RSA key"); - + EVP_PKEY_CTX_free(ctx); + ERROR_MSG("An error occurred while set the RSA-PSS signature parameters"); return false; } - // Perform the signature operation - signature.resize(osslKey->getN().size()); - - int sigLen = RSA_private_encrypt(osslKey->getN().size(), &em[0], &signature[0], rsa, RSA_NO_PADDING); - - RSA_blinding_off(rsa); - - if (sigLen == -1) + signature.resize(sigLen); + if (EVP_PKEY_sign(ctx, &signature[0], &sigLen, dataToSign.const_byte_str(), dataToSign.size()) <= 0) { + EVP_PKEY_CTX_free(ctx); ERROR_MSG("An error occurred while performing the RSA-PSS signature"); - return false; } - + EVP_PKEY_CTX_free(ctx); signature.resize(sigLen); return true; @@ -241,7 +266,7 @@ bool OSSLRSA::sign(PrivateKey* privateKey, const ByteString& dataToSign, } // In case of raw RSA, the length of the input data must match the length of the modulus - OSSLRSAPrivateKey* osslKey = (OSSLRSAPrivateKey*) privateKey; + OSSLRSAPrivateKey* osslKey = (OSSLRSAPrivateKey*)privateKey; if (dataToSign.size() != osslKey->getN().size()) { @@ -249,30 +274,26 @@ bool OSSLRSA::sign(PrivateKey* privateKey, const ByteString& dataToSign, return false; } + size_t sigLen = osslKey->getN().size(); // Perform the signature operation - signature.resize(osslKey->getN().size()); - - RSA* rsa = osslKey->getOSSLKey(); - - if (!RSA_blinding_on(rsa, NULL)) + EVP_PKEY* rsa = osslKey->getOSSLKey(); + EVP_PKEY_CTX* ctx = EVP_PKEY_CTX_new(rsa, NULL); + if (ctx == NULL) { - ERROR_MSG("Failed to turn on blinding for OpenSSL RSA key"); - + ERROR_MSG("An error occurred while creating a raw RSA signature context"); return false; } - - int sigLen = RSA_private_encrypt(dataToSign.size(), (unsigned char*) dataToSign.const_byte_str(), &signature[0], rsa, RSA_NO_PADDING); - - RSA_blinding_off(rsa); - - if (sigLen == -1) + signature.resize(sigLen); + if ((EVP_PKEY_sign_init(ctx) <= 0) || + (EVP_PKEY_CTX_set_rsa_padding(ctx, RSA_NO_PADDING) <= 0) || + (EVP_PKEY_sign(ctx, &signature[0], &sigLen, dataToSign.const_byte_str(), dataToSign.size()) <= 0)) { + EVP_PKEY_CTX_free(ctx); ERROR_MSG("An error occurred while performing a raw RSA signature"); - return false; } - + EVP_PKEY_CTX_free(ctx); signature.resize(sigLen); return true; @@ -280,15 +301,14 @@ bool OSSLRSA::sign(PrivateKey* privateKey, const ByteString& dataToSign, else { // Call default implementation - return AsymmetricAlgorithm::sign(privateKey, dataToSign, signature, mechanism, param, paramLen); + return AsymmetricAlgorithm::sign(privateKey, dataToSign, signature, mechanism, mechanismParam); } } -bool OSSLRSA::signInit(PrivateKey* privateKey, const AsymMech::Type mechanism, - const void* param /* = NULL */, const size_t paramLen /* = 0 */, - const MechanismParam* /* mechanismParam */) +bool OSSLRSA::signInit(PrivateKey *privateKey, const AsymMech::Type mechanism, + const MechanismParam* mechanismParam /*= NULL*/) { - if (!AsymmetricAlgorithm::signInit(privateKey, mechanism, param, paramLen)) + if (!AsymmetricAlgorithm::signInit(privateKey, mechanism, mechanismParam)) { return false; } @@ -306,7 +326,7 @@ 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: @@ -328,17 +348,24 @@ bool OSSLRSA::signInit(PrivateKey* privateKey, const AsymMech::Type mechanism, hash1 = HashAlgo::SHA512; break; case AsymMech::RSA_SHA1_PKCS_PSS: - if (param == NULL || paramLen != sizeof(RSA_PKCS_PSS_PARAMS) || - ((RSA_PKCS_PSS_PARAMS*) param)->hashAlg != HashAlgo::SHA1 || - ((RSA_PKCS_PSS_PARAMS*) param)->mgf != AsymRSAMGF::MGF1_SHA1) + 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 parameters"); + ERROR_MSG("Invalid RSA PSS mechanism parameters supplied"); ByteString dummy; AsymmetricAlgorithm::signFinal(dummy); return false; } - sLen = ((RSA_PKCS_PSS_PARAMS*) param)->sLen; - if (sLen > ((privateKey->getBitLength()+6)/8-2-20)) + 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()); @@ -349,17 +376,24 @@ bool OSSLRSA::signInit(PrivateKey* privateKey, const AsymMech::Type mechanism, hash1 = HashAlgo::SHA1; break; case AsymMech::RSA_SHA224_PKCS_PSS: - if (param == NULL || paramLen != sizeof(RSA_PKCS_PSS_PARAMS) || - ((RSA_PKCS_PSS_PARAMS*) param)->hashAlg != HashAlgo::SHA224 || - ((RSA_PKCS_PSS_PARAMS*) param)->mgf != AsymRSAMGF::MGF1_SHA224) + if ((mechanismParam == NULL) || (!mechanismParam->isOfType(RSAPssMechanismParam::type))) { - ERROR_MSG("Invalid parameters"); + ERROR_MSG("Invalid RSA PSS mechanism parameter type supplied"); ByteString dummy; AsymmetricAlgorithm::signFinal(dummy); return false; } - sLen = ((RSA_PKCS_PSS_PARAMS*) param)->sLen; - if (sLen > ((privateKey->getBitLength()+6)/8-2-28)) + 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()); @@ -370,17 +404,24 @@ bool OSSLRSA::signInit(PrivateKey* privateKey, const AsymMech::Type mechanism, hash1 = HashAlgo::SHA224; break; case AsymMech::RSA_SHA256_PKCS_PSS: - if (param == NULL || paramLen != sizeof(RSA_PKCS_PSS_PARAMS) || - ((RSA_PKCS_PSS_PARAMS*) param)->hashAlg != HashAlgo::SHA256 || - ((RSA_PKCS_PSS_PARAMS*) param)->mgf != AsymRSAMGF::MGF1_SHA256) + if ((mechanismParam == NULL) || (!mechanismParam->isOfType(RSAPssMechanismParam::type))) { - ERROR_MSG("Invalid parameters"); + ERROR_MSG("Invalid RSA PSS mechanism parameter type supplied"); ByteString dummy; AsymmetricAlgorithm::signFinal(dummy); return false; } - sLen = ((RSA_PKCS_PSS_PARAMS*) param)->sLen; - if (sLen > ((privateKey->getBitLength()+6)/8-2-32)) + pssParam = dynamic_cast(mechanismParam); + if ((pssParam->hashAlg != HashAlgo::SHA256)|| + (pssParam->mgfAlg != AsymRSAMGF::MGF1_SHA256)) + { + ERROR_MSG("Invalid RSA PSS mechanism parameters supplied"); + ByteString dummy; + AsymmetricAlgorithm::signFinal(dummy); + return false; + } + sLen = pssParam->sLen; + if (sLen > ((privateKey->getBitLength() + 6) / 8 - 2 - 32)) { ERROR_MSG("sLen (%lu) is too large for current key size (%lu)", (unsigned long)sLen, privateKey->getBitLength()); @@ -391,17 +432,24 @@ bool OSSLRSA::signInit(PrivateKey* privateKey, const AsymMech::Type mechanism, hash1 = HashAlgo::SHA256; break; case AsymMech::RSA_SHA384_PKCS_PSS: - if (param == NULL || paramLen != sizeof(RSA_PKCS_PSS_PARAMS) || - ((RSA_PKCS_PSS_PARAMS*) param)->hashAlg != HashAlgo::SHA384 || - ((RSA_PKCS_PSS_PARAMS*) param)->mgf != AsymRSAMGF::MGF1_SHA384) + 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)) { - ERROR_MSG("Invalid parameters"); + ERROR_MSG("Invalid RSA PSS mechanism parameters supplied"); ByteString dummy; AsymmetricAlgorithm::signFinal(dummy); return false; } - sLen = ((RSA_PKCS_PSS_PARAMS*) param)->sLen; - if (sLen > ((privateKey->getBitLength()+6)/8-2-48)) + 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()); @@ -412,17 +460,24 @@ bool OSSLRSA::signInit(PrivateKey* privateKey, const AsymMech::Type mechanism, hash1 = HashAlgo::SHA384; break; case AsymMech::RSA_SHA512_PKCS_PSS: - if (param == NULL || paramLen != sizeof(RSA_PKCS_PSS_PARAMS) || - ((RSA_PKCS_PSS_PARAMS*) param)->hashAlg != HashAlgo::SHA512 || - ((RSA_PKCS_PSS_PARAMS*) param)->mgf != AsymRSAMGF::MGF1_SHA512) + if ((mechanismParam == NULL) || (!mechanismParam->isOfType(RSAPssMechanismParam::type))) { - ERROR_MSG("Invalid parameters"); + ERROR_MSG("Invalid RSA PSS mechanism parameter type supplied"); ByteString dummy; AsymmetricAlgorithm::signFinal(dummy); return false; } - sLen = ((RSA_PKCS_PSS_PARAMS*) param)->sLen; - if (sLen > ((privateKey->getBitLength()+6)/8-2-64)) + 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()); @@ -524,7 +579,7 @@ bool OSSLRSA::signUpdate(const ByteString& dataToSign) bool OSSLRSA::signFinal(ByteString& signature) { // Save necessary state before calling super class signFinal - OSSLRSAPrivateKey* pk = (OSSLRSAPrivateKey*) currentPrivateKey; + OSSLRSAPrivateKey* pk = (OSSLRSAPrivateKey*)currentPrivateKey; AsymMech::Type mechanism = currentMechanism; if (!AsymmetricAlgorithm::signFinal(signature)) @@ -554,132 +609,112 @@ bool OSSLRSA::signFinal(ByteString& signature) ByteString digest = firstHash + secondHash; - // Resize the data block for the signature to the modulus size of the key - signature.resize(pk->getN().size()); - - // Determine the signature NID type - int type = 0; - bool isPSS = false; + int rsaPadding = 0; const EVP_MD* hash = NULL; switch (mechanism) { case AsymMech::RSA_MD5_PKCS: - type = NID_md5; + hash = EVP_md5(); + rsaPadding = RSA_PKCS1_PADDING; break; case AsymMech::RSA_SHA1_PKCS: - type = NID_sha1; + hash = EVP_sha1(); + rsaPadding = RSA_PKCS1_PADDING; break; case AsymMech::RSA_SHA224_PKCS: - type = NID_sha224; + hash = EVP_sha224(); + rsaPadding = RSA_PKCS1_PADDING; break; case AsymMech::RSA_SHA256_PKCS: - type = NID_sha256; + hash = EVP_sha256(); + rsaPadding = RSA_PKCS1_PADDING; break; case AsymMech::RSA_SHA384_PKCS: - type = NID_sha384; + hash = EVP_sha384(); + rsaPadding = RSA_PKCS1_PADDING; break; case AsymMech::RSA_SHA512_PKCS: - type = NID_sha512; + hash = EVP_sha512(); + rsaPadding = RSA_PKCS1_PADDING; break; case AsymMech::RSA_SHA1_PKCS_PSS: - isPSS = true; + rsaPadding = RSA_PKCS1_PSS_PADDING; hash = EVP_sha1(); - break; + break; case AsymMech::RSA_SHA224_PKCS_PSS: - isPSS = true; + rsaPadding = RSA_PKCS1_PSS_PADDING; hash = EVP_sha224(); break; case AsymMech::RSA_SHA256_PKCS_PSS: - isPSS = true; + rsaPadding = RSA_PKCS1_PSS_PADDING; hash = EVP_sha256(); break; case AsymMech::RSA_SHA384_PKCS_PSS: - isPSS = true; + rsaPadding = RSA_PKCS1_PSS_PADDING; hash = EVP_sha384(); break; case AsymMech::RSA_SHA512_PKCS_PSS: - isPSS = true; + rsaPadding = RSA_PKCS1_PSS_PADDING; hash = EVP_sha512(); break; case AsymMech::RSA_SSL: - type = NID_md5_sha1; + rsaPadding = RSA_PKCS1_PADDING; + hash = EVP_md5_sha1(); break; default: - break; + return false; } + // Resize the data block for the signature to the modulus size of the key - // Perform the signature operation - unsigned int sigLen = signature.size(); + size_t sigLen = pk->getN().size(); - RSA* rsa = pk->getOSSLKey(); + // Perform the signature operation + EVP_PKEY* rsa = pk->getOSSLKey(); - if (!RSA_blinding_on(rsa, NULL)) + EVP_PKEY_CTX* ctx = EVP_PKEY_CTX_new(rsa, NULL); + if (ctx == NULL) { - ERROR_MSG("Failed to turn blinding on for OpenSSL RSA key"); - + ERROR_MSG("An error occurred while creating RSA signature context"); return false; } - - bool rv; - int result; - - if (isPSS) + if ((EVP_PKEY_sign_init(ctx) <= 0) || + (EVP_PKEY_CTX_set_rsa_padding(ctx, rsaPadding) <= 0) || + (EVP_PKEY_CTX_set_signature_md(ctx, hash) <= 0)) { - ByteString em; - em.resize(pk->getN().size()); - - result = (RSA_padding_add_PKCS1_PSS(pk->getOSSLKey(), &em[0], &digest[0], - hash, sLen) == 1); - if (!result) - { - ERROR_MSG("RSA PSS padding failed (0x%08X)", ERR_get_error()); - rv = false; - } - else - { - result = RSA_private_encrypt(em.size(), &em[0], &signature[0], - pk->getOSSLKey(), RSA_NO_PADDING); - if (result >= 0) - { - sigLen = result; - rv = true; - } - else - { - ERROR_MSG("RSA private encrypt failed (0x%08X)", ERR_get_error()); - rv = false; - } - } + EVP_PKEY_CTX_free(ctx); + ERROR_MSG("RSA private encrypt set padding type failed (0x%08X)", ERR_get_error()); + return false; } - else + if (rsaPadding == RSA_PKCS1_PSS_PADDING) { - result = RSA_sign(type, &digest[0], digest.size(), &signature[0], - &sigLen, pk->getOSSLKey()); - if (result > 0) - { - rv = true; - } - else + if ((EVP_PKEY_CTX_set_rsa_mgf1_md(ctx, hash) <= 0) || + (EVP_PKEY_CTX_set_rsa_pss_saltlen(ctx, sLen) <= 0)) { - ERROR_MSG("RSA sign failed (0x%08X)", ERR_get_error()); - rv = false; + EVP_PKEY_CTX_free(ctx); + ERROR_MSG("RSA private encrypt set PSS parameters failed (0x%08X)", ERR_get_error()); + return false; } } - - RSA_blinding_off(rsa); - + signature.resize(sigLen); + if (EVP_PKEY_sign(ctx, signature.byte_str(), &sigLen, digest.const_byte_str(), digest.size()) <= 0) + { + EVP_PKEY_CTX_free(ctx); + ERROR_MSG("RSA private encrypt failed (0x%08X)", ERR_get_error()); + return false; + } + EVP_PKEY_CTX_free(ctx); signature.resize(sigLen); - return rv; + return true; } // Verification functions bool OSSLRSA::verify(PublicKey* publicKey, const ByteString& originalData, const ByteString& signature, const AsymMech::Type mechanism, - const void* param /* = NULL */, const size_t paramLen /* = 0 */, - const MechanismParam* /* mechanismParam */) + const MechanismParam* mechanismParam ) { + if (mechanism == AsymMech::RSA_PKCS) { // Specific implementation for PKCS #1 only verification; originalData is assumed to contain @@ -697,107 +732,137 @@ bool OSSLRSA::verify(PublicKey* publicKey, const ByteString& originalData, // Perform the RSA public key operation OSSLRSAPublicKey* osslKey = (OSSLRSAPublicKey*) publicKey; - ByteString recoveredData; - - recoveredData.resize(osslKey->getN().size()); - - RSA* rsa = osslKey->getOSSLKey(); - - int retLen = RSA_public_decrypt(signature.size(), (unsigned char*) signature.const_byte_str(), &recoveredData[0], rsa, RSA_PKCS1_PADDING); - - if (retLen == -1) + EVP_PKEY* rsa = osslKey->getOSSLKey(); + EVP_PKEY_CTX* ctx = EVP_PKEY_CTX_new(rsa, NULL); + if (ctx == NULL) { - ERROR_MSG("Public key operation failed"); - + ERROR_MSG("An error occurred while creating RSA signature context"); return false; } - - recoveredData.resize(retLen); - - return (originalData == recoveredData); + if ((EVP_PKEY_verify_init(ctx) <= 0) || + (EVP_PKEY_CTX_set_rsa_padding(ctx, RSA_PKCS1_PADDING) <= 0)) + { + EVP_PKEY_CTX_free(ctx); + ERROR_MSG("RSA sign verify failed (0x%08X)", ERR_get_error()); + return false; + } + int status = EVP_PKEY_verify(ctx, signature.const_byte_str(), signature.size(), originalData.const_byte_str(), originalData.size()); + if (status < 0) + { + EVP_PKEY_CTX_free(ctx); + ERROR_MSG("RSA sign verify failed (0x%08X)", ERR_get_error()); + return false; + } + EVP_PKEY_CTX_free(ctx); + return (status == 1); } else if (mechanism == AsymMech::RSA_PKCS_PSS) { - const RSA_PKCS_PSS_PARAMS *pssParam = (RSA_PKCS_PSS_PARAMS*)param; - - if (pssParam == NULL || paramLen != sizeof(RSA_PKCS_PSS_PARAMS)) + if (mechanismParam == NULL) { - ERROR_MSG("Invalid parameters supplied"); + ERROR_MSG("RSA OAEP mechanism parameter not supplied"); return false; } - - // Check if the public key is the right type - if (!publicKey->isOfType(OSSLRSAPublicKey::type)) + if (!mechanismParam->isOfType(RSAPssMechanismParam::type)) { - ERROR_MSG("Invalid key type supplied"); + ERROR_MSG("Invalid RSA PSS mechanism parameter type supplied"); return false; } + const RSAPssMechanismParam* pssParam = dynamic_cast(mechanismParam); // Perform the RSA public key operation OSSLRSAPublicKey* osslKey = (OSSLRSAPublicKey*) publicKey; - - ByteString recoveredData; - - recoveredData.resize(osslKey->getN().size()); - - RSA* rsa = osslKey->getOSSLKey(); - - int retLen = RSA_public_decrypt(signature.size(), (unsigned char*) signature.const_byte_str(), &recoveredData[0], rsa, RSA_NO_PADDING); - - if (retLen == -1) - { - ERROR_MSG("Public key operation failed"); - - return false; - } - - recoveredData.resize(retLen); + EVP_PKEY* rsa = osslKey->getOSSLKey(); size_t allowedLen; const EVP_MD* hash = NULL; - + const EVP_MD* mgf = NULL; switch (pssParam->hashAlg) { - case HashAlgo::SHA1: - hash = EVP_sha1(); - allowedLen = 20; - break; - case HashAlgo::SHA224: - hash = EVP_sha224(); - allowedLen = 28; - break; - case HashAlgo::SHA256: - hash = EVP_sha256(); - allowedLen = 32; - break; - case HashAlgo::SHA384: - hash = EVP_sha384(); - allowedLen = 48; - break; - case HashAlgo::SHA512: - hash = EVP_sha512(); - allowedLen = 64; - break; - default: - return false; + case HashAlgo::SHA1: + hash = EVP_sha1(); + allowedLen = 20; + break; + case HashAlgo::SHA224: + hash = EVP_sha224(); + allowedLen = 28; + break; + case HashAlgo::SHA256: + hash = EVP_sha256(); + allowedLen = 32; + break; + case HashAlgo::SHA384: + hash = EVP_sha384(); + allowedLen = 48; + break; + case HashAlgo::SHA512: + hash = EVP_sha512(); + allowedLen = 64; + break; + default: + return false; + } + switch (pssParam->mgfAlg) + { + case AsymRSAMGF::MGF1_SHA1: + mgf = EVP_sha1(); + break; + case AsymRSAMGF::MGF1_SHA224: + mgf = EVP_sha224(); + break; + case AsymRSAMGF::MGF1_SHA256: + mgf = EVP_sha256(); + break; + case AsymRSAMGF::MGF1_SHA384: + mgf = EVP_sha384(); + break; + case AsymRSAMGF::MGF1_SHA512: + mgf = EVP_sha512(); + break; + default: + return false; } - if (originalData.size() != allowedLen) { + if (originalData.size() != allowedLen) + { return false; } size_t sParamLen = pssParam->sLen; - if (sParamLen > ((osslKey->getBitLength()+6)/8-2-allowedLen)) + if (sParamLen > ((osslKey->getBitLength() + 6) / 8 - 2 - allowedLen)) { ERROR_MSG("sLen (%lu) is too large for current key size (%lu)", - (unsigned long)sParamLen, osslKey->getBitLength()); + (unsigned long)sParamLen, osslKey->getBitLength()); return false; } - int status = RSA_verify_PKCS1_PSS_mgf1(rsa, (unsigned char*)originalData.const_byte_str(), hash, hash, (unsigned char*) recoveredData.const_byte_str(), pssParam->sLen); - + EVP_PKEY_CTX* ctx = EVP_PKEY_CTX_new(rsa, NULL); + if (ctx == NULL) + { + ERROR_MSG("An error occurred while creating RSA signature context"); + return false; + } + if ((EVP_PKEY_verify_init(ctx) <= 0) || + (EVP_PKEY_CTX_set_rsa_padding(ctx, RSA_PKCS1_PSS_PADDING) <= 0) || + (EVP_PKEY_CTX_set_signature_md(ctx, hash) <= 0) || + (EVP_PKEY_CTX_set_rsa_mgf1_md(ctx, mgf) <= 0) || + (EVP_PKEY_CTX_set_rsa_pss_saltlen(ctx, sParamLen) <= 0)) + { + EVP_PKEY_CTX_free(ctx); + ERROR_MSG("RSA verify set PSS parameters failed (0x%08X)", ERR_get_error()); + return false; + } + int status = EVP_PKEY_verify(ctx, signature.const_byte_str(), signature.size(), + originalData.const_byte_str(), originalData.size()); + if (status < 0) + { + EVP_PKEY_CTX_free(ctx); + ERROR_MSG("RSA sign verify failed (0x%08X)", ERR_get_error()); + return false; + } + EVP_PKEY_CTX_free(ctx); return (status == 1); } else if (mechanism == AsymMech::RSA) @@ -817,37 +882,42 @@ bool OSSLRSA::verify(PublicKey* publicKey, const ByteString& originalData, // Perform the RSA public key operation OSSLRSAPublicKey* osslKey = (OSSLRSAPublicKey*) publicKey; - ByteString recoveredData; - - recoveredData.resize(osslKey->getN().size()); - - RSA* rsa = osslKey->getOSSLKey(); - - int retLen = RSA_public_decrypt(signature.size(), (unsigned char*) signature.const_byte_str(), &recoveredData[0], rsa, RSA_NO_PADDING); - - if (retLen == -1) + EVP_PKEY* rsa = osslKey->getOSSLKey(); + EVP_PKEY_CTX* ctx = EVP_PKEY_CTX_new(rsa, NULL); + if (ctx == NULL) { - ERROR_MSG("Public key operation failed"); - + ERROR_MSG("An error occurred while creating RSA signature context"); return false; } - - recoveredData.resize(retLen); - - return (originalData == recoveredData); + if ((EVP_PKEY_verify_init(ctx) <= 0) || + (EVP_PKEY_CTX_set_rsa_padding(ctx, RSA_NO_PADDING) <= 0)) + { + EVP_PKEY_CTX_free(ctx); + ERROR_MSG("RSA sign verify failed (0x%08X)", ERR_get_error()); + return false; + } + int status = EVP_PKEY_verify(ctx, signature.const_byte_str(), signature.size(), + originalData.const_byte_str(), originalData.size()); + if (status < 0) + { + EVP_PKEY_CTX_free(ctx); + ERROR_MSG("RSA sign verify failed (0x%08X)", ERR_get_error()); + return false; + } + EVP_PKEY_CTX_free(ctx); + return (status == 1); } else { // Call the generic function - return AsymmetricAlgorithm::verify(publicKey, originalData, signature, mechanism, param, paramLen); + return AsymmetricAlgorithm::verify(publicKey, originalData, signature, mechanism, mechanismParam); } } bool OSSLRSA::verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, - const void* param /* = NULL */, const size_t paramLen /* = 0 */, - const MechanismParam* /* mechanismParam */) + const MechanismParam* mechanismParam /* = NULL */) { - if (!AsymmetricAlgorithm::verifyInit(publicKey, mechanism, param, paramLen)) + if (!AsymmetricAlgorithm::verifyInit(publicKey, mechanism, mechanismParam)) { return false; } @@ -866,6 +936,8 @@ 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: @@ -887,17 +959,24 @@ bool OSSLRSA::verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, hash1 = HashAlgo::SHA512; break; case AsymMech::RSA_SHA1_PKCS_PSS: - if (param == NULL || paramLen != sizeof(RSA_PKCS_PSS_PARAMS) || - ((RSA_PKCS_PSS_PARAMS*) param)->hashAlg != HashAlgo::SHA1 || - ((RSA_PKCS_PSS_PARAMS*) param)->mgf != AsymRSAMGF::MGF1_SHA1) + if ((mechanismParam == NULL) || (!mechanismParam->isOfType(RSAPssMechanismParam::type))) { - ERROR_MSG("Invalid parameters"); + ERROR_MSG("Invalid RSA PSS mechanism parameter type supplied"); ByteString dummy; AsymmetricAlgorithm::verifyFinal(dummy); return false; } - sLen = ((RSA_PKCS_PSS_PARAMS*) param)->sLen; - if (sLen > ((publicKey->getBitLength()+6)/8-2-20)) + 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()); @@ -908,17 +987,24 @@ bool OSSLRSA::verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, hash1 = HashAlgo::SHA1; break; case AsymMech::RSA_SHA224_PKCS_PSS: - if (param == NULL || paramLen != sizeof(RSA_PKCS_PSS_PARAMS) || - ((RSA_PKCS_PSS_PARAMS*) param)->hashAlg != HashAlgo::SHA224 || - ((RSA_PKCS_PSS_PARAMS*) param)->mgf != AsymRSAMGF::MGF1_SHA224) + 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)) { - ERROR_MSG("Invalid parameters"); + ERROR_MSG("Invalid RSA PSS mechanism parameters supplied"); ByteString dummy; AsymmetricAlgorithm::verifyFinal(dummy); return false; } - sLen = ((RSA_PKCS_PSS_PARAMS*) param)->sLen; - if (sLen > ((publicKey->getBitLength()+6)/8-2-28)) + 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()); @@ -929,17 +1015,24 @@ bool OSSLRSA::verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, hash1 = HashAlgo::SHA224; break; case AsymMech::RSA_SHA256_PKCS_PSS: - if (param == NULL || paramLen != sizeof(RSA_PKCS_PSS_PARAMS) || - ((RSA_PKCS_PSS_PARAMS*) param)->hashAlg != HashAlgo::SHA256 || - ((RSA_PKCS_PSS_PARAMS*) param)->mgf != AsymRSAMGF::MGF1_SHA256) + 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 parameters"); + ERROR_MSG("Invalid RSA PSS mechanism parameters supplied"); ByteString dummy; AsymmetricAlgorithm::verifyFinal(dummy); return false; } - sLen = ((RSA_PKCS_PSS_PARAMS*) param)->sLen; - if (sLen > ((publicKey->getBitLength()+6)/8-2-32)) + 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()); @@ -950,38 +1043,52 @@ bool OSSLRSA::verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, hash1 = HashAlgo::SHA256; break; case AsymMech::RSA_SHA384_PKCS_PSS: - if (param == NULL || paramLen != sizeof(RSA_PKCS_PSS_PARAMS) || - ((RSA_PKCS_PSS_PARAMS*) param)->hashAlg != HashAlgo::SHA384 || - ((RSA_PKCS_PSS_PARAMS*) param)->mgf != AsymRSAMGF::MGF1_SHA384) + if ((mechanismParam == NULL) || (!mechanismParam->isOfType(RSAPssMechanismParam::type))) { - ERROR_MSG("Invalid parameters"); + ERROR_MSG("Invalid RSA PSS mechanism parameter type supplied"); ByteString dummy; AsymmetricAlgorithm::verifyFinal(dummy); return false; } - sLen = ((RSA_PKCS_PSS_PARAMS*) param)->sLen; - if (sLen > ((publicKey->getBitLength()+6)/8-2-48)) + pssParam = dynamic_cast(mechanismParam); + if ((pssParam->hashAlg != HashAlgo::SHA384)|| + (pssParam->mgfAlg != AsymRSAMGF::MGF1_SHA384)) { - ERROR_MSG("sLen (%lu) is too large for current key size (%lu)", - (unsigned long)sLen, publicKey->getBitLength()); + 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 (param == NULL || paramLen != sizeof(RSA_PKCS_PSS_PARAMS) || - ((RSA_PKCS_PSS_PARAMS*) param)->hashAlg != HashAlgo::SHA512 || - ((RSA_PKCS_PSS_PARAMS*) param)->mgf != AsymRSAMGF::MGF1_SHA512) + if ((mechanismParam == NULL) || (!mechanismParam->isOfType(RSAPssMechanismParam::type))) { - ERROR_MSG("Invalid parameters"); + ERROR_MSG("Invalid RSA PSS mechanism parameter type supplied"); ByteString dummy; AsymmetricAlgorithm::verifyFinal(dummy); return false; } - sLen = ((RSA_PKCS_PSS_PARAMS*) param)->sLen; - if (sLen > ((publicKey->getBitLength()+6)/8-2-64)) + 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()); @@ -1083,7 +1190,7 @@ bool OSSLRSA::verifyUpdate(const ByteString& originalData) bool OSSLRSA::verifyFinal(const ByteString& signature) { // Save necessary state before calling super class verifyFinal - OSSLRSAPublicKey* pk = (OSSLRSAPublicKey*) currentPublicKey; + OSSLRSAPublicKey* pk = (OSSLRSAPublicKey*)currentPublicKey; AsymMech::Type mechanism = currentMechanism; if (!AsymmetricAlgorithm::verifyFinal(signature)) @@ -1113,104 +1220,102 @@ bool OSSLRSA::verifyFinal(const ByteString& signature) ByteString digest = firstHash + secondHash; - // Determine the signature NID type - int type = 0; - bool isPSS = false; + int rsaPadding = 0; const EVP_MD* hash = NULL; switch (mechanism) { case AsymMech::RSA_MD5_PKCS: - type = NID_md5; + rsaPadding = RSA_PKCS1_PADDING; + hash = EVP_md5(); break; case AsymMech::RSA_SHA1_PKCS: - type = NID_sha1; + rsaPadding = RSA_PKCS1_PADDING; + hash = EVP_sha1(); break; case AsymMech::RSA_SHA224_PKCS: - type = NID_sha224; + rsaPadding = RSA_PKCS1_PADDING; + hash = EVP_sha224(); break; case AsymMech::RSA_SHA256_PKCS: - type = NID_sha256; + rsaPadding = RSA_PKCS1_PADDING; + hash = EVP_sha256(); break; case AsymMech::RSA_SHA384_PKCS: - type = NID_sha384; + rsaPadding = RSA_PKCS1_PADDING; + hash = EVP_sha384(); break; case AsymMech::RSA_SHA512_PKCS: - type = NID_sha512; + rsaPadding = RSA_PKCS1_PADDING; + hash = EVP_sha512(); break; case AsymMech::RSA_SHA1_PKCS_PSS: - isPSS = true; + rsaPadding = RSA_PKCS1_PSS_PADDING; hash = EVP_sha1(); break; case AsymMech::RSA_SHA224_PKCS_PSS: - isPSS = true; + rsaPadding = RSA_PKCS1_PSS_PADDING; hash = EVP_sha224(); break; case AsymMech::RSA_SHA256_PKCS_PSS: - isPSS = true; + rsaPadding = RSA_PKCS1_PSS_PADDING; hash = EVP_sha256(); break; case AsymMech::RSA_SHA384_PKCS_PSS: - isPSS = true; + rsaPadding = RSA_PKCS1_PSS_PADDING; hash = EVP_sha384(); break; case AsymMech::RSA_SHA512_PKCS_PSS: - isPSS = true; + rsaPadding = RSA_PKCS1_PSS_PADDING; hash = EVP_sha512(); break; case AsymMech::RSA_SSL: - type = NID_md5_sha1; + rsaPadding = RSA_PKCS1_PADDING; + hash = EVP_md5_sha1(); break; default: break; } - // Perform the verify operation - bool rv; - - if (isPSS) - { - ByteString plain; - plain.resize(pk->getN().size()); - int result = RSA_public_decrypt(signature.size(), - (unsigned char*) signature.const_byte_str(), - &plain[0], - pk->getOSSLKey(), - RSA_NO_PADDING); - if (result < 0) - { - rv = false; - ERROR_MSG("RSA public decrypt failed (0x%08X)", ERR_get_error()); - } - else + + EVP_PKEY_CTX* ctx = EVP_PKEY_CTX_new(pk->getOSSLKey(), NULL); + if (ctx == NULL) + { + ERROR_MSG("An error occurred while creating RSA signature context"); + return false; + } + if ((EVP_PKEY_verify_init(ctx) <= 0) || + (EVP_PKEY_CTX_set_rsa_padding(ctx, rsaPadding) <= 0) || + (EVP_PKEY_CTX_set_signature_md(ctx, hash) <= 0)) + { + EVP_PKEY_CTX_free(ctx); + ERROR_MSG("RSA verify set parameters failed (0x%08X)", ERR_get_error()); + return false; + } + if (rsaPadding == RSA_PKCS1_PSS_PADDING) + { + if ((EVP_PKEY_CTX_set_rsa_mgf1_md(ctx, hash) <= 0) || + (EVP_PKEY_CTX_set_rsa_pss_saltlen(ctx, sLen) <= 0)) { - plain.resize(result); - result = RSA_verify_PKCS1_PSS(pk->getOSSLKey(), &digest[0], - hash, &plain[0], sLen); - if (result == 1) - { - rv = true; - } - else - { - rv = false; - ERROR_MSG("RSA PSS verify failed (0x%08X)", ERR_get_error()); - } + EVP_PKEY_CTX_free(ctx); + ERROR_MSG("RSA verify set PSS parameters failed (0x%08X)", ERR_get_error()); + return false; } } - else + int status = EVP_PKEY_verify(ctx, signature.const_byte_str(), signature.size(), digest.const_byte_str(), digest.size()); + if (status < 0) { - rv = (RSA_verify(type, &digest[0], digest.size(), (unsigned char*) signature.const_byte_str(), signature.size(), pk->getOSSLKey()) == 1); - - if (!rv) ERROR_MSG("RSA verify failed (0x%08X)", ERR_get_error()); + EVP_PKEY_CTX_free(ctx); + ERROR_MSG("RSA sign verify failed (0x%08X)", ERR_get_error()); + return false; } - - return rv; + EVP_PKEY_CTX_free(ctx); + return (status == 1); } // Encryption functions bool OSSLRSA::encrypt(PublicKey* publicKey, const ByteString& data, - ByteString& encryptedData, const AsymMech::Type padding) + ByteString& encryptedData, const AsymMech::Type padding, const MechanismParam* mechanismParam) { // Check if the public key is the right type if (!publicKey->isOfType(OSSLRSAPublicKey::type)) @@ -1221,16 +1326,19 @@ bool OSSLRSA::encrypt(PublicKey* publicKey, const ByteString& data, } // Retrieve the OpenSSL key object - RSA* rsa = ((OSSLRSAPublicKey*) publicKey)->getOSSLKey(); + EVP_PKEY* rsa = ((OSSLRSAPublicKey*)publicKey)->getOSSLKey(); + const RSAOaepMechanismParam* oaepParam = NULL; // Check the data and padding algorithm - int osslPadding = 0; + int osslPadding = 0; + const EVP_MD* hash = NULL; + const EVP_MD* mgf = NULL; if (padding == AsymMech::RSA_PKCS) { // The size of the input data cannot be more than the modulus // length of the key - 11 - if (data.size() > (size_t) (RSA_size(rsa) - 11)) + if (data.size() > (size_t)(EVP_PKEY_size(rsa) - 11)) { ERROR_MSG("Too much data supplied for RSA PKCS #1 encryption"); @@ -1241,9 +1349,68 @@ bool OSSLRSA::encrypt(PublicKey* publicKey, const ByteString& data, } else if (padding == AsymMech::RSA_PKCS_OAEP) { + if (mechanismParam == NULL) + { + ERROR_MSG("RSA OAEP mechanism parameter not supplied"); + + return false; + } + if (!mechanismParam->isOfType(RSAOaepMechanismParam::type)) + { + ERROR_MSG("Invalid RSA OAEP mechanism parameter type supplied"); + + return false; + } + oaepParam = dynamic_cast(mechanismParam); + size_t hashLen = 0; + switch (oaepParam->hashAlg) + { + case HashAlgo::SHA1: + hash = EVP_sha1(); + hashLen = 20; + break; + case HashAlgo::SHA224: + hash = EVP_sha224(); + hashLen = 28; + break; + case HashAlgo::SHA256: + hash = EVP_sha256(); + hashLen = 32; + break; + case HashAlgo::SHA384: + hash = EVP_sha384(); + hashLen = 48; + break; + case HashAlgo::SHA512: + hash = EVP_sha512(); + hashLen = 64; + break; + default: + return false; + } + switch (oaepParam->mgfAlg) + { + case AsymRSAMGF::MGF1_SHA1: + mgf = EVP_sha1(); + break; + case AsymRSAMGF::MGF1_SHA224: + mgf = EVP_sha224(); + break; + case AsymRSAMGF::MGF1_SHA256: + mgf = EVP_sha256(); + break; + case AsymRSAMGF::MGF1_SHA384: + mgf = EVP_sha384(); + break; + case AsymRSAMGF::MGF1_SHA512: + mgf = EVP_sha512(); + break; + default: + return false; + } // The size of the input data cannot be more than the modulus - // length of the key - 41 - if (data.size() > (size_t) (RSA_size(rsa) - 41)) + // length of the key - 2 * hashLen - 2 + if (data.size() + (2 * hashLen + 2) > (size_t)(EVP_PKEY_size(rsa))) { ERROR_MSG("Too much data supplied for RSA OAEP encryption"); @@ -1255,13 +1422,12 @@ bool OSSLRSA::encrypt(PublicKey* publicKey, const ByteString& data, else if (padding == AsymMech::RSA) { // The size of the input data should be exactly equal to the modulus length - if (data.size() != (size_t) RSA_size(rsa)) + if (data.size() != (size_t)EVP_PKEY_size(rsa)) { ERROR_MSG("Incorrect amount of input data supplied for raw RSA encryption"); return false; } - osslPadding = RSA_NO_PADDING; } else @@ -1272,21 +1438,59 @@ bool OSSLRSA::encrypt(PublicKey* publicKey, const ByteString& data, } // Perform the RSA operation - encryptedData.resize(RSA_size(rsa)); + size_t encLen = EVP_PKEY_size(rsa); - if (RSA_public_encrypt(data.size(), (unsigned char*) data.const_byte_str(), &encryptedData[0], rsa, osslPadding) == -1) + EVP_PKEY_CTX* ctx = EVP_PKEY_CTX_new(rsa, NULL); + if (ctx == NULL) { - ERROR_MSG("RSA public key encryption failed (0x%08X)", ERR_get_error()); + ERROR_MSG("An error occurred while creating RSA encryption context"); + return false; + } + if ((EVP_PKEY_encrypt_init(ctx) <= 0) || + (EVP_PKEY_CTX_set_rsa_padding(ctx, osslPadding) <= 0)) + { + EVP_PKEY_CTX_free(ctx); + ERROR_MSG("RSA encrypt set padding failed (0x%08X)", ERR_get_error()); + return false; + } + if (osslPadding == RSA_PKCS1_OAEP_PADDING) + { + void* labelData = NULL; + if (oaepParam->label.size() != 0) + labelData = OPENSSL_memdup(oaepParam->label.const_byte_str(), oaepParam->label.size()); + if ((EVP_PKEY_CTX_set_rsa_oaep_md(ctx, hash) <= 0) || + (EVP_PKEY_CTX_set_rsa_mgf1_md(ctx, mgf) <= 0)) + { + OPENSSL_free(labelData); + EVP_PKEY_CTX_free(ctx); + ERROR_MSG("Set OAEP parameters for RSA encryption failed (0x%08X)", ERR_get_error()); + return false; + } + if (EVP_PKEY_CTX_set0_rsa_oaep_label(ctx, labelData, oaepParam->label.size()) <= 0) + { + OPENSSL_free(labelData); + EVP_PKEY_CTX_free(ctx); + ERROR_MSG("Set OAEP label for RSA encryption failed (0x%08X)", ERR_get_error()); + return false; + } + } + encryptedData.resize(encLen); + if (EVP_PKEY_encrypt(ctx, encryptedData.byte_str(), &encLen, data.const_byte_str(), data.size()) <= 0) + { + EVP_PKEY_CTX_free(ctx); + ERROR_MSG("RSA public key encryption failed (0x%08X)", ERR_get_error()); return false; } + EVP_PKEY_CTX_free(ctx); + encryptedData.resize(encLen); return true; } // Decryption functions bool OSSLRSA::decrypt(PrivateKey* privateKey, const ByteString& encryptedData, - ByteString& data, const AsymMech::Type padding) + ByteString& data, const AsymMech::Type padding, const MechanismParam* mechanismParam) { // Check if the private key is the right type if (!privateKey->isOfType(OSSLRSAPrivateKey::type)) @@ -1297,10 +1501,11 @@ bool OSSLRSA::decrypt(PrivateKey* privateKey, const ByteString& encryptedData, } // Retrieve the OpenSSL key object - RSA* rsa = ((OSSLRSAPrivateKey*) privateKey)->getOSSLKey(); + EVP_PKEY* rsa = ((OSSLRSAPrivateKey*)privateKey)->getOSSLKey(); + const RSAOaepMechanismParam* oaepParam = NULL; // Check the input size - if (encryptedData.size() != (size_t) RSA_size(rsa)) + if (encryptedData.size() != (size_t)EVP_PKEY_size(rsa)) { ERROR_MSG("Invalid amount of input data supplied for RSA decryption"); @@ -1309,34 +1514,126 @@ bool OSSLRSA::decrypt(PrivateKey* privateKey, const ByteString& encryptedData, // Determine the OpenSSL padding algorithm int osslPadding = 0; - - switch (padding) + const EVP_MD* hash = NULL; + const EVP_MD* mgf = NULL; + if (padding == AsymMech::RSA_PKCS) { - case AsymMech::RSA_PKCS: - osslPadding = RSA_PKCS1_PADDING; - break; - case AsymMech::RSA_PKCS_OAEP: - osslPadding = RSA_PKCS1_OAEP_PADDING; - break; - case AsymMech::RSA: - osslPadding = RSA_NO_PADDING; - break; - default: - ERROR_MSG("Invalid padding mechanism supplied (%i)", padding); + osslPadding = RSA_PKCS1_PADDING; + } + else if (padding == AsymMech::RSA_PKCS_OAEP) + { + osslPadding = RSA_PKCS1_OAEP_PADDING; + if (mechanismParam == NULL) + { + ERROR_MSG("RSA OAEP mechanism parameter not supplied"); + + return false; + } + if (!mechanismParam->isOfType(RSAOaepMechanismParam::type)) + { + ERROR_MSG("Invalid RSA OAEP mechanism parameter type supplied"); + return false; + } + + + oaepParam = dynamic_cast(mechanismParam); + switch (oaepParam->hashAlg) + { + case HashAlgo::SHA1: + hash = EVP_sha1(); + break; + case HashAlgo::SHA224: + hash = EVP_sha224(); + break; + case HashAlgo::SHA256: + hash = EVP_sha256(); + break; + case HashAlgo::SHA384: + hash = EVP_sha384(); + break; + case HashAlgo::SHA512: + hash = EVP_sha512(); + break; + default: + return false; + } + switch (oaepParam->mgfAlg) + { + case AsymRSAMGF::MGF1_SHA1: + mgf = EVP_sha1(); + break; + case AsymRSAMGF::MGF1_SHA224: + mgf = EVP_sha224(); + break; + case AsymRSAMGF::MGF1_SHA256: + mgf = EVP_sha256(); + break; + case AsymRSAMGF::MGF1_SHA384: + mgf = EVP_sha384(); + break; + case AsymRSAMGF::MGF1_SHA512: + mgf = EVP_sha512(); + break; + default: + return false; + } + } + else if (padding == AsymMech::RSA) + { + osslPadding = RSA_NO_PADDING; + } + else + { + ERROR_MSG("Invalid padding mechanism supplied (%i)", padding); + return false; } // Perform the RSA operation - data.resize(RSA_size(rsa)); - - int decSize = RSA_private_decrypt(encryptedData.size(), (unsigned char*) encryptedData.const_byte_str(), &data[0], rsa, osslPadding); + size_t decSize = EVP_PKEY_size(rsa); - if (decSize == -1) + EVP_PKEY_CTX* ctx = EVP_PKEY_CTX_new(rsa, NULL); + if (ctx == NULL) + { + ERROR_MSG("An error occurred while creating RSA decryption context"); + return false; + } + if ((EVP_PKEY_decrypt_init(ctx) <= 0) || + (EVP_PKEY_CTX_set_rsa_padding(ctx, osslPadding) <= 0)) + { + EVP_PKEY_CTX_free(ctx); + ERROR_MSG("Set padding parameter for RSA decryption failed (0x%08X)", ERR_get_error()); + return false; + } + if (osslPadding == RSA_PKCS1_OAEP_PADDING) + { + void* labelData = NULL; + if (oaepParam->label.size() != 0) + labelData = OPENSSL_memdup(oaepParam->label.const_byte_str(), oaepParam->label.size()); + if ((EVP_PKEY_CTX_set_rsa_oaep_md(ctx, hash) <= 0) || + (EVP_PKEY_CTX_set_rsa_mgf1_md(ctx, mgf) <= 0)) + { + OPENSSL_free(labelData); + EVP_PKEY_CTX_free(ctx); + ERROR_MSG("Set OAEP parameters for RSA decryption failed (0x%08X)", ERR_get_error()); + return false; + } + if (EVP_PKEY_CTX_set0_rsa_oaep_label(ctx, labelData, oaepParam->label.size()) <= 0) + { + OPENSSL_free(labelData); + EVP_PKEY_CTX_free(ctx); + ERROR_MSG("Set OAEP label for RSA decryption failed (0x%08X)", ERR_get_error()); + return false; + } + } + data.resize(decSize); + if (EVP_PKEY_decrypt(ctx, data.byte_str(), &decSize, encryptedData.const_byte_str(), encryptedData.size()) <= 0) { + EVP_PKEY_CTX_free(ctx); ERROR_MSG("RSA private key decryption failed (0x%08X)", ERR_get_error()); - return false; } + EVP_PKEY_CTX_free(ctx); data.resize(decSize); @@ -1344,11 +1641,11 @@ bool OSSLRSA::decrypt(PrivateKey* privateKey, const ByteString& encryptedData, } // Key factory -bool OSSLRSA::generateKeyPair(AsymmetricKeyPair** ppKeyPair, AsymmetricParameters* parameters, RNG* /*rng = NULL */) +bool OSSLRSA::generateKeyPair(AsymmetricKeyPair** ppKeyPair, AsymmetricParameters* parameters, RNG * /*rng = NULL */) { // Check parameters if ((ppKeyPair == NULL) || - (parameters == NULL)) + (parameters == NULL)) { return false; } @@ -1360,7 +1657,7 @@ bool OSSLRSA::generateKeyPair(AsymmetricKeyPair** ppKeyPair, AsymmetricParameter return false; } - RSAParameters* params = (RSAParameters*) parameters; + RSAParameters* params = (RSAParameters*)parameters; if (params->getBitLength() < getMinKeySize() || params->getBitLength() > getMaxKeySize()) { @@ -1386,37 +1683,53 @@ bool OSSLRSA::generateKeyPair(AsymmetricKeyPair** ppKeyPair, AsymmetricParameter } // Generate the key-pair - RSA* rsa = RSA_new(); - if (rsa == NULL) + EVP_PKEY* rsa = NULL; + BIGNUM* bn_e = OSSL::byteString2bn(params->getE()); + // Check if the key was successfully generated + EVP_PKEY_CTX* ctx = EVP_PKEY_CTX_new_id(EVP_PKEY_RSA, NULL); + if (ctx == NULL) { - ERROR_MSG("Failed to instantiate OpenSSL RSA object"); - + ERROR_MSG("Failed to create RSA key creation context"); + BN_free(bn_e); return false; } - - BIGNUM* bn_e = OSSL::byteString2bn(params->getE()); - - // Check if the key was successfully generated - if (!RSA_generate_key_ex(rsa, params->getBitLength(), bn_e, NULL)) + if ((EVP_PKEY_keygen_init(ctx) <= 0) || + (EVP_PKEY_CTX_set_rsa_keygen_bits(ctx, params->getBitLength()) <= 0) || +#if OPENSSL_VERSION_NUMBER >= 0x30000000L + (EVP_PKEY_CTX_set1_rsa_keygen_pubexp(ctx, bn_e) <= 0)) +#else + (EVP_PKEY_CTX_set_rsa_keygen_pubexp(ctx, bn_e) <= 0)) +#endif + { + ERROR_MSG("Failed to set RSA key generation parameters (0x%08X)", ERR_get_error()); + EVP_PKEY_CTX_free(ctx); + BN_free(bn_e); + return false; + } + if (EVP_PKEY_keygen(ctx, &rsa) <= 0) { ERROR_MSG("RSA key generation failed (0x%08X)", ERR_get_error()); + EVP_PKEY_CTX_free(ctx); +#if OPENSSL_VERSION_NUMBER >= 0x30000000L BN_free(bn_e); - RSA_free(rsa); - +#endif return false; } - BN_free(bn_e); + EVP_PKEY_CTX_free(ctx); +#if OPENSSL_VERSION_NUMBER >= 0x30000000L + BN_free(bn_e); +#endif // Create an asymmetric key-pair object to return OSSLRSAKeyPair* kp = new OSSLRSAKeyPair(); - ((OSSLRSAPublicKey*) kp->getPublicKey())->setFromOSSL(rsa); - ((OSSLRSAPrivateKey*) kp->getPrivateKey())->setFromOSSL(rsa); + ((OSSLRSAPublicKey*)kp->getPublicKey())->setFromOSSL(rsa); + ((OSSLRSAPrivateKey*)kp->getPrivateKey())->setFromOSSL(rsa); *ppKeyPair = kp; // Release the key - RSA_free(rsa); + EVP_PKEY_free(rsa); return true; } @@ -1440,7 +1753,7 @@ bool OSSLRSA::reconstructKeyPair(AsymmetricKeyPair** ppKeyPair, ByteString& seri { // Check input if ((ppKeyPair == NULL) || - (serialisedData.size() == 0)) + (serialisedData.size() == 0)) { return false; } @@ -1452,12 +1765,12 @@ bool OSSLRSA::reconstructKeyPair(AsymmetricKeyPair** ppKeyPair, ByteString& seri bool rv = true; - if (!((RSAPublicKey*) kp->getPublicKey())->deserialise(dPub)) + if (!((RSAPublicKey*)kp->getPublicKey())->deserialise(dPub)) { rv = false; } - if (!((RSAPrivateKey*) kp->getPrivateKey())->deserialise(dPriv)) + if (!((RSAPrivateKey*)kp->getPrivateKey())->deserialise(dPriv)) { rv = false; } @@ -1478,7 +1791,7 @@ bool OSSLRSA::reconstructPublicKey(PublicKey** ppPublicKey, ByteString& serialis { // Check input if ((ppPublicKey == NULL) || - (serialisedData.size() == 0)) + (serialisedData.size() == 0)) { return false; } @@ -1501,7 +1814,7 @@ bool OSSLRSA::reconstructPrivateKey(PrivateKey** ppPrivateKey, ByteString& seria { // Check input if ((ppPrivateKey == NULL) || - (serialisedData.size() == 0)) + (serialisedData.size() == 0)) { return false; } @@ -1520,19 +1833,19 @@ bool OSSLRSA::reconstructPrivateKey(PrivateKey** ppPrivateKey, ByteString& seria return true; } -PublicKey* OSSLRSA::newPublicKey() +PublicKey *OSSLRSA::newPublicKey() { - return (PublicKey*) new OSSLRSAPublicKey(); + return (PublicKey*)new OSSLRSAPublicKey(); } -PrivateKey* OSSLRSA::newPrivateKey() +PrivateKey *OSSLRSA::newPrivateKey() { - return (PrivateKey*) new OSSLRSAPrivateKey(); + return (PrivateKey*)new OSSLRSAPrivateKey(); } -AsymmetricParameters* OSSLRSA::newParameters() +AsymmetricParameters *OSSLRSA::newParameters() { - return (AsymmetricParameters*) new RSAParameters(); + return (AsymmetricParameters*)new RSAParameters(); } bool OSSLRSA::reconstructParameters(AsymmetricParameters** ppParams, ByteString& serialisedData) diff --git a/src/lib/crypto/OSSLRSA.h b/src/lib/crypto/OSSLRSA.h index 312f6168c..d087d0e4c 100644 --- a/src/lib/crypto/OSSLRSA.h +++ b/src/lib/crypto/OSSLRSA.h @@ -48,22 +48,24 @@ class OSSLRSA : public AsymmetricAlgorithm virtual ~OSSLRSA(); // Signing functions - virtual bool sign(PrivateKey* privateKey, const ByteString& dataToSign, ByteString& signature, const AsymMech::Type mechanism, const void* param = NULL, const size_t paramLen = 0, const MechanismParam* mechanismParam = NULL); - virtual bool signInit(PrivateKey* privateKey, const AsymMech::Type mechanism, const void* param = NULL, const size_t paramLen = 0, const MechanismParam* mechanismParam = NULL); + virtual bool sign(PrivateKey* privateKey, const ByteString& dataToSign, ByteString& signature, const AsymMech::Type mechanism, const MechanismParam* mechanismParam = NULL); + virtual bool signInit(PrivateKey* privateKey, const AsymMech::Type mechanism, const MechanismParam* mechanismParam = NULL); virtual bool signUpdate(const ByteString& dataToSign); virtual bool signFinal(ByteString& signature); // Verification functions - virtual bool verify(PublicKey* publicKey, const ByteString& originalData, const ByteString& signature, const AsymMech::Type mechanism, const void* param = NULL, const size_t paramLen = 0, const MechanismParam* mechanismParam = NULL); - virtual bool verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, const void* param = NULL, const size_t paramLen = 0, const MechanismParam* mechanismParam = NULL); + virtual bool verify(PublicKey* publicKey, const ByteString& originalData, const ByteString& signature, const AsymMech::Type mechanism, const MechanismParam* mechanismParam = NULL); + virtual bool verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, const MechanismParam* mechanismParam = NULL); virtual bool verifyUpdate(const ByteString& originalData); virtual bool verifyFinal(const ByteString& signature); // Encryption functions - virtual bool encrypt(PublicKey* publicKey, const ByteString& data, ByteString& encryptedData, const AsymMech::Type padding); + virtual bool encrypt(PublicKey* publicKey, const ByteString& data, ByteString& encryptedData, const AsymMech::Type padding, + const MechanismParam* mechanismParam = NULL); // Decryption functions - virtual bool decrypt(PrivateKey* privateKey, const ByteString& encryptedData, ByteString& data, const AsymMech::Type padding); + virtual bool decrypt(PrivateKey* privateKey, const ByteString& encryptedData, ByteString& data, const AsymMech::Type padding, + const MechanismParam* mechanismParam = NULL); // Key factory virtual bool generateKeyPair(AsymmetricKeyPair** ppKeyPair, AsymmetricParameters* parameters, RNG* rng = NULL); diff --git a/src/lib/crypto/OSSLRSAPrivateKey.cpp b/src/lib/crypto/OSSLRSAPrivateKey.cpp index 26065cf31..da16c45c3 100644 --- a/src/lib/crypto/OSSLRSAPrivateKey.cpp +++ b/src/lib/crypto/OSSLRSAPrivateKey.cpp @@ -37,6 +37,11 @@ #include "OSSLUtil.h" #include #include +#if OPENSSL_VERSION_NUMBER >= 0x30000000L +#include +#else +#include +#endif #ifdef WITH_FIPS #include #endif @@ -48,7 +53,7 @@ OSSLRSAPrivateKey::OSSLRSAPrivateKey() rsa = NULL; } -OSSLRSAPrivateKey::OSSLRSAPrivateKey(const RSA* inRSA) +OSSLRSAPrivateKey::OSSLRSAPrivateKey(const EVP_PKEY* inRSA) { rsa = NULL; @@ -58,15 +63,79 @@ OSSLRSAPrivateKey::OSSLRSAPrivateKey(const RSA* inRSA) // Destructor OSSLRSAPrivateKey::~OSSLRSAPrivateKey() { - RSA_free(rsa); + EVP_PKEY_free(rsa); } // The type -/*static*/ const char* OSSLRSAPrivateKey::type = "OpenSSL RSA Private Key"; +/*static*/ const char *OSSLRSAPrivateKey::type = "OpenSSL RSA Private Key"; // Set from OpenSSL representation -void OSSLRSAPrivateKey::setFromOSSL(const RSA* inRSA) +void OSSLRSAPrivateKey::setFromOSSL(const EVP_PKEY* inRSA) { + if (inRSA == NULL) + { + ERROR_MSG("Null RSA key"); + return; + } +#if OPENSSL_VERSION_NUMBER >= 0x30000000L + BIGNUM* bn_p = NULL; + BIGNUM* bn_q = NULL; + BIGNUM* bn_dmp1 = NULL; + BIGNUM* bn_dmq1 = NULL; + BIGNUM* bn_iqmp = NULL; + BIGNUM* bn_n = NULL; + BIGNUM* bn_e = NULL; + BIGNUM* bn_d = NULL; + + EVP_PKEY_get_bn_param(inRSA, "rsa-factor1", &bn_p); + EVP_PKEY_get_bn_param(inRSA, "rsa-factor2", &bn_q); + EVP_PKEY_get_bn_param(inRSA, "rsa-exponent1", &bn_dmp1); + EVP_PKEY_get_bn_param(inRSA, "rsa-exponent2", &bn_dmq1); + EVP_PKEY_get_bn_param(inRSA, "rsa-coefficient1", &bn_iqmp); + EVP_PKEY_get_bn_param(inRSA, "n", &bn_n); + EVP_PKEY_get_bn_param(inRSA, "e", &bn_e); + EVP_PKEY_get_bn_param(inRSA, "d", &bn_d); + if (bn_p) + { + setP(OSSL::bn2ByteString(bn_p)); + BN_free(bn_p); + } + if (bn_q) + { + setQ(OSSL::bn2ByteString(bn_q)); + BN_free(bn_q); + } + if (bn_dmp1) + { + setDP1(OSSL::bn2ByteString(bn_dmp1)); + BN_free(bn_dmp1); + } + if (bn_dmq1) + { + setDQ1(OSSL::bn2ByteString(bn_dmq1)); + BN_free(bn_dmq1); + } + if (bn_iqmp) + { + setPQ(OSSL::bn2ByteString(bn_iqmp)); + BN_free(bn_iqmp); + } + if (bn_n) + { + setN(OSSL::bn2ByteString(bn_n)); + BN_free(bn_n); + } + if (bn_e) + { + setE(OSSL::bn2ByteString(bn_e)); + BN_free(bn_e); + } + if (bn_d) + { + setD(OSSL::bn2ByteString(bn_d)); + BN_free(bn_d); + } +#else const BIGNUM* bn_p = NULL; const BIGNUM* bn_q = NULL; const BIGNUM* bn_dmp1 = NULL; @@ -75,51 +144,46 @@ void OSSLRSAPrivateKey::setFromOSSL(const RSA* inRSA) const BIGNUM* bn_n = NULL; const BIGNUM* bn_e = NULL; const BIGNUM* bn_d = NULL; - - RSA_get0_factors(inRSA, &bn_p, &bn_q); - RSA_get0_crt_params(inRSA, &bn_dmp1, &bn_dmq1, &bn_iqmp); - RSA_get0_key(inRSA, &bn_n, &bn_e, &bn_d); - + const RSA* inRSA1 = EVP_PKEY_get0_RSA(const_cast(inRSA)); + if (inRSA1 != NULL) + { + RSA_get0_factors(inRSA1, &bn_p, &bn_q); + RSA_get0_crt_params(inRSA1, &bn_dmp1, &bn_dmq1, &bn_iqmp); + RSA_get0_key(inRSA1, &bn_n, &bn_e, &bn_d); + } if (bn_p) { - ByteString inP = OSSL::bn2ByteString(bn_p); - setP(inP); + setP(OSSL::bn2ByteString(bn_p)); } if (bn_q) { - ByteString inQ = OSSL::bn2ByteString(bn_q); - setQ(inQ); + setQ(OSSL::bn2ByteString(bn_q)); } if (bn_dmp1) { - ByteString inDP1 = OSSL::bn2ByteString(bn_dmp1); - setDP1(inDP1); + setDP1(OSSL::bn2ByteString(bn_dmp1)); } if (bn_dmq1) { - ByteString inDQ1 = OSSL::bn2ByteString(bn_dmq1); - setDQ1(inDQ1); + setDQ1(OSSL::bn2ByteString(bn_dmq1)); } if (bn_iqmp) { - ByteString inPQ = OSSL::bn2ByteString(bn_iqmp); - setPQ(inPQ); + setPQ(OSSL::bn2ByteString(bn_iqmp)); } if (bn_n) { - ByteString inN = OSSL::bn2ByteString(bn_n); - setN(inN); + setN(OSSL::bn2ByteString(bn_n)); } if (bn_e) { - ByteString inE = OSSL::bn2ByteString(bn_e); - setE(inE); + setE(OSSL::bn2ByteString(bn_e)); } if (bn_d) { - ByteString inD = OSSL::bn2ByteString(bn_d); - setD(inD); + setD(OSSL::bn2ByteString(bn_d)); } +#endif } // Check if the key is of the given type @@ -135,7 +199,7 @@ void OSSLRSAPrivateKey::setP(const ByteString& inP) if (rsa) { - RSA_free(rsa); + EVP_PKEY_free(rsa); rsa = NULL; } } @@ -146,7 +210,7 @@ void OSSLRSAPrivateKey::setQ(const ByteString& inQ) if (rsa) { - RSA_free(rsa); + EVP_PKEY_free(rsa); rsa = NULL; } } @@ -157,7 +221,7 @@ void OSSLRSAPrivateKey::setPQ(const ByteString& inPQ) if (rsa) { - RSA_free(rsa); + EVP_PKEY_free(rsa); rsa = NULL; } } @@ -168,7 +232,7 @@ void OSSLRSAPrivateKey::setDP1(const ByteString& inDP1) if (rsa) { - RSA_free(rsa); + EVP_PKEY_free(rsa); rsa = NULL; } } @@ -179,7 +243,7 @@ void OSSLRSAPrivateKey::setDQ1(const ByteString& inDQ1) if (rsa) { - RSA_free(rsa); + EVP_PKEY_free(rsa); rsa = NULL; } } @@ -190,12 +254,11 @@ void OSSLRSAPrivateKey::setD(const ByteString& inD) if (rsa) { - RSA_free(rsa); + EVP_PKEY_free(rsa); rsa = NULL; } } - // Setters for the RSA public key components void OSSLRSAPrivateKey::setN(const ByteString& inN) { @@ -203,7 +266,7 @@ void OSSLRSAPrivateKey::setN(const ByteString& inN) if (rsa) { - RSA_free(rsa); + EVP_PKEY_free(rsa); rsa = NULL; } } @@ -214,27 +277,22 @@ void OSSLRSAPrivateKey::setE(const ByteString& inE) if (rsa) { - RSA_free(rsa); + EVP_PKEY_free(rsa); rsa = NULL; } } - // Encode into PKCS#8 DER ByteString OSSLRSAPrivateKey::PKCS8Encode() { ByteString der; - if (rsa == NULL) createOSSLKey(); - if (rsa == NULL) return der; - EVP_PKEY* pkey = EVP_PKEY_new(); - if (pkey == NULL) return der; - if (!EVP_PKEY_set1_RSA(pkey, rsa)) - { - EVP_PKEY_free(pkey); + + if (rsa == NULL) + createOSSLKey(); + if (rsa == NULL) + return der; + PKCS8_PRIV_KEY_INFO* p8inf = EVP_PKEY2PKCS8(rsa); + if (p8inf == NULL) return der; - } - PKCS8_PRIV_KEY_INFO* p8inf = EVP_PKEY2PKCS8(pkey); - EVP_PKEY_free(pkey); - if (p8inf == NULL) return der; int len = i2d_PKCS8_PRIV_KEY_INFO(p8inf, NULL); if (len < 0) { @@ -245,7 +303,8 @@ ByteString OSSLRSAPrivateKey::PKCS8Encode() unsigned char* priv = &der[0]; int len2 = i2d_PKCS8_PRIV_KEY_INFO(p8inf, &priv); PKCS8_PRIV_KEY_INFO_free(p8inf); - if (len2 != len) der.wipe(); + if (len2 != len) + der.wipe(); return der; } @@ -253,25 +312,26 @@ ByteString OSSLRSAPrivateKey::PKCS8Encode() bool OSSLRSAPrivateKey::PKCS8Decode(const ByteString& ber) { int len = ber.size(); - if (len <= 0) return false; + if (len <= 0) + return false; const unsigned char* priv = ber.const_byte_str(); PKCS8_PRIV_KEY_INFO* p8 = d2i_PKCS8_PRIV_KEY_INFO(NULL, &priv, len); - if (p8 == NULL) return false; - EVP_PKEY* pkey = EVP_PKCS82PKEY(p8); + if (p8 == NULL) + return false; + EVP_PKEY *pkey = EVP_PKCS82PKEY(p8); PKCS8_PRIV_KEY_INFO_free(p8); - if (pkey == NULL) return false; - RSA* key = EVP_PKEY_get1_RSA(pkey); + if (pkey == NULL) + return false; + setFromOSSL(pkey); EVP_PKEY_free(pkey); - if (key == NULL) return false; - setFromOSSL(key); - RSA_free(key); return true; } // Retrieve the OpenSSL representation of the key -RSA* OSSLRSAPrivateKey::getOSSLKey() +EVP_PKEY *OSSLRSAPrivateKey::getOSSLKey() { - if (rsa == NULL) createOSSLKey(); + if (rsa == NULL) + createOSSLKey(); return rsa; } @@ -279,42 +339,125 @@ RSA* OSSLRSAPrivateKey::getOSSLKey() // Create the OpenSSL representation of the key void OSSLRSAPrivateKey::createOSSLKey() { - if (rsa != NULL) return; + if (rsa != NULL) + return; - rsa = RSA_new(); - if (rsa == NULL) + BIGNUM* bn_p = OSSL::byteString2bn(p); + BIGNUM* bn_q = OSSL::byteString2bn(q); + BIGNUM* bn_dmp1 = OSSL::byteString2bn(dp1); + BIGNUM* bn_dmq1 = OSSL::byteString2bn(dq1); + BIGNUM* bn_iqmp = OSSL::byteString2bn(pq); + BIGNUM* bn_n = OSSL::byteString2bn(n); + BIGNUM* bn_d = OSSL::byteString2bn(d); + BIGNUM* bn_e = OSSL::byteString2bn(e); + +#if OPENSSL_VERSION_NUMBER >= 0x30000000L + OSSL_PARAM_BLD* param_bld = OSSL_PARAM_BLD_new(); + OSSL_PARAM* params = NULL; + bool bBuildErr = false; + if ((param_bld == NULL) || + (bn_n == NULL) || + (bn_e == NULL) || + (bn_d == NULL) || + (OSSL_PARAM_BLD_push_BN(param_bld, "n", bn_n) <= 0) || + (OSSL_PARAM_BLD_push_BN(param_bld, "e", bn_e) <= 0) || + (OSSL_PARAM_BLD_push_BN(param_bld, "d", bn_d) <= 0)) + { + bBuildErr = true; + } + if ((!bBuildErr) && (bn_p != NULL)) + bBuildErr |= (OSSL_PARAM_BLD_push_BN(param_bld, "rsa-factor1", bn_p) <= 0); + if ((!bBuildErr) && (bn_q != NULL)) + bBuildErr |= (OSSL_PARAM_BLD_push_BN(param_bld, "rsa-factor2", bn_q) <= 0); + if ((!bBuildErr) && (bn_dmp1 != NULL)) + bBuildErr |= (OSSL_PARAM_BLD_push_BN(param_bld, "rsa-exponent1", bn_dmp1) <= 0); + if ((!bBuildErr) && (bn_dmq1 != NULL)) + bBuildErr |= (OSSL_PARAM_BLD_push_BN(param_bld, "rsa-exponent2", bn_dmq1) <= 0); + if ((!bBuildErr) && (bn_iqmp != NULL)) + bBuildErr |= (OSSL_PARAM_BLD_push_BN(param_bld, "rsa-coefficient1", bn_iqmp) <= 0); + + if (!bBuildErr) + params = OSSL_PARAM_BLD_to_param(param_bld); + OSSL_PARAM_BLD_free(param_bld); + BN_free(bn_n); + BN_free(bn_e); + BN_free(bn_d); + BN_free(bn_p); + BN_free(bn_q); + BN_free(bn_dmp1); + BN_free(bn_dmq1); + BN_free(bn_iqmp); + if ((bBuildErr) || (params == NULL)) { - ERROR_MSG("Could not create RSA object"); + ERROR_MSG("Could not build RSA key parameters"); return; } + EVP_PKEY_CTX* ctx = EVP_PKEY_CTX_new_from_name(NULL, "RSA", NULL); + if (ctx == NULL) + { + ERROR_MSG("Could not create RSA key creation context"); + OSSL_PARAM_free(params); + return; + } + if ((EVP_PKEY_fromdata_init(ctx) <= 0) || + (EVP_PKEY_fromdata(ctx, &rsa, EVP_PKEY_KEYPAIR, params) <= 0)) + { + ERROR_MSG("Could not create RSA key object"); + OSSL_PARAM_free(params); + EVP_PKEY_CTX_free(ctx); + rsa = NULL; + return; + } + OSSL_PARAM_free(params); + EVP_PKEY_CTX_free(ctx); - // Use the OpenSSL implementation and not any engine +#else + RSA* rsa1 = RSA_new(); + if (rsa1 == NULL) + { + BN_free(bn_n); + BN_free(bn_e); + BN_free(bn_d); + BN_free(bn_p); + BN_free(bn_q); + BN_free(bn_dmp1); + BN_free(bn_dmq1); + BN_free(bn_iqmp); + ERROR_MSG("Could not build RSA object"); + return; + } #if OPENSSL_VERSION_NUMBER < 0x10100000L || defined(LIBRESSL_VERSION_NUMBER) + // Use the OpenSSL implementation and not any engine #ifdef WITH_FIPS if (FIPS_mode()) - RSA_set_method(rsa, FIPS_rsa_pkcs1_ssleay()); + RSA_set_method(rsa1, FIPS_rsa_pkcs1_ssleay()); else - RSA_set_method(rsa, RSA_PKCS1_SSLeay()); + RSA_set_method(rsa1, RSA_PKCS1_SSLeay()); #else - RSA_set_method(rsa, RSA_PKCS1_SSLeay()); + RSA_set_method(rsa1, RSA_PKCS1_SSLeay()); #endif #else - RSA_set_method(rsa, RSA_PKCS1_OpenSSL()); + RSA_set_method(rsa1, RSA_PKCS1_OpenSSL()); +#endif + RSA_set0_factors(rsa1, bn_p, bn_q); + RSA_set0_crt_params(rsa1, bn_dmp1, bn_dmq1, bn_iqmp); + RSA_set0_key(rsa1, bn_n, bn_e, bn_d); + rsa = EVP_PKEY_new(); + if (rsa == NULL) + { + ERROR_MSG("Could not build RSA PKEY"); + RSA_free(rsa1); + return; + } + if (EVP_PKEY_assign_RSA(rsa, rsa1) <= 0) + { + ERROR_MSG("Could not assign RSA PKEY"); + RSA_free(rsa1); + EVP_PKEY_free(rsa); + rsa = NULL; + return; + } #endif - - BIGNUM* bn_p = OSSL::byteString2bn(p); - BIGNUM* bn_q = OSSL::byteString2bn(q); - BIGNUM* bn_dmp1 = OSSL::byteString2bn(dp1); - BIGNUM* bn_dmq1 = OSSL::byteString2bn(dq1); - BIGNUM* bn_iqmp = OSSL::byteString2bn(pq); - BIGNUM* bn_n = OSSL::byteString2bn(n); - BIGNUM* bn_e = OSSL::byteString2bn(e); - BIGNUM* bn_d = OSSL::byteString2bn(d); - - RSA_set0_factors(rsa, bn_p, bn_q); - RSA_set0_crt_params(rsa, bn_dmp1, bn_dmq1, bn_iqmp); - RSA_set0_key(rsa, bn_n, bn_e, bn_d); } - diff --git a/src/lib/crypto/OSSLRSAPrivateKey.h b/src/lib/crypto/OSSLRSAPrivateKey.h index bb876d508..8294eed5a 100644 --- a/src/lib/crypto/OSSLRSAPrivateKey.h +++ b/src/lib/crypto/OSSLRSAPrivateKey.h @@ -35,7 +35,7 @@ #include "config.h" #include "RSAPrivateKey.h" -#include +#include class OSSLRSAPrivateKey : public RSAPrivateKey { @@ -43,7 +43,7 @@ class OSSLRSAPrivateKey : public RSAPrivateKey // Constructors OSSLRSAPrivateKey(); - OSSLRSAPrivateKey(const RSA* inRSA); + OSSLRSAPrivateKey(const EVP_PKEY* inRSA); // Destructor virtual ~OSSLRSAPrivateKey(); @@ -73,14 +73,14 @@ class OSSLRSAPrivateKey : public RSAPrivateKey virtual bool PKCS8Decode(const ByteString& ber); // Set from OpenSSL representation - virtual void setFromOSSL(const RSA* inRSA); + virtual void setFromOSSL(const EVP_PKEY* inRSA); // Retrieve the OpenSSL representation of the key - RSA* getOSSLKey(); + EVP_PKEY* getOSSLKey(); private: // The internal OpenSSL representation - RSA* rsa; + EVP_PKEY* rsa; // Create the OpenSSL representation of the key void createOSSLKey(); diff --git a/src/lib/crypto/OSSLRSAPublicKey.cpp b/src/lib/crypto/OSSLRSAPublicKey.cpp index 2a6893bfc..f14217304 100644 --- a/src/lib/crypto/OSSLRSAPublicKey.cpp +++ b/src/lib/crypto/OSSLRSAPublicKey.cpp @@ -37,6 +37,11 @@ #include "OSSLUtil.h" #include #include +#if OPENSSL_VERSION_NUMBER >= 0x30000000L +#include +#else +#include +#endif #ifdef WITH_FIPS #include #endif @@ -47,7 +52,7 @@ OSSLRSAPublicKey::OSSLRSAPublicKey() rsa = NULL; } -OSSLRSAPublicKey::OSSLRSAPublicKey(const RSA* inRSA) +OSSLRSAPublicKey::OSSLRSAPublicKey(const EVP_PKEY* inRSA) { rsa = NULL; @@ -57,7 +62,7 @@ OSSLRSAPublicKey::OSSLRSAPublicKey(const RSA* inRSA) // Destructor OSSLRSAPublicKey::~OSSLRSAPublicKey() { - RSA_free(rsa); + EVP_PKEY_free(rsa); } // The type @@ -70,23 +75,44 @@ bool OSSLRSAPublicKey::isOfType(const char* inType) } // Set from OpenSSL representation -void OSSLRSAPublicKey::setFromOSSL(const RSA* inRSA) +void OSSLRSAPublicKey::setFromOSSL(const EVP_PKEY* inRSA) { - const BIGNUM* bn_n = NULL; - const BIGNUM* bn_e = NULL; - - RSA_get0_key(inRSA, &bn_n, &bn_e, NULL); - + if (inRSA == NULL) + { + ERROR_MSG("Null RSA key"); + return; + } +#if OPENSSL_VERSION_NUMBER >= 0x30000000L + BIGNUM* bn_n = NULL; + BIGNUM* bn_e = NULL; + EVP_PKEY_get_bn_param(inRSA, "n", &bn_n); + EVP_PKEY_get_bn_param(inRSA, "e", &bn_e); if (bn_n) { - ByteString inN = OSSL::bn2ByteString(bn_n); - setN(inN); + setN(OSSL::bn2ByteString(bn_n)); + BN_free(bn_n); } if (bn_e) { - ByteString inE = OSSL::bn2ByteString(bn_e); - setE(inE); + setE(OSSL::bn2ByteString(bn_e)); + BN_free(bn_e); + } +#else + const BIGNUM* bn_n = NULL; + const BIGNUM* bn_e = NULL; + const RSA* inRSA1 = EVP_PKEY_get0_RSA(const_cast(inRSA)); + if (inRSA1 != NULL) + RSA_get0_key(inRSA1, &bn_n, &bn_e, NULL); + if (bn_n) + { + setN(OSSL::bn2ByteString(bn_n)); } + if (bn_e) + { + setE(OSSL::bn2ByteString(bn_e)); + } +#endif + } // Setters for the RSA public key components @@ -96,7 +122,7 @@ void OSSLRSAPublicKey::setN(const ByteString& inN) if (rsa) { - RSA_free(rsa); + EVP_PKEY_free(rsa); rsa = NULL; } } @@ -107,15 +133,16 @@ void OSSLRSAPublicKey::setE(const ByteString& inE) if (rsa) { - RSA_free(rsa); + EVP_PKEY_free(rsa); rsa = NULL; } } // Retrieve the OpenSSL representation of the key -RSA* OSSLRSAPublicKey::getOSSLKey() +EVP_PKEY* OSSLRSAPublicKey::getOSSLKey() { - if (rsa == NULL) createOSSLKey(); + if (rsa == NULL) + createOSSLKey(); return rsa; } @@ -123,33 +150,90 @@ RSA* OSSLRSAPublicKey::getOSSLKey() // Create the OpenSSL representation of the key void OSSLRSAPublicKey::createOSSLKey() { - if (rsa != NULL) return; + if (rsa != NULL) + return; - rsa = RSA_new(); - if (rsa == NULL) + + BIGNUM* bn_n = OSSL::byteString2bn(n); + BIGNUM* bn_e = OSSL::byteString2bn(e); + +#if OPENSSL_VERSION_NUMBER >= 0x30000000L + OSSL_PARAM_BLD *param_bld = OSSL_PARAM_BLD_new(); + + if ((param_bld == NULL) || + (bn_n == NULL) || + (bn_e == NULL) || + (OSSL_PARAM_BLD_push_BN(param_bld,"n",bn_n) <= 0 ) || + (OSSL_PARAM_BLD_push_BN(param_bld,"e",bn_e) <= 0 )) { - ERROR_MSG("Could not create RSA object"); + OSSL_PARAM_BLD_free(param_bld); + BN_free(bn_n); + BN_free(bn_e); + ERROR_MSG("Could not build RSA public key parameters"); return; } + OSSL_PARAM* params = OSSL_PARAM_BLD_to_param(param_bld); + OSSL_PARAM_BLD_free(param_bld); + BN_free(bn_n); + BN_free(bn_e); - // Use the OpenSSL implementation and not any engine + EVP_PKEY_CTX* ctx = EVP_PKEY_CTX_new_from_name(NULL, "RSA", NULL); + if (ctx == NULL) + { + ERROR_MSG("Could not create RSA public key creation context"); + OSSL_PARAM_free(params); + return; + } + if ((EVP_PKEY_fromdata_init(ctx) <= 0) || + (EVP_PKEY_fromdata(ctx, &rsa, EVP_PKEY_PUBLIC_KEY, params) <= 0)) + { + ERROR_MSG("Could not create public RSA key object"); + OSSL_PARAM_free(params); + EVP_PKEY_CTX_free(ctx); + rsa = NULL; + return; + } + OSSL_PARAM_free(params); + EVP_PKEY_CTX_free(ctx); + +#else + RSA* rsa1 = RSA_new(); + if (rsa1 == NULL) + { + BN_free(bn_n); + BN_free(bn_e); + ERROR_MSG("Could not build RSA object"); + return; + } #if OPENSSL_VERSION_NUMBER < 0x10100000L || defined(LIBRESSL_VERSION_NUMBER) - +// Use the OpenSSL implementation and not any engine #ifdef WITH_FIPS if (FIPS_mode()) - RSA_set_method(rsa, FIPS_rsa_pkcs1_ssleay()); + RSA_set_method(rsa1, FIPS_rsa_pkcs1_ssleay()); else - RSA_set_method(rsa, RSA_PKCS1_SSLeay()); + RSA_set_method(rsa1, RSA_PKCS1_SSLeay()); #else - RSA_set_method(rsa, RSA_PKCS1_SSLeay()); + RSA_set_method(rsa1, RSA_PKCS1_SSLeay()); #endif #else - RSA_set_method(rsa, RSA_PKCS1_OpenSSL()); + RSA_set_method(rsa1, RSA_PKCS1_OpenSSL()); +#endif + RSA_set0_key(rsa1, bn_n, bn_e, NULL); + rsa = EVP_PKEY_new(); + if (rsa == NULL) + { + ERROR_MSG("Could not build RSA PKEY"); + RSA_free(rsa1); + return; + } + if (EVP_PKEY_assign_RSA(rsa,rsa1) <= 0) + { + ERROR_MSG("Could not assign RSA PKEY"); + RSA_free(rsa1); + EVP_PKEY_free(rsa); + rsa = NULL; + return; + } #endif - - BIGNUM* bn_n = OSSL::byteString2bn(n); - BIGNUM* bn_e = OSSL::byteString2bn(e); - - RSA_set0_key(rsa, bn_n, bn_e, NULL); } diff --git a/src/lib/crypto/OSSLRSAPublicKey.h b/src/lib/crypto/OSSLRSAPublicKey.h index 98f99f204..5e0fa52da 100644 --- a/src/lib/crypto/OSSLRSAPublicKey.h +++ b/src/lib/crypto/OSSLRSAPublicKey.h @@ -35,7 +35,7 @@ #include "config.h" #include "RSAPublicKey.h" -#include +#include class OSSLRSAPublicKey : public RSAPublicKey { @@ -43,7 +43,7 @@ class OSSLRSAPublicKey : public RSAPublicKey // Constructors OSSLRSAPublicKey(); - OSSLRSAPublicKey(const RSA* inRSA); + OSSLRSAPublicKey(const EVP_PKEY* inRSA); // Destructor virtual ~OSSLRSAPublicKey(); @@ -59,14 +59,14 @@ class OSSLRSAPublicKey : public RSAPublicKey virtual void setE(const ByteString& inE); // Set from OpenSSL representation - virtual void setFromOSSL(const RSA* inRSA); + virtual void setFromOSSL(const EVP_PKEY* inRSA); // Retrieve the OpenSSL representation of the key - RSA* getOSSLKey(); + EVP_PKEY* getOSSLKey(); private: // The internal OpenSSL representation - RSA* rsa; + EVP_PKEY* rsa; // Create the OpenSSL representation of the key void createOSSLKey(); diff --git a/src/lib/crypto/OSSLUtil.cpp b/src/lib/crypto/OSSLUtil.cpp index 8293624d4..df74f7b18 100644 --- a/src/lib/crypto/OSSLUtil.cpp +++ b/src/lib/crypto/OSSLUtil.cpp @@ -172,14 +172,12 @@ ByteString OSSL::oid2ByteString(int nid) // Convert a ByteString to an OpenSSL EVP_PKEY id int OSSL::byteString2oid(const ByteString& byteString) { - ASN1_OBJECT *oid; - ASN1_PRINTABLESTRING *curve_name; + ASN1_OBJECT *oid = NULL; + ASN1_PRINTABLESTRING *curve_name = NULL; const unsigned char *p = byteString.const_byte_str(); const unsigned char *pp = p; - const unsigned char *data; long length; - int tag, pclass, data_len; - int nid = NID_undef; + int tag, pclass; ASN1_get_object(&pp, &length, &tag, &pclass, byteString.size()); if (pclass == V_ASN1_UNIVERSAL && tag == V_ASN1_OBJECT) @@ -192,50 +190,35 @@ int OSSL::byteString2oid(const ByteString& byteString) return NID_undef; } - nid = OBJ_obj2nid(oid); - ASN1_OBJECT_free(oid); + return OBJ_obj2nid(oid); } else if (pclass == V_ASN1_UNIVERSAL && tag == V_ASN1_PRINTABLESTRING) { /* The final PKCS#11 3.0 expects curve name encoded as PrintableString */ curve_name = d2i_ASN1_PRINTABLESTRING(NULL, &p, byteString.size()); - if (curve_name == NULL) + if (strcmp((char *)curve_name->data, "edwards25519") == 0) { - return NID_undef; - } - - data = ASN1_STRING_get0_data(curve_name); - data_len = ASN1_STRING_length(curve_name); - - if (data_len == 12 && memcmp(data, "edwards25519", data_len) == 0) - { - ASN1_PRINTABLESTRING_free(curve_name); return EVP_PKEY_ED25519; } - if (data_len == 10 && memcmp(data, "curve25519", 10) == 0) + if (strcmp((char *)curve_name->data, "curve25519") == 0) { - ASN1_PRINTABLESTRING_free(curve_name); return EVP_PKEY_X25519; } - if (data_len == 10 && memcmp(data, "edwards448", 10) == 0) + if (strcmp((char *)curve_name->data, "edwards448") == 0) { - ASN1_PRINTABLESTRING_free(curve_name); return EVP_PKEY_ED448; } - if (data_len == 8 && memcmp(data, "curve448", 8) == 0) + if (strcmp((char *)curve_name->data, "curve448") == 0) { - ASN1_PRINTABLESTRING_free(curve_name); return EVP_PKEY_X448; } - - ASN1_PRINTABLESTRING_free(curve_name); } - return nid; + return NID_undef; } #endif diff --git a/src/lib/crypto/RSAMechanismParam.cpp b/src/lib/crypto/RSAMechanismParam.cpp new file mode 100644 index 000000000..6dadc5ac6 --- /dev/null +++ b/src/lib/crypto/RSAMechanismParam.cpp @@ -0,0 +1,71 @@ +/***************************************************************************** + RSAMechanismParam.cpp + + RSA mechanism parameters used for signing/verifying and OAEP encryption/decryption operations + *****************************************************************************/ + +#include "config.h" + +#include "ByteString.h" +#include "MechanismParam.h" +#include "RSAMechanismParam.h" + +RSAOaepMechanismParam::RSAOaepMechanismParam() { + +} + +RSAOaepMechanismParam::RSAOaepMechanismParam(HashAlgo::Type hashAlg,AsymRSAMGF::Type mgfAlg) { + this->hashAlg = hashAlg; + this->mgfAlg = mgfAlg; +} + +RSAOaepMechanismParam::RSAOaepMechanismParam(HashAlgo::Type hashAlg,AsymRSAMGF::Type mgfAlg,ByteString label) { + this->hashAlg = hashAlg; + this->mgfAlg = mgfAlg; + this->label = label; +} + +// Set the type +/*static*/ const char* RSAOaepMechanismParam::type = "RSA OAEP encryption param"; + +RSAOaepMechanismParam* RSAOaepMechanismParam::RSAOaepMechanismParam::clone() const +{ + return new RSAOaepMechanismParam(static_cast(*this)); // call the copy ctor. +} + +// Check if the parameter is of the given type +bool RSAOaepMechanismParam::isOfType(const char* inType) const +{ + return !strcmp(type, inType); +} + +RSAPssMechanismParam::RSAPssMechanismParam() { + +} + +RSAPssMechanismParam::RSAPssMechanismParam(HashAlgo::Type hashAlg,AsymRSAMGF::Type mgfAlg) { + this->hashAlg = hashAlg; + this->mgfAlg = mgfAlg; + this->sLen = 0; +} + +RSAPssMechanismParam::RSAPssMechanismParam(HashAlgo::Type hashAlg,AsymRSAMGF::Type mgfAlg,size_t sLen) { + this->hashAlg = hashAlg; + this->mgfAlg = mgfAlg; + this->sLen = sLen; +} + +// Set the type +/*static*/ const char* RSAPssMechanismParam::type = "RSA PSS signature param"; + +RSAPssMechanismParam* RSAPssMechanismParam::RSAPssMechanismParam::clone() const +{ + return new RSAPssMechanismParam(static_cast(*this)); // call the copy ctor. +} + +// Check if the parameter is of the given type +bool RSAPssMechanismParam::isOfType(const char* inType) const +{ + return !strcmp(type, inType); +} + diff --git a/src/lib/crypto/RSAMechanismParam.h b/src/lib/crypto/RSAMechanismParam.h new file mode 100644 index 000000000..ac606886e --- /dev/null +++ b/src/lib/crypto/RSAMechanismParam.h @@ -0,0 +1,66 @@ +/***************************************************************************** + RSAMechanismParam.h + + RSA mechanism parameters used for signing/verifying and encrypt/decrypt operations + *****************************************************************************/ + +#ifndef _SOFTHSM_V2_RSAMECHANISMPARAM_H +#define _SOFTHSM_V2_RSAMECHANISMPARAM_H + +#include "config.h" + +#include "ByteString.h" +#include "HashAlgorithm.h" +#include "AsymmetricAlgorithm.h" +#include "MechanismParam.h" + +// Limit OAEP label length to avoid overflow +#define MAX_RSA_OAEP_LABEL_LENGTH 0x0fffffff + +// Mechanism parameter for RSA OAEP encryption +class RSAOaepMechanismParam : public MechanismParam +{ +public: + HashAlgo::Type hashAlg; + AsymRSAMGF::Type mgfAlg; + ByteString label; + + // The type + static const char* type; + + RSAOaepMechanismParam(); + + RSAOaepMechanismParam(HashAlgo::Type hashAlg,AsymRSAMGF::Type mgfAlg); + + RSAOaepMechanismParam(HashAlgo::Type hashAlg,AsymRSAMGF::Type mgfAlg,ByteString label); + + RSAOaepMechanismParam* clone() const; + + // Check if the mechanism param is of the given type + virtual bool isOfType(const char* inType) const; +}; + +class RSAPssMechanismParam : public MechanismParam +{ +public: + HashAlgo::Type hashAlg; + AsymRSAMGF::Type mgfAlg; + size_t sLen; + + // The type + static const char* type; + + RSAPssMechanismParam(); + + RSAPssMechanismParam(HashAlgo::Type hashAlg,AsymRSAMGF::Type mgfAlg); + + RSAPssMechanismParam(HashAlgo::Type hashAlg,AsymRSAMGF::Type mgfAlg,size_t sLen); + + RSAPssMechanismParam* clone() const; + + // Check if the mechanism param is of the given type + virtual bool isOfType(const char* inType) const; +}; + +#endif // !_SOFTHSM_V2_RSAMECHANISMPARAM_H + diff --git a/src/lib/crypto/test/MLDSATests.cpp b/src/lib/crypto/test/MLDSATests.cpp index 0a6c2ed9f..0c401ecc9 100644 --- a/src/lib/crypto/test/MLDSATests.cpp +++ b/src/lib/crypto/test/MLDSATests.cpp @@ -206,12 +206,12 @@ void MLDSATests::testSigningTestVector() CPPUNIT_ASSERT(dPriv != NULL); CPPUNIT_ASSERT(pk.size() != 0); - + CPPUNIT_ASSERT(dPriv->PKCS8Decode(pk)); MLDSAMechanismParam context = MLDSAMechanismParam(Hedge::Type::DETERMINISTIC_REQUIRED); - CPPUNIT_ASSERT(mldsa->sign(dPriv, msg, sig, AsymMech::MLDSA, NULL, 0UL, &context)); + CPPUNIT_ASSERT(mldsa->sign(dPriv, msg, sig, AsymMech::MLDSA, &context)); CPPUNIT_ASSERT(sig.size() != 0); CPPUNIT_ASSERT(sig == wantedSig); @@ -230,7 +230,7 @@ void MLDSATests::testSigningTestVectorEmptyContext() CPPUNIT_ASSERT(dPriv != NULL); CPPUNIT_ASSERT(pk.size() != 0); - + CPPUNIT_ASSERT(dPriv->PKCS8Decode(pk)); std::string contextStr = std::string(""); @@ -238,7 +238,7 @@ void MLDSATests::testSigningTestVectorEmptyContext() MLDSAMechanismParam context = MLDSAMechanismParam(Hedge::Type::DETERMINISTIC_REQUIRED, contextBS); - CPPUNIT_ASSERT(mldsa->sign(dPriv, msg, sig, AsymMech::MLDSA, NULL, 0UL, &context)); + CPPUNIT_ASSERT(mldsa->sign(dPriv, msg, sig, AsymMech::MLDSA, &context)); CPPUNIT_ASSERT(sig.size() != 0); CPPUNIT_ASSERT(sig == wantedSig); @@ -256,14 +256,14 @@ void MLDSATests::testSigningTestVectorNonEmptyContext() CPPUNIT_ASSERT(dPriv != NULL); CPPUNIT_ASSERT(pk.size() != 0); - + CPPUNIT_ASSERT(dPriv->PKCS8Decode(pk)); ByteString contextStr = ByteString("436f6e74657874"); MLDSAMechanismParam context = MLDSAMechanismParam(Hedge::Type::DETERMINISTIC_REQUIRED, contextStr); - CPPUNIT_ASSERT(mldsa->sign(dPriv, msg, sig, AsymMech::MLDSA, NULL, 0UL, &context)); + CPPUNIT_ASSERT(mldsa->sign(dPriv, msg, sig, AsymMech::MLDSA, &context)); CPPUNIT_ASSERT(sig.size() != 0); CPPUNIT_ASSERT(sig == wantedSig); @@ -281,14 +281,14 @@ void MLDSATests::testSigningTestVectorLongestContext() CPPUNIT_ASSERT(dPriv != NULL); CPPUNIT_ASSERT(pk.size() != 0); - + CPPUNIT_ASSERT(dPriv->PKCS8Decode(pk)); ByteString contextStr = ByteString("414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141"); MLDSAMechanismParam context = MLDSAMechanismParam(Hedge::Type::DETERMINISTIC_REQUIRED, contextStr); - CPPUNIT_ASSERT(mldsa->sign(dPriv, msg, sig, AsymMech::MLDSA, NULL, 0UL, &context)); + CPPUNIT_ASSERT(mldsa->sign(dPriv, msg, sig, AsymMech::MLDSA, &context)); CPPUNIT_ASSERT(sig.size() != 0); CPPUNIT_ASSERT(sig == wantedSig); @@ -305,14 +305,14 @@ void MLDSATests::testSigningTestVectorContextTooLong() CPPUNIT_ASSERT(dPriv != NULL); CPPUNIT_ASSERT(pk.size() != 0); - + CPPUNIT_ASSERT(dPriv->PKCS8Decode(pk)); ByteString* contextStr = new ByteString("41414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141"); MLDSAMechanismParam context = MLDSAMechanismParam(Hedge::Type::DETERMINISTIC_REQUIRED, *contextStr); - CPPUNIT_ASSERT(!mldsa->sign(dPriv, msg, sig, AsymMech::MLDSA, NULL, 0UL, &context)); + CPPUNIT_ASSERT(!mldsa->sign(dPriv, msg, sig, AsymMech::MLDSA, &context)); mldsa->recyclePrivateKey(dPriv); } @@ -332,7 +332,7 @@ void MLDSATests::testVerifyingTestVector() MLDSAMechanismParam context = MLDSAMechanismParam(Hedge::Type::DETERMINISTIC_REQUIRED); - CPPUNIT_ASSERT(mldsa->verify(dPub, msg, sig, AsymMech::MLDSA, NULL, 0UL, &context)); + CPPUNIT_ASSERT(mldsa->verify(dPub, msg, sig, AsymMech::MLDSA, &context)); mldsa->recyclePublicKey(dPub); } @@ -355,7 +355,7 @@ void MLDSATests::testVerifyingTestVectorEmptyContext() MLDSAMechanismParam context = MLDSAMechanismParam(Hedge::Type::DETERMINISTIC_REQUIRED, *contextBS); - CPPUNIT_ASSERT(mldsa->verify(dPub, msg, sig, AsymMech::MLDSA, NULL, 0UL, &context)); + CPPUNIT_ASSERT(mldsa->verify(dPub, msg, sig, AsymMech::MLDSA, &context)); mldsa->recyclePublicKey(dPub); } @@ -377,7 +377,7 @@ void MLDSATests::testVerifyingTestVectorNonEmptyContext() MLDSAMechanismParam context = MLDSAMechanismParam(Hedge::Type::DETERMINISTIC_REQUIRED, *contextStr); - CPPUNIT_ASSERT(mldsa->verify(dPub, msg, sig, AsymMech::MLDSA, NULL, 0UL, &context)); + CPPUNIT_ASSERT(mldsa->verify(dPub, msg, sig, AsymMech::MLDSA, &context)); mldsa->recyclePublicKey(dPub); } @@ -399,7 +399,7 @@ void MLDSATests::testVerifyingTestVectorLongestContext() MLDSAMechanismParam context = MLDSAMechanismParam(Hedge::Type::DETERMINISTIC_REQUIRED, *contextStr); - CPPUNIT_ASSERT(mldsa->verify(dPub, msg, sig, AsymMech::MLDSA, NULL, 0UL, &context)); + CPPUNIT_ASSERT(mldsa->verify(dPub, msg, sig, AsymMech::MLDSA, &context)); mldsa->recyclePublicKey(dPub); } @@ -421,262 +421,11 @@ void MLDSATests::testVerifyingTestVectorContextTooLong() MLDSAMechanismParam context = MLDSAMechanismParam(Hedge::Type::DETERMINISTIC_REQUIRED, *contextStr); - CPPUNIT_ASSERT(!mldsa->verify(dPub, msg, sig, AsymMech::MLDSA, NULL, 0UL, &context)); + CPPUNIT_ASSERT(!mldsa->verify(dPub, msg, sig, AsymMech::MLDSA, &context)); mldsa->recyclePublicKey(dPub); } -void MLDSATests::testSigningMultiPartVerifying() -{ - for (const unsigned long parameterSet : allParameterSets) - { - // Get domain parameters - MLDSAParameters *p = new MLDSAParameters(); - CPPUNIT_ASSERT(p != NULL); - p->setParameterSet(parameterSet); - - // Generate key-pair - AsymmetricKeyPair *kp; - CPPUNIT_ASSERT(mldsa->generateKeyPair(&kp, p)); - - // Generate some data to sign - ByteString dataToSign; - ByteString dataToSignMultipart; - - RNG *rng = CryptoFactory::i()->getRNG(); - CPPUNIT_ASSERT(rng != NULL); - - CPPUNIT_ASSERT(rng->generateRandom(dataToSign, 567)); - CPPUNIT_ASSERT(rng->generateRandom(dataToSignMultipart, 890)); - - ByteString all = dataToSign + dataToSignMultipart; - - ByteString sigMultiPart; - CPPUNIT_ASSERT(mldsa->signInit(kp->getPrivateKey(), AsymMech::MLDSA)); - CPPUNIT_ASSERT(mldsa->signUpdate(dataToSign)); - CPPUNIT_ASSERT(mldsa->signUpdate(dataToSignMultipart)); - CPPUNIT_ASSERT(mldsa->signFinal(sigMultiPart)); - - CPPUNIT_ASSERT(mldsa->verify(kp->getPublicKey(), all, sigMultiPart, AsymMech::MLDSA)); - - mldsa->recycleKeyPair(kp); - mldsa->recycleParameters(p); - } -} - -void MLDSATests::testSigningMultiPartVerifyingWithContext() -{ - for (const unsigned long parameterSet : allParameterSets) - { - // Get domain parameters - MLDSAParameters *p = new MLDSAParameters(); - CPPUNIT_ASSERT(p != NULL); - p->setParameterSet(parameterSet); - - // Generate key-pair - AsymmetricKeyPair *kp; - CPPUNIT_ASSERT(mldsa->generateKeyPair(&kp, p)); - - // Generate some data to sign - ByteString dataToSign; - ByteString dataToSignMultipart; - - RNG *rng = CryptoFactory::i()->getRNG(); - CPPUNIT_ASSERT(rng != NULL); - - CPPUNIT_ASSERT(rng->generateRandom(dataToSign, 567)); - CPPUNIT_ASSERT(rng->generateRandom(dataToSignMultipart, 890)); - - ByteString all = dataToSign + dataToSignMultipart; - - const std::string contextStr("HEDGE_PREFERRED"); - const ByteString contextBS((const unsigned char*)contextStr.data(), contextStr.size()); - - MLDSAMechanismParam context = MLDSAMechanismParam(Hedge::Type::HEDGE_PREFERRED, contextBS); - - ByteString sigMultiPart; - CPPUNIT_ASSERT(mldsa->signInit(kp->getPrivateKey(), AsymMech::MLDSA, NULL, 0, &context)); - CPPUNIT_ASSERT(mldsa->signUpdate(dataToSign)); - CPPUNIT_ASSERT(mldsa->signUpdate(dataToSignMultipart)); - CPPUNIT_ASSERT(mldsa->signFinal(sigMultiPart)); - - CPPUNIT_ASSERT(mldsa->verify(kp->getPublicKey(), all, sigMultiPart, AsymMech::MLDSA, NULL, 0, &context)); - - mldsa->recycleKeyPair(kp); - mldsa->recycleParameters(p); - } -} - -void MLDSATests::testSigningVerifyingMultiPart() -{ - for (const unsigned long parameterSet : allParameterSets) - { - // Get domain parameters - MLDSAParameters *p = new MLDSAParameters(); - CPPUNIT_ASSERT(p != NULL); - p->setParameterSet(parameterSet); - - // Generate key-pair - AsymmetricKeyPair *kp; - CPPUNIT_ASSERT(mldsa->generateKeyPair(&kp, p)); - - // Generate some data to sign - ByteString dataToSign; - ByteString dataToSignMultipart; - - RNG *rng = CryptoFactory::i()->getRNG(); - CPPUNIT_ASSERT(rng != NULL); - - CPPUNIT_ASSERT(rng->generateRandom(dataToSign, 567)); - CPPUNIT_ASSERT(rng->generateRandom(dataToSignMultipart, 890)); - - ByteString all = dataToSign + dataToSignMultipart; - - ByteString sig; - CPPUNIT_ASSERT(mldsa->sign(kp->getPrivateKey(), all, sig, AsymMech::MLDSA, NULL, 0, NULL)); - - CPPUNIT_ASSERT(mldsa->verifyInit(kp->getPublicKey(), AsymMech::MLDSA, NULL, 0, NULL)); - CPPUNIT_ASSERT(mldsa->verifyUpdate(dataToSign)); - CPPUNIT_ASSERT(mldsa->verifyUpdate(dataToSignMultipart)); - CPPUNIT_ASSERT(mldsa->verifyFinal(sig)); - - mldsa->recycleKeyPair(kp); - mldsa->recycleParameters(p); - } -} - -void MLDSATests::testSigningVerifyingMultiPartWithContext() -{ - for (const unsigned long parameterSet : allParameterSets) - { - // Get domain parameters - MLDSAParameters *p = new MLDSAParameters(); - CPPUNIT_ASSERT(p != NULL); - p->setParameterSet(parameterSet); - - // Generate key-pair - AsymmetricKeyPair *kp; - CPPUNIT_ASSERT(mldsa->generateKeyPair(&kp, p)); - - // Generate some data to sign - ByteString dataToSign; - ByteString dataToSignMultipart; - - RNG *rng = CryptoFactory::i()->getRNG(); - CPPUNIT_ASSERT(rng != NULL); - - CPPUNIT_ASSERT(rng->generateRandom(dataToSign, 567)); - CPPUNIT_ASSERT(rng->generateRandom(dataToSignMultipart, 890)); - - ByteString all = dataToSign + dataToSignMultipart; - - const std::string contextStr("HEDGE_PREFERRED"); - const ByteString contextBS((const unsigned char*)contextStr.data(), contextStr.size()); - - MLDSAMechanismParam context = MLDSAMechanismParam(Hedge::Type::HEDGE_PREFERRED, contextBS); - - ByteString sigMultiPart; - - CPPUNIT_ASSERT(mldsa->sign(kp->getPrivateKey(), all, sigMultiPart, AsymMech::MLDSA, NULL, 0, &context)); - - CPPUNIT_ASSERT(mldsa->verifyInit(kp->getPublicKey(), AsymMech::MLDSA, NULL, 0, &context)); - CPPUNIT_ASSERT(mldsa->verifyUpdate(dataToSign)); - CPPUNIT_ASSERT(mldsa->verifyUpdate(dataToSignMultipart)); - CPPUNIT_ASSERT(mldsa->verifyFinal(sigMultiPart)); - - mldsa->recycleKeyPair(kp); - mldsa->recycleParameters(p); - } -} - -void MLDSATests::testSigningMultiPartVerifyingMultiPart() -{ - for (const unsigned long parameterSet : allParameterSets) - { - // Get domain parameters - MLDSAParameters *p = new MLDSAParameters(); - CPPUNIT_ASSERT(p != NULL); - p->setParameterSet(parameterSet); - - // Generate key-pair - AsymmetricKeyPair *kp; - CPPUNIT_ASSERT(mldsa->generateKeyPair(&kp, p)); - - // Generate some data to sign - ByteString dataToSign; - ByteString dataToSignMultipart; - - RNG *rng = CryptoFactory::i()->getRNG(); - CPPUNIT_ASSERT(rng != NULL); - - CPPUNIT_ASSERT(rng->generateRandom(dataToSign, 567)); - CPPUNIT_ASSERT(rng->generateRandom(dataToSignMultipart, 890)); - - ByteString all = dataToSign + dataToSignMultipart; - - ByteString sigMultiPart; - CPPUNIT_ASSERT(mldsa->signInit(kp->getPrivateKey(), AsymMech::MLDSA, NULL, 0, NULL)); - CPPUNIT_ASSERT(mldsa->signUpdate(dataToSign)); - CPPUNIT_ASSERT(mldsa->signUpdate(dataToSignMultipart)); - CPPUNIT_ASSERT(mldsa->signFinal(sigMultiPart)); - - CPPUNIT_ASSERT(mldsa->verifyInit(kp->getPublicKey(), AsymMech::MLDSA, NULL, 0, NULL)); - CPPUNIT_ASSERT(mldsa->verifyUpdate(dataToSign)); - CPPUNIT_ASSERT(mldsa->verifyUpdate(dataToSignMultipart)); - CPPUNIT_ASSERT(mldsa->verifyFinal(sigMultiPart)); - - mldsa->recycleKeyPair(kp); - mldsa->recycleParameters(p); - } -} - -void MLDSATests::testSigningMultiPartVerifyingMultiPartWithContext() -{ - for (const unsigned long parameterSet : allParameterSets) - { - // Get domain parameters - MLDSAParameters *p = new MLDSAParameters(); - CPPUNIT_ASSERT(p != NULL); - p->setParameterSet(parameterSet); - - // Generate key-pair - AsymmetricKeyPair *kp; - CPPUNIT_ASSERT(mldsa->generateKeyPair(&kp, p)); - - // Generate some data to sign - ByteString dataToSign; - ByteString dataToSignMultipart; - - RNG *rng = CryptoFactory::i()->getRNG(); - CPPUNIT_ASSERT(rng != NULL); - - CPPUNIT_ASSERT(rng->generateRandom(dataToSign, 567)); - CPPUNIT_ASSERT(rng->generateRandom(dataToSignMultipart, 890)); - - ByteString all = dataToSign + dataToSignMultipart; - - const std::string contextStr("HEDGE_PREFERRED"); - const ByteString contextBS((const unsigned char*)contextStr.data(), contextStr.size()); - - MLDSAMechanismParam context = MLDSAMechanismParam(Hedge::Type::HEDGE_PREFERRED, contextBS); - - ByteString sigMultiPart; - - CPPUNIT_ASSERT(mldsa->signInit(kp->getPrivateKey(), AsymMech::MLDSA, NULL, 0, &context)); - CPPUNIT_ASSERT(mldsa->signUpdate(dataToSign)); - CPPUNIT_ASSERT(mldsa->signUpdate(dataToSignMultipart)); - CPPUNIT_ASSERT(mldsa->signFinal(sigMultiPart)); - - CPPUNIT_ASSERT(mldsa->verifyInit(kp->getPublicKey(), AsymMech::MLDSA, NULL, 0, &context)); - CPPUNIT_ASSERT(mldsa->verifyUpdate(dataToSign)); - CPPUNIT_ASSERT(mldsa->verifyUpdate(dataToSignMultipart)); - CPPUNIT_ASSERT(mldsa->verifyFinal(sigMultiPart)); - - mldsa->recycleKeyPair(kp); - mldsa->recycleParameters(p); - } -} - void MLDSATests::testSigningVerifyingHedgePreferred() { @@ -701,10 +450,10 @@ void MLDSATests::testSigningVerifyingHedgePreferred() // Sign the data ByteString sig; - CPPUNIT_ASSERT(mldsa->sign(kp->getPrivateKey(), dataToSign, sig, AsymMech::MLDSA, NULL, 0UL, &context)); + CPPUNIT_ASSERT(mldsa->sign(kp->getPrivateKey(), dataToSign, sig, AsymMech::MLDSA, &context)); // And verify it - CPPUNIT_ASSERT(mldsa->verify(kp->getPublicKey(), dataToSign, sig, AsymMech::MLDSA, NULL, 0UL, &context)); + CPPUNIT_ASSERT(mldsa->verify(kp->getPublicKey(), dataToSign, sig, AsymMech::MLDSA, &context)); mldsa->recycleKeyPair(kp); mldsa->recycleParameters(p); @@ -736,10 +485,10 @@ void MLDSATests::testSigningVerifyingHedgePreferredWithContext() // Sign the data ByteString sig; - CPPUNIT_ASSERT(mldsa->sign(kp->getPrivateKey(), dataToSign, sig, AsymMech::MLDSA, NULL, 0UL, &context)); + CPPUNIT_ASSERT(mldsa->sign(kp->getPrivateKey(), dataToSign, sig, AsymMech::MLDSA, &context)); // And verify it - CPPUNIT_ASSERT(mldsa->verify(kp->getPublicKey(), dataToSign, sig, AsymMech::MLDSA, NULL, 0UL, &context)); + CPPUNIT_ASSERT(mldsa->verify(kp->getPublicKey(), dataToSign, sig, AsymMech::MLDSA, &context)); mldsa->recycleKeyPair(kp); mldsa->recycleParameters(p); @@ -771,7 +520,7 @@ void MLDSATests::testSigningVerifyingHedgePreferredWithContextTooLong() // Sign the data ByteString sig; - CPPUNIT_ASSERT_EQUAL(false, mldsa->sign(kp->getPrivateKey(), dataToSign, sig, AsymMech::MLDSA, NULL, 0UL, &context)); + CPPUNIT_ASSERT_EQUAL(false, mldsa->sign(kp->getPrivateKey(), dataToSign, sig, AsymMech::MLDSA, &context)); mldsa->recycleKeyPair(kp); mldsa->recycleParameters(p); @@ -800,10 +549,10 @@ void MLDSATests::testSigningVerifyingHedgeRequired() // Sign the data ByteString sig; - CPPUNIT_ASSERT(mldsa->sign(kp->getPrivateKey(), dataToSign, sig, AsymMech::MLDSA, NULL, 0UL, &context)); + CPPUNIT_ASSERT(mldsa->sign(kp->getPrivateKey(), dataToSign, sig, AsymMech::MLDSA, &context)); // And verify it - CPPUNIT_ASSERT(mldsa->verify(kp->getPublicKey(), dataToSign, sig, AsymMech::MLDSA, NULL, 0UL, &context)); + CPPUNIT_ASSERT(mldsa->verify(kp->getPublicKey(), dataToSign, sig, AsymMech::MLDSA, &context)); mldsa->recycleKeyPair(kp); mldsa->recycleParameters(p); @@ -835,10 +584,10 @@ void MLDSATests::testSigningVerifyingHedgeRequiredWithContext() // Sign the data ByteString sig; - CPPUNIT_ASSERT(mldsa->sign(kp->getPrivateKey(), dataToSign, sig, AsymMech::MLDSA, NULL, 0UL, &context)); + CPPUNIT_ASSERT(mldsa->sign(kp->getPrivateKey(), dataToSign, sig, AsymMech::MLDSA, &context)); // And verify it - CPPUNIT_ASSERT(mldsa->verify(kp->getPublicKey(), dataToSign, sig, AsymMech::MLDSA, NULL, 0UL, &context)); + CPPUNIT_ASSERT(mldsa->verify(kp->getPublicKey(), dataToSign, sig, AsymMech::MLDSA, &context)); mldsa->recycleKeyPair(kp); mldsa->recycleParameters(p); @@ -870,7 +619,7 @@ void MLDSATests::testSigningVerifyingHedgeRequiredWithContextTooLong() // Sign the data ByteString sig; - CPPUNIT_ASSERT(!mldsa->sign(kp->getPrivateKey(), dataToSign, sig, AsymMech::MLDSA, NULL, 0UL, &context)); + CPPUNIT_ASSERT(!mldsa->sign(kp->getPrivateKey(), dataToSign, sig, AsymMech::MLDSA, &context)); mldsa->recycleKeyPair(kp); mldsa->recycleParameters(p); @@ -899,10 +648,10 @@ void MLDSATests::testSigningVerifyingDeterministic() // Sign the data ByteString sig; - CPPUNIT_ASSERT(mldsa->sign(kp->getPrivateKey(), dataToSign, sig, AsymMech::MLDSA, NULL, 0UL, &context)); + CPPUNIT_ASSERT(mldsa->sign(kp->getPrivateKey(), dataToSign, sig, AsymMech::MLDSA, &context)); // And verify it - CPPUNIT_ASSERT(mldsa->verify(kp->getPublicKey(), dataToSign, sig, AsymMech::MLDSA, NULL, 0UL, &context)); + CPPUNIT_ASSERT(mldsa->verify(kp->getPublicKey(), dataToSign, sig, AsymMech::MLDSA, &context)); mldsa->recycleKeyPair(kp); mldsa->recycleParameters(p); @@ -934,10 +683,10 @@ void MLDSATests::testSigningVerifyingDeterministicWithContext() // Sign the data ByteString sig; - CPPUNIT_ASSERT(mldsa->sign(kp->getPrivateKey(), dataToSign, sig, AsymMech::MLDSA, NULL, 0UL, &context)); + CPPUNIT_ASSERT(mldsa->sign(kp->getPrivateKey(), dataToSign, sig, AsymMech::MLDSA, &context)); // And verify it - CPPUNIT_ASSERT(mldsa->verify(kp->getPublicKey(), dataToSign, sig, AsymMech::MLDSA, NULL, 0UL, &context)); + CPPUNIT_ASSERT(mldsa->verify(kp->getPublicKey(), dataToSign, sig, AsymMech::MLDSA, &context)); mldsa->recycleKeyPair(kp); mldsa->recycleParameters(p); @@ -969,7 +718,7 @@ void MLDSATests::testSigningVerifyingDeterministicWithContextTooLong() // Sign the data ByteString sig; - CPPUNIT_ASSERT(!mldsa->sign(kp->getPrivateKey(), dataToSign, sig, AsymMech::MLDSA, NULL, 0UL, &context)); + CPPUNIT_ASSERT(!mldsa->sign(kp->getPrivateKey(), dataToSign, sig, AsymMech::MLDSA, &context)); mldsa->recycleKeyPair(kp); mldsa->recycleParameters(p); diff --git a/src/lib/crypto/test/MLDSATests.h b/src/lib/crypto/test/MLDSATests.h index 56a4609ac..090eed3b0 100644 --- a/src/lib/crypto/test/MLDSATests.h +++ b/src/lib/crypto/test/MLDSATests.h @@ -17,12 +17,6 @@ class MLDSATests : public CppUnit::TestFixture CPPUNIT_TEST(testSerialisation); CPPUNIT_TEST(testPKCS8); CPPUNIT_TEST(testSigningVerifying); - CPPUNIT_TEST(testSigningMultiPartVerifying); - CPPUNIT_TEST(testSigningMultiPartVerifyingWithContext); - CPPUNIT_TEST(testSigningVerifyingMultiPart); - CPPUNIT_TEST(testSigningVerifyingMultiPartWithContext); - CPPUNIT_TEST(testSigningMultiPartVerifyingMultiPart); - CPPUNIT_TEST(testSigningMultiPartVerifyingMultiPartWithContext); CPPUNIT_TEST(testSigningTestVector); CPPUNIT_TEST(testSigningTestVectorEmptyContext); CPPUNIT_TEST(testSigningTestVectorNonEmptyContext); @@ -49,12 +43,6 @@ class MLDSATests : public CppUnit::TestFixture void testSerialisation(); void testPKCS8(); void testSigningVerifying(); - void testSigningMultiPartVerifying(); - void testSigningMultiPartVerifyingWithContext(); - void testSigningVerifyingMultiPart(); - void testSigningVerifyingMultiPartWithContext(); - void testSigningMultiPartVerifyingMultiPart(); - void testSigningMultiPartVerifyingMultiPartWithContext(); void testSigningTestVector(); void testSigningTestVectorEmptyContext(); void testSigningTestVectorNonEmptyContext(); diff --git a/src/lib/crypto/test/RSATests.cpp b/src/lib/crypto/test/RSATests.cpp index 6af1e19fb..e8e665ca1 100644 --- a/src/lib/crypto/test/RSATests.cpp +++ b/src/lib/crypto/test/RSATests.cpp @@ -38,6 +38,7 @@ #include "RNG.h" #include "AsymmetricKeyPair.h" #include "AsymmetricAlgorithm.h" +#include "RSAMechanismParam.h" #include "RSAParameters.h" #include "RSAPublicKey.h" #include "RSAPrivateKey.h" @@ -278,7 +279,7 @@ void RSATests::testSigningVerifying() #endif /* Max salt length for SHA512 and 1024-bit RSA is 62 bytes */ - RSA_PKCS_PSS_PARAMS pssParams[] = { + RSAPssMechanismParam pssParams[] = { { HashAlgo::SHA1, AsymRSAMGF::MGF1_SHA1, 20 }, { HashAlgo::SHA224, AsymRSAMGF::MGF1_SHA224, 0 }, { HashAlgo::SHA256, AsymRSAMGF::MGF1_SHA256, 0 }, @@ -307,35 +308,29 @@ void RSATests::testSigningVerifying() for (std::vector::iterator m = mechanisms.begin(); m != mechanisms.end(); m++) { ByteString blockSignature, singlePartSignature; - void* param = NULL; - size_t paramLen = 0; + RSAPssMechanismParam* mechanismParam = NULL; bool isPSS = false; switch (*m) { case AsymMech::RSA_SHA1_PKCS_PSS: - param = &pssParams[0]; - paramLen = sizeof(pssParams[0]); + mechanismParam = &pssParams[0]; isPSS = true; break; case AsymMech::RSA_SHA224_PKCS_PSS: - param = &pssParams[1]; - paramLen = sizeof(pssParams[1]); + mechanismParam = &pssParams[1]; isPSS = true; break; case AsymMech::RSA_SHA256_PKCS_PSS: - param = &pssParams[2]; - paramLen = sizeof(pssParams[2]); + mechanismParam = &pssParams[2]; isPSS = true; break; case AsymMech::RSA_SHA384_PKCS_PSS: - param = &pssParams[3]; - paramLen = sizeof(pssParams[3]); + mechanismParam = &pssParams[3]; isPSS = true; break; case AsymMech::RSA_SHA512_PKCS_PSS: - param = &pssParams[4]; - paramLen = sizeof(pssParams[4]); + mechanismParam = &pssParams[4]; isPSS = true; break; default: @@ -343,14 +338,14 @@ void RSATests::testSigningVerifying() } // Sign the data in blocks - CPPUNIT_ASSERT(rsa->signInit(kp->getPrivateKey(), *m, param, paramLen)); + CPPUNIT_ASSERT(rsa->signInit(kp->getPrivateKey(), *m, mechanismParam)); CPPUNIT_ASSERT(rsa->signUpdate(dataToSign.substr(0, 134))); CPPUNIT_ASSERT(rsa->signUpdate(dataToSign.substr(134, 289))); CPPUNIT_ASSERT(rsa->signUpdate(dataToSign.substr(134 + 289))); CPPUNIT_ASSERT(rsa->signFinal(blockSignature)); // Sign the data in one pass - CPPUNIT_ASSERT(rsa->sign(kp->getPrivateKey(), dataToSign, singlePartSignature, *m, param, paramLen)); + CPPUNIT_ASSERT(rsa->sign(kp->getPrivateKey(), dataToSign, singlePartSignature, *m, mechanismParam)); // If it is not a PSS signature, check if the two signatures match if (!isPSS) @@ -360,14 +355,14 @@ void RSATests::testSigningVerifying() } // Now perform multi-pass verification - CPPUNIT_ASSERT(rsa->verifyInit(kp->getPublicKey(), *m, param, paramLen)); + CPPUNIT_ASSERT(rsa->verifyInit(kp->getPublicKey(), *m, mechanismParam)); CPPUNIT_ASSERT(rsa->verifyUpdate(dataToSign.substr(0, 125))); CPPUNIT_ASSERT(rsa->verifyUpdate(dataToSign.substr(125, 247))); CPPUNIT_ASSERT(rsa->verifyUpdate(dataToSign.substr(125 + 247))); CPPUNIT_ASSERT(rsa->verifyFinal(blockSignature)); // And single-pass verification - CPPUNIT_ASSERT(rsa->verify(kp->getPublicKey(), dataToSign, singlePartSignature, *m, param, paramLen)); + CPPUNIT_ASSERT(rsa->verify(kp->getPublicKey(), dataToSign, singlePartSignature, *m, mechanismParam)); } // Test mechanisms that do not perform internal hashing @@ -399,28 +394,28 @@ void RSATests::testSigningVerifying() #ifdef WITH_RAW_PSS // Test raw (SHA1) PKCS PSS signing CPPUNIT_ASSERT(rng->generateRandom(dataToSign, 20)); - CPPUNIT_ASSERT(rsa->sign(kp->getPrivateKey(), dataToSign, signature, AsymMech::RSA_PKCS_PSS, &pssParams[0], sizeof(pssParams[0]))); - CPPUNIT_ASSERT(rsa->verify(kp->getPublicKey(), dataToSign, signature, AsymMech::RSA_PKCS_PSS, &pssParams[0], sizeof(pssParams[0]))); + CPPUNIT_ASSERT(rsa->sign(kp->getPrivateKey(), dataToSign, signature, AsymMech::RSA_PKCS_PSS, &pssParams[0])); + CPPUNIT_ASSERT(rsa->verify(kp->getPublicKey(), dataToSign, signature, AsymMech::RSA_PKCS_PSS, &pssParams[0])); // Test raw (SHA224) PKCS PSS signing CPPUNIT_ASSERT(rng->generateRandom(dataToSign, 28)); - CPPUNIT_ASSERT(rsa->sign(kp->getPrivateKey(), dataToSign, signature, AsymMech::RSA_PKCS_PSS, &pssParams[1], sizeof(pssParams[1]))); - CPPUNIT_ASSERT(rsa->verify(kp->getPublicKey(), dataToSign, signature, AsymMech::RSA_PKCS_PSS, &pssParams[1], sizeof(pssParams[1]))); + CPPUNIT_ASSERT(rsa->sign(kp->getPrivateKey(), dataToSign, signature, AsymMech::RSA_PKCS_PSS, &pssParams[1])); + CPPUNIT_ASSERT(rsa->verify(kp->getPublicKey(), dataToSign, signature, AsymMech::RSA_PKCS_PSS, &pssParams[1])); // Test raw (SHA256) PKCS PSS signing CPPUNIT_ASSERT(rng->generateRandom(dataToSign, 32)); - CPPUNIT_ASSERT(rsa->sign(kp->getPrivateKey(), dataToSign, signature, AsymMech::RSA_PKCS_PSS, &pssParams[2], sizeof(pssParams[2]))); - CPPUNIT_ASSERT(rsa->verify(kp->getPublicKey(), dataToSign, signature, AsymMech::RSA_PKCS_PSS, &pssParams[2], sizeof(pssParams[2]))); + CPPUNIT_ASSERT(rsa->sign(kp->getPrivateKey(), dataToSign, signature, AsymMech::RSA_PKCS_PSS, &pssParams[2])); + CPPUNIT_ASSERT(rsa->verify(kp->getPublicKey(), dataToSign, signature, AsymMech::RSA_PKCS_PSS, &pssParams[2])); // Test raw (SHA384) PKCS PSS signing CPPUNIT_ASSERT(rng->generateRandom(dataToSign, 48)); - CPPUNIT_ASSERT(rsa->sign(kp->getPrivateKey(), dataToSign, signature, AsymMech::RSA_PKCS_PSS, &pssParams[3], sizeof(pssParams[3]))); - CPPUNIT_ASSERT(rsa->verify(kp->getPublicKey(), dataToSign, signature, AsymMech::RSA_PKCS_PSS, &pssParams[3], sizeof(pssParams[3]))); + CPPUNIT_ASSERT(rsa->sign(kp->getPrivateKey(), dataToSign, signature, AsymMech::RSA_PKCS_PSS, &pssParams[3])); + CPPUNIT_ASSERT(rsa->verify(kp->getPublicKey(), dataToSign, signature, AsymMech::RSA_PKCS_PSS, &pssParams[3])); // Test raw (SHA512) PKCS PSS signing CPPUNIT_ASSERT(rng->generateRandom(dataToSign, 64)); - CPPUNIT_ASSERT(rsa->sign(kp->getPrivateKey(), dataToSign, signature, AsymMech::RSA_PKCS_PSS, &pssParams[4], sizeof(pssParams[4]))); - CPPUNIT_ASSERT(rsa->verify(kp->getPublicKey(), dataToSign, signature, AsymMech::RSA_PKCS_PSS, &pssParams[4], sizeof(pssParams[4]))); + CPPUNIT_ASSERT(rsa->sign(kp->getPrivateKey(), dataToSign, signature, AsymMech::RSA_PKCS_PSS, &pssParams[4])); + CPPUNIT_ASSERT(rsa->verify(kp->getPublicKey(), dataToSign, signature, AsymMech::RSA_PKCS_PSS, &pssParams[4])); #endif rsa->recycleKeyPair(kp); @@ -601,7 +596,9 @@ void RSATests::testEncryptDecrypt() { AsymmetricKeyPair* kp; RSAParameters p; - + char TestLabel[] = "THIS IS A GOOD DAY"; + char InvalidLabel[] = "ALWAYS BAD"; + // Public exponents to test std::vector exponents; exponents.push_back("010001"); @@ -614,14 +611,23 @@ void RSATests::testEncryptDecrypt() keySizes.push_back(1024); keySizes.push_back(1280); keySizes.push_back(2048); - //keySizes.push_back(4096); + keySizes.push_back(4096); // Paddings to test std::vector paddings; paddings.push_back(AsymMech::RSA_PKCS); - paddings.push_back(AsymMech::RSA_PKCS_OAEP); paddings.push_back(AsymMech::RSA); + //OAEP parameters for test + std::vector oaep_parameters; + oaep_parameters.push_back({HashAlgo::SHA1,AsymRSAMGF::MGF1_SHA1}); + oaep_parameters.push_back({HashAlgo::SHA256,AsymRSAMGF::MGF1_SHA256}); + oaep_parameters.push_back({HashAlgo::SHA384,AsymRSAMGF::MGF1_SHA384}); + oaep_parameters.push_back({HashAlgo::SHA512,AsymRSAMGF::MGF1_SHA512}); + oaep_parameters.push_back({HashAlgo::SHA1,AsymRSAMGF::MGF1_SHA256}); + oaep_parameters.push_back({HashAlgo::SHA512,AsymRSAMGF::MGF1_SHA224, TestLabel}); + oaep_parameters.push_back({HashAlgo::SHA1,AsymRSAMGF::MGF1_SHA256, TestLabel}); + for (std::vector::iterator e = exponents.begin(); e != exponents.end(); e++) { for (std::vector::iterator k = keySizes.begin(); k != keySizes.end(); k++) @@ -638,15 +644,13 @@ void RSATests::testEncryptDecrypt() { // Generate some test data to encrypt based on the selected padding ByteString testData; + RSAOaepMechanismParam* mechanismParam = NULL; if (*pad == AsymMech::RSA_PKCS) { CPPUNIT_ASSERT(rng->generateRandom(testData, (*k >> 3) - 12)); } - else if (*pad == AsymMech::RSA_PKCS_OAEP) - { - CPPUNIT_ASSERT(rng->generateRandom(testData, (*k >> 3) - 42)); - } + else if (*pad == AsymMech::RSA) { CPPUNIT_ASSERT(rng->generateRandom(testData, *k >> 3)); @@ -659,9 +663,52 @@ void RSATests::testEncryptDecrypt() // Encrypt the data ByteString encryptedData; + CPPUNIT_ASSERT(rsa->encrypt(kp->getPublicKey(), testData, encryptedData, *pad, mechanismParam)); + // The encrypted data length should equal the modulus length + CPPUNIT_ASSERT(encryptedData.size() == (*k >> 3)); + CPPUNIT_ASSERT(encryptedData != testData); + + // Now decrypt the data + ByteString decryptedData; - CPPUNIT_ASSERT(rsa->encrypt(kp->getPublicKey(), testData, encryptedData, *pad)); + CPPUNIT_ASSERT(rsa->decrypt(kp->getPrivateKey(), encryptedData, decryptedData, *pad, mechanismParam)); + // Check that the data was properly decrypted + CPPUNIT_ASSERT(decryptedData == testData); + } + // OAEP encryption test + for (std::vector::iterator par = oaep_parameters.begin(); par != oaep_parameters.end(); par++) + { + // Generate some test data to encrypt based on the selected padding + ByteString testData; + RSAOaepMechanismParam mechanismParam(par->hashAlg, par->mgfAlg, par->label); + size_t hashLen = 0; + switch (par->hashAlg) + { + case HashAlgo::SHA1: + hashLen = 20; + break; + case HashAlgo::SHA224: + hashLen = 28; + break; + case HashAlgo::SHA256: + hashLen = 32; + break; + case HashAlgo::SHA384: + hashLen = 48; + break; + case HashAlgo::SHA512: + hashLen = 64; + break; + default: + CPPUNIT_ASSERT(true == false); + } + if ((*k >> 3) <= (hashLen*2)+2) + continue; //skip test - hash too long for key size + CPPUNIT_ASSERT(rng->generateRandom(testData, (*k >> 3) - 2 - hashLen*2)); + // Encrypt the data + ByteString encryptedData; + CPPUNIT_ASSERT(rsa->encrypt(kp->getPublicKey(), testData, encryptedData, AsymMech::RSA_PKCS_OAEP, &mechanismParam)); // The encrypted data length should equal the modulus length CPPUNIT_ASSERT(encryptedData.size() == (*k >> 3)); CPPUNIT_ASSERT(encryptedData != testData); @@ -669,10 +716,18 @@ void RSATests::testEncryptDecrypt() // Now decrypt the data ByteString decryptedData; - CPPUNIT_ASSERT(rsa->decrypt(kp->getPrivateKey(), encryptedData, decryptedData, *pad)); + CPPUNIT_ASSERT(rsa->decrypt(kp->getPrivateKey(), encryptedData, decryptedData, AsymMech::RSA_PKCS_OAEP, &mechanismParam)); // Check that the data was properly decrypted CPPUNIT_ASSERT(decryptedData == testData); + + // Now decrypt the data with invalid label + ByteString decryptedData1; + RSAOaepMechanismParam mechanismParam1; + mechanismParam1.hashAlg = par->hashAlg; + mechanismParam1.mgfAlg = par->mgfAlg; + mechanismParam1.label = InvalidLabel; + CPPUNIT_ASSERT(rsa->decrypt(kp->getPrivateKey(), encryptedData, decryptedData1, AsymMech::RSA_PKCS_OAEP, &mechanismParam1) == false); } rsa->recycleKeyPair(kp); diff --git a/src/lib/object_store/Directory.cpp b/src/lib/object_store/Directory.cpp index d1a0a324d..8776c6422 100644 --- a/src/lib/object_store/Directory.cpp +++ b/src/lib/object_store/Directory.cpp @@ -108,7 +108,7 @@ bool Directory::refresh() if (dir == NULL) { - ERROR_MSG("Failed to open directory %s (%s)", path.c_str(), strerror(errno)); + DEBUG_MSG("Failed to open directory %s", path.c_str()); return false; } @@ -168,10 +168,6 @@ bool Directory::refresh() DEBUG_MSG("File not used %s", name.c_str()); } } - else - { - WARNING_MSG("Failed to stat %s (%s)", fullPath.c_str(), strerror(errno)); - } } } @@ -196,7 +192,7 @@ bool Directory::refresh() if (errno == ENOENT) goto finished; - ERROR_MSG("Failed to open directory %s (%s)", path.c_str(), strerror(errno)); + DEBUG_MSG("Failed to open directory %s", path.c_str()); return false; } @@ -222,8 +218,6 @@ bool Directory::refresh() valid = true; - DEBUG_MSG("Directory %s refreshed: %zu files, %zu subdirs", path.c_str(), files.size(), subDirs.size()); - return true; } @@ -261,16 +255,10 @@ bool Directory::rmdir(std::string name, bool doRefresh /* = false */) #ifndef _WIN32 if (::rmdir(fullPath.c_str()) != 0) - { - ERROR_MSG("Failed to remove directory %s (%s)", fullPath.c_str(), strerror(errno)); return false; - } #else if (_rmdir(fullPath.c_str()) != 0) - { - ERROR_MSG("Failed to remove directory %s (%s)", fullPath.c_str(), strerror(errno)); return false; - } #endif if (doRefresh) return refresh(); @@ -283,19 +271,9 @@ bool Directory::remove(std::string name) std::string fullPath = path + OS_PATHSEP + name; #ifndef _WIN32 - if (::remove(fullPath.c_str()) != 0) - { - ERROR_MSG("Failed to remove file %s (%s)", fullPath.c_str(), strerror(errno)); - return false; - } - return refresh(); + return (!::remove(fullPath.c_str()) && refresh()); #else - if (_unlink(fullPath.c_str()) != 0) - { - ERROR_MSG("Failed to remove file %s (%s)", fullPath.c_str(), strerror(errno)); - return false; - } - return refresh(); + return (!_unlink(fullPath.c_str()) && refresh()); #endif } diff --git a/src/lib/object_store/Generation.cpp b/src/lib/object_store/Generation.cpp index f22695ea8..cb858796c 100644 --- a/src/lib/object_store/Generation.cpp +++ b/src/lib/object_store/Generation.cpp @@ -96,7 +96,6 @@ bool Generation::wasUpdated() if (!genFile.isValid()) { - WARNING_MSG("Generation::wasUpdated: could not open %s; assuming updated", path.c_str()); return true; } @@ -106,13 +105,11 @@ bool Generation::wasUpdated() if (!genFile.readULong(onDisk)) { - WARNING_MSG("Generation::wasUpdated: could not read %s; assuming updated", path.c_str()); return true; } if (onDisk != currentValue) { - DEBUG_MSG("Generation::wasUpdated: %s changed %lu -> %lu", path.c_str(), currentValue, onDisk); currentValue = onDisk; return true; } @@ -125,7 +122,6 @@ bool Generation::wasUpdated() if (!objectFile.isValid()) { - WARNING_MSG("Generation::wasUpdated: could not open %s; assuming updated", path.c_str()); return true; } @@ -135,15 +131,9 @@ bool Generation::wasUpdated() if (!objectFile.readULong(onDisk)) { - WARNING_MSG("Generation::wasUpdated: could not read %s; assuming updated", path.c_str()); return true; } - if (onDisk != currentValue) - { - DEBUG_MSG("Generation::wasUpdated: %s changed %lu -> %lu", path.c_str(), currentValue, onDisk); - } - return (onDisk != currentValue); } } @@ -165,7 +155,6 @@ void Generation::commit() if (!genFile.isValid()) { - WARNING_MSG("Generation::commit: could not open %s for writing", path.c_str()); return; } @@ -186,8 +175,6 @@ void Generation::commit() genFile.unlock(); - DEBUG_MSG("Generation::commit: initialized %s to %lu", path.c_str(), currentValue); - return; } @@ -215,12 +202,6 @@ void Generation::commit() currentValue = onDisk; pendingUpdate = false; - - DEBUG_MSG("Generation::commit: %s committed generation %lu", path.c_str(), currentValue); - } - else - { - WARNING_MSG("Generation::commit: failed to update %s", path.c_str()); } genFile.unlock(); diff --git a/src/lib/object_store/OSToken.cpp b/src/lib/object_store/OSToken.cpp index aecc9f00e..7cfb3db83 100644 --- a/src/lib/object_store/OSToken.cpp +++ b/src/lib/object_store/OSToken.cpp @@ -62,7 +62,7 @@ OSToken::OSToken(const std::string inTokenPath, int inUmask) tokenMutex = MutexFactory::i()->getMutex(); valid = (gen != NULL) && (tokenMutex != NULL) && tokenDir->isValid() && tokenObject->valid; - DEBUG_MSG("Opened token %s (valid=%d)", tokenPath.c_str(), valid); + DEBUG_MSG("Opened token %s", tokenPath.c_str()); index(true); } @@ -596,18 +596,9 @@ bool OSToken::index(bool isFirstTime /* = false */) } // Check the integrity - if (!tokenDir->refresh()) + if (!tokenDir->refresh() || !tokenObject->valid) { - ERROR_MSG("Failed to refresh token directory %s", tokenPath.c_str()); - - valid = false; - - return false; - } - - if (!tokenObject->valid) - { - ERROR_MSG("Token object is not valid for %s", tokenPath.c_str()); + ERROR_MSG("Token integrity check failed"); valid = false; @@ -667,13 +658,8 @@ bool OSToken::index(bool isFirstTime /* = false */) currentFiles = newSet; - DEBUG_MSG("%zu objects were added and %zu objects were removed", addedFiles.size(), removedFiles.size()); - DEBUG_MSG("Current directory set contains %zu objects", currentFiles.size()); - - if (!removedFiles.empty()) - { - WARNING_MSG("Token %s: %zu object(s) no longer on disk", tokenPath.c_str(), removedFiles.size()); - } + DEBUG_MSG("%d objects were added and %d objects were removed", addedFiles.size(), removedFiles.size()); + DEBUG_MSG("Current directory set contains %d objects", currentFiles.size()); // Now update the set of objects @@ -723,8 +709,6 @@ bool OSToken::index(bool isFirstTime /* = false */) } else { - WARNING_MSG("Token %s: invalidating object %s (file no longer present)", - tokenPath.c_str(), fileObject->getFilename().c_str()); fileObject->invalidate(); } } @@ -732,7 +716,7 @@ bool OSToken::index(bool isFirstTime /* = false */) // Set the new objects objects = newObjects; - DEBUG_MSG("The token now contains %zu objects", objects.size()); + DEBUG_MSG("The token now contains %d objects", objects.size()); return true; } diff --git a/src/lib/object_store/ObjectFile.cpp b/src/lib/object_store/ObjectFile.cpp index d3cd9f796..7bd743edf 100644 --- a/src/lib/object_store/ObjectFile.cpp +++ b/src/lib/object_store/ObjectFile.cpp @@ -275,8 +275,6 @@ bool ObjectFile::isValid() // been deleted. void ObjectFile::invalidate() { - DEBUG_MSG("Object %s invalidated", path.c_str()); - valid = false; discardAttributes(); @@ -680,7 +678,7 @@ void ObjectFile::store(bool isCommit /* = false */) if (!objectFile.isValid()) { - ERROR_MSG("Cannot open object %s for writing", path.c_str()); + DEBUG_MSG("Cannot open object %s for writing", path.c_str()); valid = false; @@ -695,8 +693,6 @@ void ObjectFile::store(bool isCommit /* = false */) if (!writeAttributes(objectFile)) { - ERROR_MSG("Failed to write attributes to object %s", path.c_str()); - valid = false; return; @@ -706,8 +702,6 @@ void ObjectFile::store(bool isCommit /* = false */) { if (!writeAttributes(objectFile)) { - ERROR_MSG("Failed to commit attributes to object %s", path.c_str()); - valid = false; return; diff --git a/src/lib/test/AsymEncryptDecryptTests.cpp b/src/lib/test/AsymEncryptDecryptTests.cpp index 2a537d00a..279b35f2f 100644 --- a/src/lib/test/AsymEncryptDecryptTests.cpp +++ b/src/lib/test/AsymEncryptDecryptTests.cpp @@ -82,10 +82,10 @@ CK_RV AsymEncryptDecryptTests::generateRsaKeyPair(CK_SESSION_HANDLE hSession, CK &hPuk, &hPrk) ); } -void AsymEncryptDecryptTests::rsaEncryptDecrypt(CK_MECHANISM_TYPE mechanismType, CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE hPublicKey, CK_OBJECT_HANDLE hPrivateKey) +void AsymEncryptDecryptTests::rsaEncryptDecrypt(CK_MECHANISM_TYPE mechanismType, CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE hPublicKey, CK_OBJECT_HANDLE hPrivateKey, + CK_RSA_PKCS_OAEP_PARAMS* oaepParam) { CK_MECHANISM mechanism = { mechanismType, NULL_PTR, 0 }; - CK_RSA_PKCS_OAEP_PARAMS oaepParams = { CKM_SHA_1, CKG_MGF1_SHA1, 1, NULL_PTR, 0 }; CK_BYTE plainText[] = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B,0x0C, 0x0D, 0x0F }; CK_BYTE cipherText[256]; CK_ULONG ulCipherTextLen; @@ -95,8 +95,11 @@ void AsymEncryptDecryptTests::rsaEncryptDecrypt(CK_MECHANISM_TYPE mechanismType, if (mechanismType == CKM_RSA_PKCS_OAEP) { - mechanism.pParameter = &oaepParams; - mechanism.ulParameterLen = sizeof(oaepParams); + mechanism.pParameter = oaepParam; + if (oaepParam != NULL_PTR) + mechanism.ulParameterLen = sizeof(CK_RSA_PKCS_OAEP_PARAMS); + else + mechanism.ulParameterLen = 0L; } rv = CRYPTOKI_F_PTR( C_EncryptInit(hSession,&mechanism,hPublicKey) ); @@ -114,6 +117,27 @@ void AsymEncryptDecryptTests::rsaEncryptDecrypt(CK_MECHANISM_TYPE mechanismType, CPPUNIT_ASSERT(rv==CKR_OK); CPPUNIT_ASSERT(memcmp(plainText, &recoveredText[ulRecoveredTextLen-sizeof(plainText)], sizeof(plainText)) == 0); + + // Attempt to decrypt with wrong label + if (mechanismType == CKM_RSA_PKCS_OAEP) + { + const char InvalidDecryptionLabel[] = "INVALID DECRYPTION LABEL"; + CK_RSA_PKCS_OAEP_PARAMS invalid_oaepParam; + invalid_oaepParam.hashAlg = oaepParam->hashAlg; + invalid_oaepParam.mgf = oaepParam->mgf; + invalid_oaepParam.source = 1; + invalid_oaepParam.pSourceData = (void*)InvalidDecryptionLabel; + invalid_oaepParam.ulSourceDataLen = strlen(InvalidDecryptionLabel); + mechanism.pParameter = &invalid_oaepParam; + mechanism.ulParameterLen = sizeof(CK_RSA_PKCS_OAEP_PARAMS); + rv = CRYPTOKI_F_PTR( C_DecryptInit(hSession,&mechanism,hPrivateKey) ); + CPPUNIT_ASSERT(rv==CKR_OK); + + ulRecoveredTextLen = sizeof(recoveredText); + rv = CRYPTOKI_F_PTR( C_Decrypt(hSession,cipherText,ulCipherTextLen,recoveredText,&ulRecoveredTextLen) ); + CPPUNIT_ASSERT(rv==CKR_ENCRYPTED_DATA_INVALID); + } + } // Check that RSA OAEP mechanism properly validates all input parameters @@ -137,10 +161,11 @@ void AsymEncryptDecryptTests::rsaOAEPParams(CK_SESSION_HANDLE hSession, CK_OBJEC rv = CRYPTOKI_F_PTR( C_EncryptInit(hSession,&mechanism,hPublicKey) ); CPPUNIT_ASSERT(rv==CKR_ARGUMENTS_BAD); - oaepParams.hashAlg = CKM_SHA_1; + // This parameter is valid + /*oaepParams.hashAlg = CKM_SHA_1; oaepParams.mgf = CKG_MGF1_SHA256; rv = CRYPTOKI_F_PTR( C_EncryptInit(hSession,&mechanism,hPublicKey) ); - CPPUNIT_ASSERT(rv==CKR_ARGUMENTS_BAD); + CPPUNIT_ASSERT(rv==CKR_ARGUMENTS_BAD);*/ oaepParams.mgf = CKG_MGF1_SHA1; oaepParams.source = CKZ_DATA_SPECIFIED - 1; @@ -200,5 +225,32 @@ void AsymEncryptDecryptTests::testRsaEncryptDecrypt() rsaOAEPParams(hSessionRO,hPublicKey); rsaEncryptDecrypt(CKM_RSA_PKCS,hSessionRO,hPublicKey,hPrivateKey); rsaEncryptDecrypt(CKM_RSA_X_509,hSessionRO,hPublicKey,hPrivateKey); - rsaEncryptDecrypt(CKM_RSA_PKCS_OAEP,hSessionRO,hPublicKey,hPrivateKey); + // Test RSA encrypt/decrypt with and without label + CK_RSA_PKCS_OAEP_PARAMS oaepParams; + const char EncryptLabel[] = "TEST ENCRYPTION LABEL"; + oaepParams = { CKM_SHA_1, CKG_MGF1_SHA1, 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_SHA224, CKG_MGF1_SHA224, 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_SHA256, CKG_MGF1_SHA256, 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_SHA384, CKG_MGF1_SHA384, 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_SHA512, CKG_MGF1_SHA512, 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/AsymEncryptDecryptTests.h b/src/lib/test/AsymEncryptDecryptTests.h index 0b8db0405..8e0fdda86 100644 --- a/src/lib/test/AsymEncryptDecryptTests.h +++ b/src/lib/test/AsymEncryptDecryptTests.h @@ -48,7 +48,7 @@ class AsymEncryptDecryptTests : public TestsBase protected: CK_RV generateRsaKeyPair(CK_SESSION_HANDLE hSession, CK_BBOOL bTokenPuk, CK_BBOOL bPrivatePuk, CK_BBOOL bTokenPrk, CK_BBOOL bPrivatePrk, CK_OBJECT_HANDLE &hPuk, CK_OBJECT_HANDLE &hPrk); - void rsaEncryptDecrypt(CK_MECHANISM_TYPE mechanismType, CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE hPublicKey, CK_OBJECT_HANDLE hPrivateKey); + void rsaEncryptDecrypt(CK_MECHANISM_TYPE mechanismType, CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE hPublicKey, CK_OBJECT_HANDLE hPrivateKey, CK_RSA_PKCS_OAEP_PARAMS* oaepParam = NULL); void rsaOAEPParams(CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE hPublicKey); }; diff --git a/src/lib/test/SignVerifyTests.cpp b/src/lib/test/SignVerifyTests.cpp index a85b91d52..f3afa88b4 100644 --- a/src/lib/test/SignVerifyTests.cpp +++ b/src/lib/test/SignVerifyTests.cpp @@ -1285,191 +1285,3 @@ void SignVerifyTests::testMacSignVerify() macSignVerify(CKM_AES_CMAC, hSessionRO, hKey); } -// C_SignInit with mismatched key type must return CKR_KEY_TYPE_INCONSISTENT, -// not accept the key and crash during C_Sign. -void SignVerifyTests::testSignInitWrongKeyType() -{ - CK_RV rv; - CK_SESSION_HANDLE hSession; - - // Just make sure that we finalize any previous tests - CRYPTOKI_F_PTR( C_Finalize(NULL_PTR) ); - - rv = CRYPTOKI_F_PTR( C_Initialize(NULL_PTR) ); - CPPUNIT_ASSERT(rv == CKR_OK); - - rv = CRYPTOKI_F_PTR( C_OpenSession(m_initializedTokenSlotID, CKF_SERIAL_SESSION | CKF_RW_SESSION, NULL_PTR, NULL_PTR, &hSession) ); - CPPUNIT_ASSERT(rv == CKR_OK); - - rv = CRYPTOKI_F_PTR( C_Login(hSession, CKU_USER, m_userPin1, m_userPin1Length) ); - CPPUNIT_ASSERT(rv == CKR_OK); - - // EC private key with RSA/DSA mechanisms - CK_OBJECT_HANDLE hEcPub = CK_INVALID_HANDLE, hEcPriv = CK_INVALID_HANDLE; -#ifdef WITH_ECC - rv = generateEC("P-256", hSession, IN_SESSION, IS_PUBLIC, IN_SESSION, IS_PUBLIC, hEcPub, hEcPriv); - CPPUNIT_ASSERT(rv == CKR_OK); - - // RSA mechanisms with EC key - CK_MECHANISM_TYPE rsaMechs[] = { - CKM_RSA_PKCS, CKM_RSA_X_509, - CKM_SHA1_RSA_PKCS, CKM_SHA256_RSA_PKCS, - CKM_SHA384_RSA_PKCS, CKM_SHA512_RSA_PKCS - }; - for (size_t i = 0; i < sizeof(rsaMechs)/sizeof(rsaMechs[0]); i++) - { - CK_MECHANISM mechanism = { rsaMechs[i], NULL_PTR, 0 }; - rv = CRYPTOKI_F_PTR( C_SignInit(hSession, &mechanism, hEcPriv) ); - CPPUNIT_ASSERT(rv == CKR_KEY_TYPE_INCONSISTENT); - } - - // DSA mechanisms with EC key - CK_MECHANISM_TYPE dsaMechs[] = { CKM_DSA, CKM_DSA_SHA1, CKM_DSA_SHA256 }; - for (size_t i = 0; i < sizeof(dsaMechs)/sizeof(dsaMechs[0]); i++) - { - CK_MECHANISM mechanism = { dsaMechs[i], NULL_PTR, 0 }; - rv = CRYPTOKI_F_PTR( C_SignInit(hSession, &mechanism, hEcPriv) ); - CPPUNIT_ASSERT(rv == CKR_KEY_TYPE_INCONSISTENT); - } -#endif - - // RSA private key with ECDSA/EdDSA mechanisms - CK_OBJECT_HANDLE hRsaPub = CK_INVALID_HANDLE, hRsaPriv = CK_INVALID_HANDLE; - rv = generateRSA(hSession, IN_SESSION, IS_PUBLIC, IN_SESSION, IS_PUBLIC, hRsaPub, hRsaPriv); - CPPUNIT_ASSERT(rv == CKR_OK); - -#ifdef WITH_ECC - // ECDSA mechanisms with RSA key - CK_MECHANISM_TYPE ecdsaMechs[] = { CKM_ECDSA, CKM_ECDSA_SHA1, CKM_ECDSA_SHA256 }; - for (size_t i = 0; i < sizeof(ecdsaMechs)/sizeof(ecdsaMechs[0]); i++) - { - CK_MECHANISM mechanism = { ecdsaMechs[i], NULL_PTR, 0 }; - rv = CRYPTOKI_F_PTR( C_SignInit(hSession, &mechanism, hRsaPriv) ); - CPPUNIT_ASSERT(rv == CKR_KEY_TYPE_INCONSISTENT); - } -#endif - -#ifdef WITH_EDDSA - // EdDSA mechanism with RSA key - { - CK_MECHANISM mechanism = { CKM_EDDSA, NULL_PTR, 0 }; - rv = CRYPTOKI_F_PTR( C_SignInit(hSession, &mechanism, hRsaPriv) ); - CPPUNIT_ASSERT(rv == CKR_KEY_TYPE_INCONSISTENT); - } -#endif - -#ifdef WITH_GOST - // GOST mechanism with RSA key - { - CK_MECHANISM mechanism = { CKM_GOSTR3410, NULL_PTR, 0 }; - rv = CRYPTOKI_F_PTR( C_SignInit(hSession, &mechanism, hRsaPriv) ); - CPPUNIT_ASSERT(rv == CKR_KEY_TYPE_INCONSISTENT); - } -#endif - -#ifdef WITH_ML_DSA - // ML-DSA mechanism with RSA key - { - CK_MECHANISM mechanism = { CKM_ML_DSA, NULL_PTR, 0 }; - rv = CRYPTOKI_F_PTR( C_SignInit(hSession, &mechanism, hRsaPriv) ); - CPPUNIT_ASSERT(rv == CKR_KEY_TYPE_INCONSISTENT); - } -#endif - - C_Logout(hSession); - C_CloseSession(hSession); -} - -// Same as above but for C_VerifyInit. -void SignVerifyTests::testVerifyInitWrongKeyType() -{ - CK_RV rv; - CK_SESSION_HANDLE hSession; - - // Just make sure that we finalize any previous tests - CRYPTOKI_F_PTR( C_Finalize(NULL_PTR) ); - - rv = CRYPTOKI_F_PTR( C_Initialize(NULL_PTR) ); - CPPUNIT_ASSERT(rv == CKR_OK); - - rv = CRYPTOKI_F_PTR( C_OpenSession(m_initializedTokenSlotID, CKF_SERIAL_SESSION | CKF_RW_SESSION, NULL_PTR, NULL_PTR, &hSession) ); - CPPUNIT_ASSERT(rv == CKR_OK); - - rv = CRYPTOKI_F_PTR( C_Login(hSession, CKU_USER, m_userPin1, m_userPin1Length) ); - CPPUNIT_ASSERT(rv == CKR_OK); - - // EC public key with RSA/DSA mechanisms - CK_OBJECT_HANDLE hEcPub = CK_INVALID_HANDLE, hEcPriv = CK_INVALID_HANDLE; -#ifdef WITH_ECC - rv = generateEC("P-256", hSession, IN_SESSION, IS_PUBLIC, IN_SESSION, IS_PUBLIC, hEcPub, hEcPriv); - CPPUNIT_ASSERT(rv == CKR_OK); - - // RSA mechanisms with EC key - CK_MECHANISM_TYPE rsaMechs[] = { - CKM_RSA_PKCS, CKM_RSA_X_509, - CKM_SHA1_RSA_PKCS, CKM_SHA256_RSA_PKCS, - CKM_SHA384_RSA_PKCS, CKM_SHA512_RSA_PKCS - }; - for (size_t i = 0; i < sizeof(rsaMechs)/sizeof(rsaMechs[0]); i++) - { - CK_MECHANISM mechanism = { rsaMechs[i], NULL_PTR, 0 }; - rv = CRYPTOKI_F_PTR( C_VerifyInit(hSession, &mechanism, hEcPub) ); - CPPUNIT_ASSERT(rv == CKR_KEY_TYPE_INCONSISTENT); - } - - // DSA mechanisms with EC key - CK_MECHANISM_TYPE dsaMechs[] = { CKM_DSA, CKM_DSA_SHA1, CKM_DSA_SHA256 }; - for (size_t i = 0; i < sizeof(dsaMechs)/sizeof(dsaMechs[0]); i++) - { - CK_MECHANISM mechanism = { dsaMechs[i], NULL_PTR, 0 }; - rv = CRYPTOKI_F_PTR( C_VerifyInit(hSession, &mechanism, hEcPub) ); - CPPUNIT_ASSERT(rv == CKR_KEY_TYPE_INCONSISTENT); - } -#endif - - // RSA public key with ECDSA/EdDSA mechanisms - CK_OBJECT_HANDLE hRsaPub = CK_INVALID_HANDLE, hRsaPriv = CK_INVALID_HANDLE; - rv = generateRSA(hSession, IN_SESSION, IS_PUBLIC, IN_SESSION, IS_PUBLIC, hRsaPub, hRsaPriv); - CPPUNIT_ASSERT(rv == CKR_OK); - -#ifdef WITH_ECC - // ECDSA mechanisms with RSA key - CK_MECHANISM_TYPE ecdsaMechs[] = { CKM_ECDSA, CKM_ECDSA_SHA1, CKM_ECDSA_SHA256 }; - for (size_t i = 0; i < sizeof(ecdsaMechs)/sizeof(ecdsaMechs[0]); i++) - { - CK_MECHANISM mechanism = { ecdsaMechs[i], NULL_PTR, 0 }; - rv = CRYPTOKI_F_PTR( C_VerifyInit(hSession, &mechanism, hRsaPub) ); - CPPUNIT_ASSERT(rv == CKR_KEY_TYPE_INCONSISTENT); - } -#endif - -#ifdef WITH_EDDSA - // EdDSA mechanism with RSA key - { - CK_MECHANISM mechanism = { CKM_EDDSA, NULL_PTR, 0 }; - rv = CRYPTOKI_F_PTR( C_VerifyInit(hSession, &mechanism, hRsaPub) ); - CPPUNIT_ASSERT(rv == CKR_KEY_TYPE_INCONSISTENT); - } -#endif - -#ifdef WITH_GOST - // GOST mechanism with RSA key - { - CK_MECHANISM mechanism = { CKM_GOSTR3410, NULL_PTR, 0 }; - rv = CRYPTOKI_F_PTR( C_VerifyInit(hSession, &mechanism, hRsaPub) ); - CPPUNIT_ASSERT(rv == CKR_KEY_TYPE_INCONSISTENT); - } -#endif - -#ifdef WITH_ML_DSA - // ML-DSA mechanism with RSA key - { - CK_MECHANISM mechanism = { CKM_ML_DSA, NULL_PTR, 0 }; - rv = CRYPTOKI_F_PTR( C_VerifyInit(hSession, &mechanism, hRsaPub) ); - CPPUNIT_ASSERT(rv == CKR_KEY_TYPE_INCONSISTENT); - } -#endif - - C_Logout(hSession); - C_CloseSession(hSession); -} diff --git a/src/lib/test/SignVerifyTests.h b/src/lib/test/SignVerifyTests.h index a7c22e083..c2b4ada78 100644 --- a/src/lib/test/SignVerifyTests.h +++ b/src/lib/test/SignVerifyTests.h @@ -52,8 +52,6 @@ class SignVerifyTests : public TestsBase #ifdef WITH_ML_DSA CPPUNIT_TEST_PARAMETERIZED(testMLDSASignVerify, {CKP_ML_DSA_44, CKP_ML_DSA_65, CKP_ML_DSA_87}); #endif - CPPUNIT_TEST(testSignInitWrongKeyType); - CPPUNIT_TEST(testVerifyInitWrongKeyType); CPPUNIT_TEST_SUITE_END(); public: @@ -68,8 +66,6 @@ class SignVerifyTests : public TestsBase #ifdef WITH_ML_DSA void testMLDSASignVerify(CK_ULONG parameterSet); #endif - void testSignInitWrongKeyType(); - void testVerifyInitWrongKeyType(); protected: CK_RV generateRSA(CK_SESSION_HANDLE hSession, CK_BBOOL bTokenPuk, CK_BBOOL bPrivatePuk, CK_BBOOL bTokenPrk, CK_BBOOL bPrivatePrk, CK_OBJECT_HANDLE &hPuk, CK_OBJECT_HANDLE &hPrk);