From 36c5c167a0cf2cd1d23d774b1f9159ac518fc94e Mon Sep 17 00:00:00 2001 From: Golikov Pavel Evgenevich Date: Wed, 24 Dec 2025 17:18:27 +0300 Subject: [PATCH 01/15] Add OAEP parameter passing --- src/lib/SoftHSM.cpp | 284 +++++++++++++++++++++++++++++++++++++++----- 1 file changed, 256 insertions(+), 28 deletions(-) diff --git a/src/lib/SoftHSM.cpp b/src/lib/SoftHSM.cpp index 62ddd72c..6c2c8de2 100644 --- a/src/lib/SoftHSM.cpp +++ b/src/lib/SoftHSM.cpp @@ -2512,6 +2512,64 @@ CK_RV SoftHSM::AsymEncryptInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMec { return CKR_MECHANISM_INVALID; } + // set mechanism parameters + void *parameters = NULL; + size_t paramLen = 0; + RSA_PKCS_OAEP_PARAMS oaep_param; + if (pMechanism->mechanism == CKM_RSA_PKCS_OAEP) + { + CK_RSA_PKCS_OAEP_PARAMS* par1 = (CK_RSA_PKCS_OAEP_PARAMS*) pMechanism->pParameter; + switch (par1->hashAlg) + { + case CKM_SHA_1: + oaep_param.hashAlg = HashAlgo::SHA1; + break; + case CKM_SHA224: + oaep_param.hashAlg = HashAlgo::SHA224; + break; + case CKM_SHA256: + oaep_param.hashAlg = HashAlgo::SHA256; + break; + case CKM_SHA384: + oaep_param.hashAlg = HashAlgo::SHA384; + break; + case CKM_SHA512: + oaep_param.hashAlg = HashAlgo::SHA512; + break; + default: + return CKR_ARGUMENTS_BAD; + } + switch (par1->mgf) + { + case CKG_MGF1_SHA1: + oaep_param.mgf = AsymRSAMGF::MGF1_SHA1; + break; + case CKG_MGF1_SHA224: + oaep_param.mgf = AsymRSAMGF::MGF1_SHA224; + break; + case CKG_MGF1_SHA256: + oaep_param.mgf = AsymRSAMGF::MGF1_SHA256; + break; + case CKG_MGF1_SHA384: + oaep_param.mgf = AsymRSAMGF::MGF1_SHA384; + break; + case CKG_MGF1_SHA512: + oaep_param.mgf = AsymRSAMGF::MGF1_SHA512; + break; + default: + return CKR_ARGUMENTS_BAD; + } + // need copy parameters to session context + // label source data will be copyed to end of parameter block + paramLen = sizeof(RSA_PKCS_OAEP_PARAMS) + par1->ulSourceDataLen; + parameters = malloc(paramLen); + if (parameters == NULL) + return CKR_HOST_MEMORY; + oaep_param.sourceData = (char*)parameters + sizeof(RSA_PKCS_OAEP_PARAMS); + oaep_param.sourceDataLen = par1->ulSourceDataLen; + memcpy(parameters,&oaep_param,sizeof(RSA_PKCS_OAEP_PARAMS)); + memcpy(oaep_param.sourceData,par1->pSourceData,par1->ulSourceDataLen); + } session->setOpType(SESSION_OP_ENCRYPT); session->setAsymmetricCryptoOp(asymCrypto); @@ -2519,7 +2577,11 @@ CK_RV SoftHSM::AsymEncryptInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMec session->setAllowMultiPartOp(false); session->setAllowSinglePartOp(true); session->setPublicKey(publicKey); - + if (parameters != NULL) + { + session->setParameters(parameters, paramLen); + free(parameters); + } return CKR_OK; } @@ -2616,6 +2678,8 @@ static CK_RV AsymEncrypt(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 = 0; + void* parameters = session->getParameters(paramLen); if (asymCrypto == NULL || !session->getAllowSinglePartOp() || publicKey == NULL) { session->resetOp(); @@ -2649,8 +2713,8 @@ 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)) + // Encrypt the data + if (!asymCrypto->encrypt(publicKey,data,encryptedData,mechanism, parameters, paramLen)) { session->resetOp(); return CKR_GENERAL_ERROR; @@ -3265,6 +3329,64 @@ CK_RV SoftHSM::AsymDecryptInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMec { session->setReAuthentication(true); } + // set mechanism parameters + void *parameters = NULL; + size_t paramLen = 0; + RSA_PKCS_OAEP_PARAMS oaep_param; + if (pMechanism->mechanism == CKM_RSA_PKCS_OAEP) + { + CK_RSA_PKCS_OAEP_PARAMS* par1 = (CK_RSA_PKCS_OAEP_PARAMS*) pMechanism->pParameter; + switch (par1->hashAlg) + { + case CKM_SHA_1: + oaep_param.hashAlg = HashAlgo::SHA1; + break; + case CKM_SHA224: + oaep_param.hashAlg = HashAlgo::SHA224; + break; + case CKM_SHA256: + oaep_param.hashAlg = HashAlgo::SHA256; + break; + case CKM_SHA384: + oaep_param.hashAlg = HashAlgo::SHA384; + break; + case CKM_SHA512: + oaep_param.hashAlg = HashAlgo::SHA512; + break; + default: + return CKR_ARGUMENTS_BAD; + } + switch (par1->mgf) + { + case CKG_MGF1_SHA1: + oaep_param.mgf = AsymRSAMGF::MGF1_SHA1; + break; + case CKG_MGF1_SHA224: + oaep_param.mgf = AsymRSAMGF::MGF1_SHA224; + break; + case CKG_MGF1_SHA256: + oaep_param.mgf = AsymRSAMGF::MGF1_SHA256; + break; + case CKG_MGF1_SHA384: + oaep_param.mgf = AsymRSAMGF::MGF1_SHA384; + break; + case CKG_MGF1_SHA512: + oaep_param.mgf = AsymRSAMGF::MGF1_SHA512; + break; + default: + return CKR_ARGUMENTS_BAD; + } + // need copy parameters to session context + // label source data will be copyed to end of parameter block + paramLen = sizeof(RSA_PKCS_OAEP_PARAMS) + par1->ulSourceDataLen; + parameters = malloc(paramLen); + if (parameters == NULL) + return CKR_HOST_MEMORY; + oaep_param.sourceData = (char*)parameters + sizeof(RSA_PKCS_OAEP_PARAMS); + oaep_param.sourceDataLen = par1->ulSourceDataLen; + memcpy(parameters,&oaep_param,sizeof(RSA_PKCS_OAEP_PARAMS)); + memcpy(oaep_param.sourceData,par1->pSourceData,par1->ulSourceDataLen); + } session->setOpType(SESSION_OP_DECRYPT); session->setAsymmetricCryptoOp(asymCrypto); @@ -3272,7 +3394,11 @@ CK_RV SoftHSM::AsymDecryptInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMec session->setAllowMultiPartOp(false); session->setAllowSinglePartOp(true); session->setPrivateKey(privateKey); - + if (parameters != NULL) + { + session->setParameters(parameters,paramLen); + free(parameters); + } return CKR_OK; } @@ -3361,6 +3487,8 @@ static CK_RV AsymDecrypt(Session* session, CK_BYTE_PTR pEncryptedData, CK_ULONG AsymmetricAlgorithm* asymCrypto = session->getAsymmetricCryptoOp(); AsymMech::Type mechanism = session->getMechanism(); PrivateKey* privateKey = session->getPrivateKey(); + size_t paramLen = 0; + void* parameters = session->getParameters(paramLen); if (asymCrypto == NULL || !session->getAllowSinglePartOp() || privateKey == NULL) { session->resetOp(); @@ -3394,7 +3522,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,parameters,paramLen)) { session->resetOp(); return CKR_ENCRYPTED_DATA_INVALID; @@ -6450,7 +6578,64 @@ CK_RV SoftHSM::WrapKeyAsym const size_t bb = 8; AsymAlgo::Type algo = AsymAlgo::Unknown; AsymMech::Type mech = AsymMech::Unknown; + void *parameters = NULL; + size_t paramLen = 0; + size_t hashLen = 0; + RSA_PKCS_OAEP_PARAMS oaep_parameters; + if (pMechanism->mechanism == CKM_RSA_PKCS_OAEP) + { + CK_RSA_PKCS_OAEP_PARAMS* par1 = (CK_RSA_PKCS_OAEP_PARAMS*) pMechanism->pParameter; + switch (par1->hashAlg) + { + case CKM_SHA_1: + oaep_parameters.hashAlg = HashAlgo::SHA1; + hashLen = 20; + break; + case CKM_SHA224: + oaep_parameters.hashAlg = HashAlgo::SHA224; + hashLen = 28; + break; + case CKM_SHA256: + oaep_parameters.hashAlg = HashAlgo::SHA256; + hashLen = 32; + break; + case CKM_SHA384: + oaep_parameters.hashAlg = HashAlgo::SHA384; + hashLen = 48; + break; + case CKM_SHA512: + oaep_parameters.hashAlg = HashAlgo::SHA512; + hashLen = 64; + break; + default: + return CKR_ARGUMENTS_BAD; + } + switch (par1->mgf) + { + case CKG_MGF1_SHA1: + oaep_parameters.mgf = AsymRSAMGF::MGF1_SHA1; + break; + case CKG_MGF1_SHA224: + oaep_parameters.mgf = AsymRSAMGF::MGF1_SHA224; + break; + case CKG_MGF1_SHA256: + oaep_parameters.mgf = AsymRSAMGF::MGF1_SHA256; + break; + case CKG_MGF1_SHA384: + oaep_parameters.mgf = AsymRSAMGF::MGF1_SHA384; + break; + case CKG_MGF1_SHA512: + oaep_parameters.mgf = AsymRSAMGF::MGF1_SHA512; + break; + default: + return CKR_ARGUMENTS_BAD; + } + oaep_parameters.sourceData = par1->pSourceData; + oaep_parameters.sourceDataLen = par1->ulSourceDataLen; + parameters = &oaep_parameters; + paramLen = sizeof(RSA_PKCS_OAEP_PARAMS); + } CK_ULONG modulus_length; switch(pMechanism->mechanism) { case CKM_RSA_PKCS: @@ -6479,7 +6664,7 @@ CK_RV SoftHSM::WrapKeyAsym 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) + if (keydata.size() > modulus_length - 2 - (2 * hashLen)) return CKR_KEY_SIZE_RANGE; break; @@ -6511,8 +6696,9 @@ CK_RV SoftHSM::WrapKeyAsym default: return CKR_MECHANISM_INVALID; } + // Wrap the key - if (!cipher->wrapKey(publicKey, keydata, wrapped, mech)) + if (!cipher->wrapKey(publicKey, keydata, wrapped, mech,parameters,paramLen)) { cipher->recyclePublicKey(publicKey); CryptoFactory::i()->recycleAsymmetricAlgorithm(cipher); @@ -7038,6 +7224,7 @@ CK_RV SoftHSM::UnwrapKeyAsym // Get the symmetric algorithm matching the mechanism AsymAlgo::Type algo = AsymAlgo::Unknown; AsymMech::Type mode = AsymMech::Unknown; + switch(pMechanism->mechanism) { case CKM_RSA_PKCS: algo = AsymAlgo::RSA; @@ -7077,8 +7264,59 @@ CK_RV SoftHSM::UnwrapKeyAsym return CKR_MECHANISM_INVALID; } + void *parameters = NULL; + size_t paramLen = 0; + RSA_PKCS_OAEP_PARAMS oaep_parameters; + if (pMechanism->mechanism == CKM_RSA_PKCS_OAEP) + { + CK_RSA_PKCS_OAEP_PARAMS* par1 = (CK_RSA_PKCS_OAEP_PARAMS*) pMechanism->pParameter; + switch (par1->hashAlg) + { + case CKM_SHA_1: + oaep_parameters.hashAlg = HashAlgo::SHA1; + break; + case CKM_SHA224: + oaep_parameters.hashAlg = HashAlgo::SHA224; + break; + case CKM_SHA256: + oaep_parameters.hashAlg = HashAlgo::SHA256; + break; + case CKM_SHA384: + oaep_parameters.hashAlg = HashAlgo::SHA384; + break; + case CKM_SHA512: + oaep_parameters.hashAlg = HashAlgo::SHA512; + break; + default: + return CKR_ARGUMENTS_BAD; + } + switch (par1->mgf) + { + case CKG_MGF1_SHA1: + oaep_parameters.mgf = AsymRSAMGF::MGF1_SHA1; + break; + case CKG_MGF1_SHA224: + oaep_parameters.mgf = AsymRSAMGF::MGF1_SHA224; + break; + case CKG_MGF1_SHA256: + oaep_parameters.mgf = AsymRSAMGF::MGF1_SHA256; + break; + case CKG_MGF1_SHA384: + oaep_parameters.mgf = AsymRSAMGF::MGF1_SHA384; + break; + case CKG_MGF1_SHA512: + oaep_parameters.mgf = AsymRSAMGF::MGF1_SHA512; + break; + default: + return CKR_ARGUMENTS_BAD; + } + oaep_parameters.sourceData = par1->pSourceData; + oaep_parameters.sourceDataLen = par1->ulSourceDataLen; + parameters = &oaep_parameters; + paramLen = sizeof(RSA_PKCS_OAEP_PARAMS); + } // Unwrap the key - if (!cipher->unwrapKey(unwrappingkey, wrapped, keydata, mode)) + if (!cipher->unwrapKey(unwrappingkey, wrapped, keydata, mode, parameters, paramLen )) rv = CKR_GENERAL_ERROR; cipher->recyclePrivateKey(unwrappingkey); CryptoFactory::i()->recycleAsymmetricAlgorithm(cipher); @@ -13175,31 +13413,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) - { - ERROR_MSG("pSourceData must be NULL"); - return CKR_ARGUMENTS_BAD; - } - if (params->ulSourceDataLen != 0) + if ((params-> pSourceData == NULL)&&(params->ulSourceDataLen != 0)) { - ERROR_MSG("ulSourceDataLen must be 0"); + ERROR_MSG("pSourceData is NULL"); return CKR_ARGUMENTS_BAD; } return CKR_OK; @@ -13241,7 +13464,12 @@ CK_RV SoftHSM::MechParamCheckRSAAESKEYWRAP(CK_MECHANISM_PTR pMechanism) ERROR_MSG("source must be CKZ_DATA_SPECIFIED"); return CKR_ARGUMENTS_BAD; } - if (params->pOAEPParams->pSourceData != NULL) + if ((params-> pOAEPParams->pSourceData == NULL)&&(params->pOAEPParams->ulSourceDataLen != 0)) + { + ERROR_MSG("pSourceData is NULL"); + return CKR_ARGUMENTS_BAD; + } + /*if (params->pOAEPParams->pSourceData != NULL) { ERROR_MSG("pSourceData must be NULL"); return CKR_ARGUMENTS_BAD; @@ -13250,7 +13478,7 @@ CK_RV SoftHSM::MechParamCheckRSAAESKEYWRAP(CK_MECHANISM_PTR pMechanism) { ERROR_MSG("ulSourceDataLen must be 0"); return CKR_ARGUMENTS_BAD; - } + }*/ return CKR_OK; } From 5bd133f1e2d14c9153b0af49f8805b7bcd361ab4 Mon Sep 17 00:00:00 2001 From: Golikov Pavel Evgenevich Date: Wed, 24 Dec 2025 17:21:32 +0300 Subject: [PATCH 02/15] Add Asymmetric encrypt/decrypt parameter --- src/lib/crypto/AsymmetricAlgorithm.cpp | 10 ++++++---- src/lib/crypto/AsymmetricAlgorithm.h | 21 ++++++++++++++++----- src/lib/crypto/OSSLDH.cpp | 6 ++++-- src/lib/crypto/OSSLDH.h | 6 ++++-- src/lib/crypto/OSSLDSA.cpp | 6 ++++-- src/lib/crypto/OSSLDSA.h | 6 ++++-- src/lib/crypto/OSSLECDH.cpp | 6 ++++-- src/lib/crypto/OSSLECDH.h | 6 ++++-- src/lib/crypto/OSSLECDSA.cpp | 4 ++-- src/lib/crypto/OSSLECDSA.h | 6 ++++-- src/lib/crypto/OSSLEDDSA.cpp | 4 ++-- src/lib/crypto/OSSLEDDSA.h | 6 ++++-- src/lib/crypto/OSSLGOST.cpp | 6 ++++-- src/lib/crypto/OSSLGOST.h | 6 ++++-- 14 files changed, 66 insertions(+), 33 deletions(-) diff --git a/src/lib/crypto/AsymmetricAlgorithm.cpp b/src/lib/crypto/AsymmetricAlgorithm.cpp index 20a50a5f..1f27f988 100644 --- a/src/lib/crypto/AsymmetricAlgorithm.cpp +++ b/src/lib/crypto/AsymmetricAlgorithm.cpp @@ -156,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 void* param, size_t paramLen) { if (!isWrappingMech(padding)) return false; - return encrypt(publicKey, data, encryptedData, padding); + return encrypt(publicKey, data, encryptedData, padding, param, paramLen); } -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 void* param, size_t paramLen) { if (!isWrappingMech(padding)) return false; - return decrypt(privateKey, encryptedData, data, padding); + return decrypt(privateKey, encryptedData, data, padding, param, paramLen); } diff --git a/src/lib/crypto/AsymmetricAlgorithm.h b/src/lib/crypto/AsymmetricAlgorithm.h index 52519db6..38884456 100644 --- a/src/lib/crypto/AsymmetricAlgorithm.h +++ b/src/lib/crypto/AsymmetricAlgorithm.h @@ -116,6 +116,14 @@ struct RSA_PKCS_PSS_PARAMS size_t sLen; }; +struct RSA_PKCS_OAEP_PARAMS +{ + HashAlgo::Type hashAlg; + AsymRSAMGF::Type mgf; + void *sourceData; + size_t sourceDataLen; +}; + class AsymmetricAlgorithm { public: @@ -138,14 +146,17 @@ class AsymmetricAlgorithm 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 void* param = NULL, const size_t paramLen = 0) = 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 void* param = NULL, const size_t paramLen = 0) = 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 void* param = NULL, size_t paramLen = 0); + bool unwrapKey(PrivateKey* privateKey, const ByteString& encryptedData, ByteString& data, const AsymMech::Type padding, + const void* param = NULL, size_t paramLen = 0); // Key factory virtual bool generateKeyPair(AsymmetricKeyPair** ppKeyPair, AsymmetricParameters* parameters, RNG* rng = NULL) = 0; diff --git a/src/lib/crypto/OSSLDH.cpp b/src/lib/crypto/OSSLDH.cpp index ee61733c..e2befb9c 100644 --- a/src/lib/crypto/OSSLDH.cpp +++ b/src/lib/crypto/OSSLDH.cpp @@ -91,7 +91,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 void* /*param*/, const size_t /*paramLen*/) { ERROR_MSG("DH does not support encryption"); @@ -100,7 +101,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 void* /*param*/, const size_t /*paramLen*/) { ERROR_MSG("DH does not support decryption"); diff --git a/src/lib/crypto/OSSLDH.h b/src/lib/crypto/OSSLDH.h index d611aee1..5f498fe9 100644 --- a/src/lib/crypto/OSSLDH.h +++ b/src/lib/crypto/OSSLDH.h @@ -54,10 +54,12 @@ class OSSLDH : public AsymmetricAlgorithm 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 void* param = NULL, const size_t paramLen = 0); // 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 void* param = NULL, const size_t paramLen = 0); // 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 06b5d501..ae676212 100644 --- a/src/lib/crypto/OSSLDSA.cpp +++ b/src/lib/crypto/OSSLDSA.cpp @@ -437,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 void* /*param*/, const size_t /*paramLen*/) { ERROR_MSG("DSA does not support encryption"); @@ -446,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 void* /*param*/, const size_t /*paramLen*/) { ERROR_MSG("DSA does not support decryption"); diff --git a/src/lib/crypto/OSSLDSA.h b/src/lib/crypto/OSSLDSA.h index 1fb2b1e5..69c6cd75 100644 --- a/src/lib/crypto/OSSLDSA.h +++ b/src/lib/crypto/OSSLDSA.h @@ -60,10 +60,12 @@ class OSSLDSA : public AsymmetricAlgorithm 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 void* param = NULL, const size_t paramLen = 0); // 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 void* param = NULL, const size_t paramLen = 0); // 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 e2abaeb2..3b3bc38f 100644 --- a/src/lib/crypto/OSSLECDH.cpp +++ b/src/lib/crypto/OSSLECDH.cpp @@ -94,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 void* /*param*/, const size_t /*paramLen*/) { ERROR_MSG("ECDH does not support encryption"); @@ -103,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 void* /*param*/, const size_t /*paramLen*/) { ERROR_MSG("ECDH does not support decryption"); diff --git a/src/lib/crypto/OSSLECDH.h b/src/lib/crypto/OSSLECDH.h index 2cafa6fd..224ce9c0 100644 --- a/src/lib/crypto/OSSLECDH.h +++ b/src/lib/crypto/OSSLECDH.h @@ -54,10 +54,12 @@ class OSSLECDH : public AsymmetricAlgorithm 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 void* param = NULL, const size_t paramLen = 0); // 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 void* param = NULL, const size_t paramLen = 0); // 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 23139c1b..d035a6ae 100644 --- a/src/lib/crypto/OSSLECDSA.cpp +++ b/src/lib/crypto/OSSLECDSA.cpp @@ -331,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 void* /*param*/, const size_t /*paramLen*/ ) { ERROR_MSG("ECDSA does not support encryption"); @@ -340,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 void* /*param*/, const size_t /*paramLen*/) { ERROR_MSG("ECDSA does not support decryption"); diff --git a/src/lib/crypto/OSSLECDSA.h b/src/lib/crypto/OSSLECDSA.h index 992fa40b..8dac2227 100644 --- a/src/lib/crypto/OSSLECDSA.h +++ b/src/lib/crypto/OSSLECDSA.h @@ -56,10 +56,12 @@ class OSSLECDSA : public AsymmetricAlgorithm 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 void* param = NULL, const size_t paramLen = 0); // 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 void* param = NULL, const size_t paramLen = 0); // 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 dc2f4cc3..ac0f05b5 100644 --- a/src/lib/crypto/OSSLEDDSA.cpp +++ b/src/lib/crypto/OSSLEDDSA.cpp @@ -208,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 void* /*param*/ , const size_t /*paramLen*/) { ERROR_MSG("EDDSA does not support encryption"); @@ -217,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 void* /*param*/ , const size_t /*paramLen*/) { ERROR_MSG("EDDSA does not support decryption"); diff --git a/src/lib/crypto/OSSLEDDSA.h b/src/lib/crypto/OSSLEDDSA.h index 02b8a115..0543c356 100644 --- a/src/lib/crypto/OSSLEDDSA.h +++ b/src/lib/crypto/OSSLEDDSA.h @@ -56,10 +56,12 @@ class OSSLEDDSA : public AsymmetricAlgorithm 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 void* param = NULL, const size_t paramLen = 0); // 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 void* param = NULL, const size_t paramLen = 0); // 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 4f34d45d..76d3d9bb 100644 --- a/src/lib/crypto/OSSLGOST.cpp +++ b/src/lib/crypto/OSSLGOST.cpp @@ -428,7 +428,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 void* /*param*/, const size_t /*paramLen*/) { ERROR_MSG("GOST does not support encryption"); @@ -437,7 +438,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 void* /*param*/, const size_t /*paramLen*/) { ERROR_MSG("GOST does not support decryption"); diff --git a/src/lib/crypto/OSSLGOST.h b/src/lib/crypto/OSSLGOST.h index ad399f18..68ed6992 100644 --- a/src/lib/crypto/OSSLGOST.h +++ b/src/lib/crypto/OSSLGOST.h @@ -61,10 +61,12 @@ class OSSLGOST : public AsymmetricAlgorithm 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 void* param = NULL, const size_t paramLen = 0); // 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 void* param = NULL, const size_t paramLen = 0); // Key factory virtual bool generateKeyPair(AsymmetricKeyPair** ppKeyPair, AsymmetricParameters* parameters, RNG* rng = NULL); From 73e5fe2412ae7d94ea1d31f6b4085c896b0bb568 Mon Sep 17 00:00:00 2001 From: Golikov Pavel Evgenevich Date: Wed, 24 Dec 2025 17:22:39 +0300 Subject: [PATCH 03/15] Refactor RSA/ add OAEP encrypt/decrypt parameters --- src/lib/crypto/OSSLRSA.cpp | 1578 ++++++++++++++++---------- src/lib/crypto/OSSLRSA.h | 6 +- src/lib/crypto/OSSLRSAPrivateKey.cpp | 220 ++-- src/lib/crypto/OSSLRSAPrivateKey.h | 10 +- src/lib/crypto/OSSLRSAPublicKey.cpp | 85 +- src/lib/crypto/OSSLRSAPublicKey.h | 10 +- 6 files changed, 1205 insertions(+), 704 deletions(-) diff --git a/src/lib/crypto/OSSLRSA.cpp b/src/lib/crypto/OSSLRSA.cpp index d36a1e68..f173d337 100644 --- a/src/lib/crypto/OSSLRSA.cpp +++ b/src/lib/crypto/OSSLRSA.cpp @@ -38,7 +38,7 @@ #include "RSAParameters.h" #include "OSSLRSAKeyPair.h" #include -#include +#include #include #include @@ -65,9 +65,9 @@ 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 */) +bool OSSLRSA::sign(PrivateKey *privateKey, const ByteString &dataToSign, + ByteString &signature, const AsymMech::Type mechanism, + const void *param /* = NULL */, const size_t paramLen /* = 0 */) { if (mechanism == AsymMech::RSA_PKCS) { @@ -83,7 +83,7 @@ bool OSSLRSA::sign(PrivateKey* privateKey, const ByteString& dataToSign, // In case of PKCS #1 signing the length of the input data may not exceed 40% of the // modulus size - OSSLRSAPrivateKey* osslKey = (OSSLRSAPrivateKey*) privateKey; + OSSLRSAPrivateKey *osslKey = (OSSLRSAPrivateKey *)privateKey; size_t allowedLen = osslKey->getN().size() - 11; @@ -95,27 +95,44 @@ 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)) - { - ERROR_MSG("Failed to turn on blinding for OpenSSL RSA key"); + // if (!RSA_blinding_on(rsa, NULL)) + //{ + // ERROR_MSG("Failed to turn on blinding for OpenSSL RSA key"); + // return false; + //} + //-------- + EVP_PKEY_CTX *ctx = EVP_PKEY_CTX_new(rsa, NULL); + if (ctx == NULL) + { + 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 (sigLen == -1) + + 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; + } + + 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); + //-------- + // int sigLen = RSA_private_encrypt(dataToSign.size(), (unsigned char*) dataToSign.const_byte_str(), &signature[0], rsa, RSA_PKCS1_PADDING); + + // RSA_blinding_off(rsa); signature.resize(sigLen); @@ -123,7 +140,7 @@ bool OSSLRSA::sign(PrivateKey* privateKey, const ByteString& dataToSign, } else if (mechanism == AsymMech::RSA_PKCS_PSS) { - const RSA_PKCS_PSS_PARAMS *pssParam = (RSA_PKCS_PSS_PARAMS*)param; + const RSA_PKCS_PSS_PARAMS *pssParam = (RSA_PKCS_PSS_PARAMS *)param; // Separate implementation for RSA PKCS #1 signing without hash computation @@ -143,7 +160,8 @@ bool OSSLRSA::sign(PrivateKey* privateKey, const ByteString& dataToSign, } size_t allowedLen; - const EVP_MD* hash = NULL; + const EVP_MD *hash = NULL; + const EVP_MD *mgf = NULL; switch (pssParam->hashAlg) { @@ -171,9 +189,30 @@ bool OSSLRSA::sign(PrivateKey* privateKey, const ByteString& dataToSign, return false; } - OSSLRSAPrivateKey* osslKey = (OSSLRSAPrivateKey*) privateKey; + switch (pssParam->mgf) + { + 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; + } - RSA* rsa = osslKey->getOSSLKey(); + OSSLRSAPrivateKey *osslKey = (OSSLRSAPrivateKey *)privateKey; + + EVP_PKEY *rsa = osslKey->getOSSLKey(); if (dataToSign.size() != allowedLen) { @@ -183,45 +222,65 @@ 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()); + // 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) - { - ERROR_MSG("Error in RSA PSS padding generation"); + // int status = RSA_padding_add_PKCS1_PSS_mgf1(rsa, &em[0], (unsigned char*) dataToSign.const_byte_str(), hash, hash, pssParam->sLen); + // if (!status) + //{ + // ERROR_MSG("Error in RSA PSS padding generation"); - return false; - } + // return false; + //} + // if (!RSA_blinding_on(rsa, NULL)) + //{ + // ERROR_MSG("Failed to turn on blinding for OpenSSL RSA key"); - if (!RSA_blinding_on(rsa, NULL)) - { - ERROR_MSG("Failed to turn on blinding for OpenSSL RSA key"); + // return false; + //} + // 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("An error occurred while creating the RSA-PSS signature context"); 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) + 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)) { + EVP_PKEY_CTX_free(ctx); + ERROR_MSG("An error occurred while performing the RSA-PSS signature"); + return false; + } + + 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); + //-------- + + // int sigLen = RSA_private_encrypt(osslKey->getN().size(), &em[0], &signature[0], rsa, RSA_NO_PADDING); + + // RSA_blinding_off(rsa); signature.resize(sigLen); @@ -240,7 +299,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()) { @@ -248,30 +307,38 @@ 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()); + EVP_PKEY *rsa = osslKey->getOSSLKey(); - RSA* rsa = osslKey->getOSSLKey(); + // if (!RSA_blinding_on(rsa, NULL)) + //{ + // ERROR_MSG("Failed to turn on blinding for OpenSSL RSA key"); - if (!RSA_blinding_on(rsa, NULL)) + // return false; + //} + //-------- + 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); + //-------- + // int sigLen = RSA_private_encrypt(dataToSign.size(), (unsigned char*) dataToSign.const_byte_str(), &signature[0], rsa, RSA_NO_PADDING); + // RSA_blinding_off(rsa); signature.resize(sigLen); return true; @@ -283,8 +350,8 @@ bool OSSLRSA::sign(PrivateKey* privateKey, const ByteString& dataToSign, } } -bool OSSLRSA::signInit(PrivateKey* privateKey, const AsymMech::Type mechanism, - const void* param /* = NULL */, const size_t paramLen /* = 0 */) +bool OSSLRSA::signInit(PrivateKey *privateKey, const AsymMech::Type mechanism, + const void *param /* = NULL */, const size_t paramLen /* = 0 */) { if (!AsymmetricAlgorithm::signInit(privateKey, mechanism, param, paramLen)) { @@ -307,140 +374,140 @@ bool OSSLRSA::signInit(PrivateKey* privateKey, const AsymMech::Type mechanism, switch (mechanism) { - case AsymMech::RSA_MD5_PKCS: - hash1 = HashAlgo::MD5; - break; - case AsymMech::RSA_SHA1_PKCS: - hash1 = HashAlgo::SHA1; - break; - case AsymMech::RSA_SHA224_PKCS: - hash1 = HashAlgo::SHA224; - break; - case AsymMech::RSA_SHA256_PKCS: - hash1 = HashAlgo::SHA256; - break; - case AsymMech::RSA_SHA384_PKCS: - hash1 = HashAlgo::SHA384; - break; - case AsymMech::RSA_SHA512_PKCS: - 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) - { - ERROR_MSG("Invalid parameters"); - ByteString dummy; - AsymmetricAlgorithm::signFinal(dummy); - return false; - } - sLen = ((RSA_PKCS_PSS_PARAMS*) param)->sLen; - if (sLen > ((privateKey->getBitLength()+6)/8-2-20)) - { - ERROR_MSG("sLen (%lu) is too large for current key size (%lu)", + case AsymMech::RSA_MD5_PKCS: + hash1 = HashAlgo::MD5; + break; + case AsymMech::RSA_SHA1_PKCS: + hash1 = HashAlgo::SHA1; + break; + case AsymMech::RSA_SHA224_PKCS: + hash1 = HashAlgo::SHA224; + break; + case AsymMech::RSA_SHA256_PKCS: + hash1 = HashAlgo::SHA256; + break; + case AsymMech::RSA_SHA384_PKCS: + hash1 = HashAlgo::SHA384; + break; + case AsymMech::RSA_SHA512_PKCS: + 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) + { + ERROR_MSG("Invalid parameters"); + ByteString dummy; + AsymmetricAlgorithm::signFinal(dummy); + return false; + } + sLen = ((RSA_PKCS_PSS_PARAMS *)param)->sLen; + if (sLen > ((privateKey->getBitLength() + 6) / 8 - 2 - 20)) + { + ERROR_MSG("sLen (%lu) is too large for current key size (%lu)", (unsigned long)sLen, privateKey->getBitLength()); - ByteString dummy; - AsymmetricAlgorithm::signFinal(dummy); - return false; - } - 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) - { - ERROR_MSG("Invalid parameters"); - ByteString dummy; - AsymmetricAlgorithm::signFinal(dummy); - return false; - } - sLen = ((RSA_PKCS_PSS_PARAMS*) param)->sLen; - if (sLen > ((privateKey->getBitLength()+6)/8-2-28)) - { - ERROR_MSG("sLen (%lu) is too large for current key size (%lu)", + ByteString dummy; + AsymmetricAlgorithm::signFinal(dummy); + return false; + } + 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) + { + ERROR_MSG("Invalid parameters"); + ByteString dummy; + AsymmetricAlgorithm::signFinal(dummy); + return false; + } + sLen = ((RSA_PKCS_PSS_PARAMS *)param)->sLen; + if (sLen > ((privateKey->getBitLength() + 6) / 8 - 2 - 28)) + { + ERROR_MSG("sLen (%lu) is too large for current key size (%lu)", (unsigned long)sLen, privateKey->getBitLength()); - ByteString dummy; - AsymmetricAlgorithm::signFinal(dummy); - return false; - } - hash1 = HashAlgo::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) - { - ERROR_MSG("Invalid parameters"); - ByteString dummy; - AsymmetricAlgorithm::signFinal(dummy); - return false; - } - sLen = ((RSA_PKCS_PSS_PARAMS*) param)->sLen; - if (sLen > ((privateKey->getBitLength()+6)/8-2-32)) - { - ERROR_MSG("sLen (%lu) is too large for current key size (%lu)", + ByteString dummy; + AsymmetricAlgorithm::signFinal(dummy); + return false; + } + 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) + { + ERROR_MSG("Invalid parameters"); + ByteString dummy; + AsymmetricAlgorithm::signFinal(dummy); + return false; + } + sLen = ((RSA_PKCS_PSS_PARAMS *)param)->sLen; + if (sLen > ((privateKey->getBitLength() + 6) / 8 - 2 - 32)) + { + ERROR_MSG("sLen (%lu) is too large for current key size (%lu)", (unsigned long)sLen, privateKey->getBitLength()); - ByteString dummy; - AsymmetricAlgorithm::signFinal(dummy); - return false; - } - hash1 = HashAlgo::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) - { - ERROR_MSG("Invalid parameters"); - ByteString dummy; - AsymmetricAlgorithm::signFinal(dummy); - return false; - } - sLen = ((RSA_PKCS_PSS_PARAMS*) param)->sLen; - if (sLen > ((privateKey->getBitLength()+6)/8-2-48)) - { - ERROR_MSG("sLen (%lu) is too large for current key size (%lu)", + ByteString dummy; + AsymmetricAlgorithm::signFinal(dummy); + return false; + } + 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) + { + ERROR_MSG("Invalid parameters"); + ByteString dummy; + AsymmetricAlgorithm::signFinal(dummy); + return false; + } + sLen = ((RSA_PKCS_PSS_PARAMS *)param)->sLen; + if (sLen > ((privateKey->getBitLength() + 6) / 8 - 2 - 48)) + { + ERROR_MSG("sLen (%lu) is too large for current key size (%lu)", (unsigned long)sLen, privateKey->getBitLength()); - ByteString dummy; - AsymmetricAlgorithm::signFinal(dummy); - return false; - } - hash1 = HashAlgo::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) - { - ERROR_MSG("Invalid parameters"); - ByteString dummy; - AsymmetricAlgorithm::signFinal(dummy); - return false; - } - sLen = ((RSA_PKCS_PSS_PARAMS*) param)->sLen; - if (sLen > ((privateKey->getBitLength()+6)/8-2-64)) - { - ERROR_MSG("sLen (%lu) is too large for current key size (%lu)", + ByteString dummy; + AsymmetricAlgorithm::signFinal(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) + { + ERROR_MSG("Invalid parameters"); + ByteString dummy; + AsymmetricAlgorithm::signFinal(dummy); + return false; + } + sLen = ((RSA_PKCS_PSS_PARAMS *)param)->sLen; + if (sLen > ((privateKey->getBitLength() + 6) / 8 - 2 - 64)) + { + ERROR_MSG("sLen (%lu) is too large for current key size (%lu)", (unsigned long)sLen, privateKey->getBitLength()); - ByteString dummy; - AsymmetricAlgorithm::signFinal(dummy); - return false; - } - hash1 = HashAlgo::SHA512; - break; - case AsymMech::RSA_SSL: - hash1 = HashAlgo::MD5; - hash2 = HashAlgo::SHA1; - break; - default: - ERROR_MSG("Invalid mechanism supplied (%i)", mechanism); - ByteString dummy; AsymmetricAlgorithm::signFinal(dummy); - return false; + } + hash1 = HashAlgo::SHA512; + break; + case AsymMech::RSA_SSL: + hash1 = HashAlgo::MD5; + hash2 = HashAlgo::SHA1; + break; + default: + ERROR_MSG("Invalid mechanism supplied (%i)", mechanism); + + ByteString dummy; + AsymmetricAlgorithm::signFinal(dummy); + + return false; } pCurrentHash = CryptoFactory::i()->getHashAlgorithm(hash1); @@ -484,7 +551,7 @@ bool OSSLRSA::signInit(PrivateKey* privateKey, const AsymMech::Type mechanism, return true; } -bool OSSLRSA::signUpdate(const ByteString& dataToSign) +bool OSSLRSA::signUpdate(const ByteString &dataToSign) { if (!AsymmetricAlgorithm::signUpdate(dataToSign)) { @@ -519,10 +586,10 @@ bool OSSLRSA::signUpdate(const ByteString& dataToSign) return true; } -bool OSSLRSA::signFinal(ByteString& signature) +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)) @@ -552,131 +619,126 @@ 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; - const EVP_MD* hash = NULL; + int rsaPadding = 0; + const EVP_MD *hash = NULL; switch (mechanism) { - case AsymMech::RSA_MD5_PKCS: - type = NID_md5; - break; - case AsymMech::RSA_SHA1_PKCS: - type = NID_sha1; - break; - case AsymMech::RSA_SHA224_PKCS: - type = NID_sha224; - break; - case AsymMech::RSA_SHA256_PKCS: - type = NID_sha256; - break; - case AsymMech::RSA_SHA384_PKCS: - type = NID_sha384; - break; - case AsymMech::RSA_SHA512_PKCS: - type = NID_sha512; - break; - case AsymMech::RSA_SHA1_PKCS_PSS: - isPSS = true; - hash = EVP_sha1(); - break; - case AsymMech::RSA_SHA224_PKCS_PSS: - isPSS = true; - hash = EVP_sha224(); - break; - case AsymMech::RSA_SHA256_PKCS_PSS: - isPSS = true; - hash = EVP_sha256(); - break; - case AsymMech::RSA_SHA384_PKCS_PSS: - isPSS = true; - hash = EVP_sha384(); - break; - case AsymMech::RSA_SHA512_PKCS_PSS: - isPSS = true; - hash = EVP_sha512(); - break; - case AsymMech::RSA_SSL: - type = NID_md5_sha1; - break; - default: - break; + case AsymMech::RSA_MD5_PKCS: + // type = NID_md5; + hash = EVP_md5(); + rsaPadding = RSA_PKCS1_PADDING; + break; + case AsymMech::RSA_SHA1_PKCS: + hash = EVP_sha1(); + rsaPadding = RSA_PKCS1_PADDING; + break; + case AsymMech::RSA_SHA224_PKCS: + hash = EVP_sha224(); + rsaPadding = RSA_PKCS1_PADDING; + break; + case AsymMech::RSA_SHA256_PKCS: + hash = EVP_sha256(); + rsaPadding = RSA_PKCS1_PADDING; + break; + case AsymMech::RSA_SHA384_PKCS: + hash = EVP_sha384(); + rsaPadding = RSA_PKCS1_PADDING; + break; + case AsymMech::RSA_SHA512_PKCS: + hash = EVP_sha512(); + rsaPadding = RSA_PKCS1_PADDING; + break; + case AsymMech::RSA_SHA1_PKCS_PSS: + rsaPadding = RSA_PKCS1_PSS_PADDING; + hash = EVP_sha1(); + break; + case AsymMech::RSA_SHA224_PKCS_PSS: + rsaPadding = RSA_PKCS1_PSS_PADDING; + hash = EVP_sha224(); + break; + case AsymMech::RSA_SHA256_PKCS_PSS: + rsaPadding = RSA_PKCS1_PSS_PADDING; + hash = EVP_sha256(); + break; + case AsymMech::RSA_SHA384_PKCS_PSS: + rsaPadding = RSA_PKCS1_PSS_PADDING; + hash = EVP_sha384(); + break; + case AsymMech::RSA_SHA512_PKCS_PSS: + rsaPadding = RSA_PKCS1_PSS_PADDING; + hash = EVP_sha512(); + break; + case AsymMech::RSA_SSL: + rsaPadding = RSA_PKCS1_PADDING; + hash = EVP_md5_sha1(); + break; + default: + return false; + // break; } + // Resize the data block for the signature to the modulus size of the key + + size_t sigLen = pk->getN().size(); // Perform the signature operation - unsigned int sigLen = signature.size(); + EVP_PKEY *rsa = pk->getOSSLKey(); - RSA* rsa = pk->getOSSLKey(); + // if (!RSA_blinding_on(rsa, NULL)) + //{ + // ERROR_MSG("Failed to turn blinding on for OpenSSL RSA key"); - if (!RSA_blinding_on(rsa, NULL)) - { - ERROR_MSG("Failed to turn blinding on for OpenSSL RSA key"); + // return false; + //} + //-------- + 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; } - - 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) + if ((EVP_PKEY_CTX_set_rsa_mgf1_md(ctx, hash) <= 0) || + (EVP_PKEY_CTX_set_rsa_pss_saltlen(ctx, sLen) <= 0)) { - rv = true; - } - else - { - 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; } } + 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); + //-------- - RSA_blinding_off(rsa); + // RSA_blinding_off(rsa); 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 */) +bool OSSLRSA::verify(PublicKey *publicKey, const ByteString &originalData, + const ByteString &signature, const AsymMech::Type mechanism, + const void *param /* = NULL */, const size_t paramLen /* = 0 */) { + if (mechanism == AsymMech::RSA_PKCS) { // Specific implementation for PKCS #1 only verification; originalData is assumed to contain @@ -692,30 +754,53 @@ bool OSSLRSA::verify(PublicKey* publicKey, const ByteString& originalData, } // Perform the RSA public key operation - OSSLRSAPublicKey* osslKey = (OSSLRSAPublicKey*) publicKey; - - ByteString recoveredData; + OSSLRSAPublicKey *osslKey = (OSSLRSAPublicKey *)publicKey; - recoveredData.resize(osslKey->getN().size()); + // ByteString recoveredData; - RSA* rsa = osslKey->getOSSLKey(); + // recoveredData.resize(osslKey->getN().size()); - int retLen = RSA_public_decrypt(signature.size(), (unsigned char*) signature.const_byte_str(), &recoveredData[0], rsa, RSA_PKCS1_PADDING); + EVP_PKEY *rsa = osslKey->getOSSLKey(); - if (retLen == -1) + //-------- + 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; + } + 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); + // int retLen = RSA_public_decrypt(signature.size(), (unsigned char*) signature.const_byte_str(), &recoveredData[0], rsa, RSA_PKCS1_PADDING); - recoveredData.resize(retLen); + // if (retLen == -1) + //{ + // ERROR_MSG("Public key operation failed"); - return (originalData == recoveredData); + // return false; + //} + + // recoveredData.resize(retLen); + + // return (originalData == recoveredData); } else if (mechanism == AsymMech::RSA_PKCS_PSS) { - const RSA_PKCS_PSS_PARAMS *pssParam = (RSA_PKCS_PSS_PARAMS*)param; + const RSA_PKCS_PSS_PARAMS *pssParam = (RSA_PKCS_PSS_PARAMS *)param; if (pssParam == NULL || paramLen != sizeof(RSA_PKCS_PSS_PARAMS)) { @@ -733,28 +818,28 @@ bool OSSLRSA::verify(PublicKey* publicKey, const ByteString& originalData, } // Perform the RSA public key operation - OSSLRSAPublicKey* osslKey = (OSSLRSAPublicKey*) publicKey; + OSSLRSAPublicKey *osslKey = (OSSLRSAPublicKey *)publicKey; - ByteString recoveredData; + // ByteString recoveredData; - recoveredData.resize(osslKey->getN().size()); + // recoveredData.resize(osslKey->getN().size()); - RSA* rsa = osslKey->getOSSLKey(); + EVP_PKEY *rsa = osslKey->getOSSLKey(); - int retLen = RSA_public_decrypt(signature.size(), (unsigned char*) signature.const_byte_str(), &recoveredData[0], rsa, RSA_NO_PADDING); + // 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"); + // if (retLen == -1) + //{ + // ERROR_MSG("Public key operation failed"); - return false; - } + // return false; + //} - recoveredData.resize(retLen); + // recoveredData.resize(retLen); size_t allowedLen; - const EVP_MD* hash = NULL; - + const EVP_MD *hash = NULL; + const EVP_MD *mgf = NULL; switch (pssParam->hashAlg) { case HashAlgo::SHA1: @@ -780,21 +865,66 @@ bool OSSLRSA::verify(PublicKey* publicKey, const ByteString& originalData, default: return false; } + switch (pssParam->mgf) + { + 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); - + // 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_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) @@ -812,26 +942,51 @@ bool OSSLRSA::verify(PublicKey* publicKey, const ByteString& originalData, } // Perform the RSA public key operation - OSSLRSAPublicKey* osslKey = (OSSLRSAPublicKey*) publicKey; - - ByteString recoveredData; + OSSLRSAPublicKey *osslKey = (OSSLRSAPublicKey *)publicKey; - recoveredData.resize(osslKey->getN().size()); + // ByteString recoveredData; - RSA* rsa = osslKey->getOSSLKey(); + // recoveredData.resize(osslKey->getN().size()); - int retLen = RSA_public_decrypt(signature.size(), (unsigned char*) signature.const_byte_str(), &recoveredData[0], rsa, RSA_NO_PADDING); + EVP_PKEY *rsa = osslKey->getOSSLKey(); - if (retLen == -1) + //-------- + 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; + } + 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); + + // 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); + // recoveredData.resize(retLen); - return (originalData == recoveredData); + // return (originalData == recoveredData); } else { @@ -840,8 +995,8 @@ bool OSSLRSA::verify(PublicKey* publicKey, const ByteString& originalData, } } -bool OSSLRSA::verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, - const void* param /* = NULL */, const size_t paramLen /* = 0 */) +bool OSSLRSA::verifyInit(PublicKey *publicKey, const AsymMech::Type mechanism, + const void *param /* = NULL */, const size_t paramLen /* = 0 */) { if (!AsymmetricAlgorithm::verifyInit(publicKey, mechanism, param, paramLen)) { @@ -864,140 +1019,140 @@ bool OSSLRSA::verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, switch (mechanism) { - case AsymMech::RSA_MD5_PKCS: - hash1 = HashAlgo::MD5; - break; - case AsymMech::RSA_SHA1_PKCS: - hash1 = HashAlgo::SHA1; - break; - case AsymMech::RSA_SHA224_PKCS: - hash1 = HashAlgo::SHA224; - break; - case AsymMech::RSA_SHA256_PKCS: - hash1 = HashAlgo::SHA256; - break; - case AsymMech::RSA_SHA384_PKCS: - hash1 = HashAlgo::SHA384; - break; - case AsymMech::RSA_SHA512_PKCS: - 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) - { - ERROR_MSG("Invalid parameters"); - ByteString dummy; - AsymmetricAlgorithm::verifyFinal(dummy); - return false; - } - sLen = ((RSA_PKCS_PSS_PARAMS*) param)->sLen; - if (sLen > ((publicKey->getBitLength()+6)/8-2-20)) - { - ERROR_MSG("sLen (%lu) is too large for current key size (%lu)", + case AsymMech::RSA_MD5_PKCS: + hash1 = HashAlgo::MD5; + break; + case AsymMech::RSA_SHA1_PKCS: + hash1 = HashAlgo::SHA1; + break; + case AsymMech::RSA_SHA224_PKCS: + hash1 = HashAlgo::SHA224; + break; + case AsymMech::RSA_SHA256_PKCS: + hash1 = HashAlgo::SHA256; + break; + case AsymMech::RSA_SHA384_PKCS: + hash1 = HashAlgo::SHA384; + break; + case AsymMech::RSA_SHA512_PKCS: + 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) + { + ERROR_MSG("Invalid parameters"); + ByteString dummy; + AsymmetricAlgorithm::verifyFinal(dummy); + return false; + } + sLen = ((RSA_PKCS_PSS_PARAMS *)param)->sLen; + if (sLen > ((publicKey->getBitLength() + 6) / 8 - 2 - 20)) + { + ERROR_MSG("sLen (%lu) is too large for current key size (%lu)", (unsigned long)sLen, publicKey->getBitLength()); - ByteString dummy; - AsymmetricAlgorithm::verifyFinal(dummy); - return false; - } - 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) - { - ERROR_MSG("Invalid parameters"); - ByteString dummy; - AsymmetricAlgorithm::verifyFinal(dummy); - return false; - } - sLen = ((RSA_PKCS_PSS_PARAMS*) param)->sLen; - if (sLen > ((publicKey->getBitLength()+6)/8-2-28)) - { - ERROR_MSG("sLen (%lu) is too large for current key size (%lu)", + ByteString dummy; + AsymmetricAlgorithm::verifyFinal(dummy); + return false; + } + 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) + { + ERROR_MSG("Invalid parameters"); + ByteString dummy; + AsymmetricAlgorithm::verifyFinal(dummy); + return false; + } + sLen = ((RSA_PKCS_PSS_PARAMS *)param)->sLen; + if (sLen > ((publicKey->getBitLength() + 6) / 8 - 2 - 28)) + { + ERROR_MSG("sLen (%lu) is too large for current key size (%lu)", (unsigned long)sLen, publicKey->getBitLength()); - ByteString dummy; - AsymmetricAlgorithm::verifyFinal(dummy); - return false; - } - hash1 = HashAlgo::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) - { - ERROR_MSG("Invalid parameters"); - ByteString dummy; - AsymmetricAlgorithm::verifyFinal(dummy); - return false; - } - sLen = ((RSA_PKCS_PSS_PARAMS*) param)->sLen; - if (sLen > ((publicKey->getBitLength()+6)/8-2-32)) - { - ERROR_MSG("sLen (%lu) is too large for current key size (%lu)", + ByteString dummy; + AsymmetricAlgorithm::verifyFinal(dummy); + return false; + } + 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) + { + ERROR_MSG("Invalid parameters"); + ByteString dummy; + AsymmetricAlgorithm::verifyFinal(dummy); + return false; + } + sLen = ((RSA_PKCS_PSS_PARAMS *)param)->sLen; + if (sLen > ((publicKey->getBitLength() + 6) / 8 - 2 - 32)) + { + ERROR_MSG("sLen (%lu) is too large for current key size (%lu)", (unsigned long)sLen, publicKey->getBitLength()); - ByteString dummy; - AsymmetricAlgorithm::verifyFinal(dummy); - return false; - } - hash1 = HashAlgo::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) - { - ERROR_MSG("Invalid parameters"); - ByteString dummy; - AsymmetricAlgorithm::verifyFinal(dummy); - return false; - } - sLen = ((RSA_PKCS_PSS_PARAMS*) param)->sLen; - if (sLen > ((publicKey->getBitLength()+6)/8-2-48)) - { - ERROR_MSG("sLen (%lu) is too large for current key size (%lu)", + ByteString dummy; + AsymmetricAlgorithm::verifyFinal(dummy); + return false; + } + 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) + { + ERROR_MSG("Invalid parameters"); + ByteString dummy; + AsymmetricAlgorithm::verifyFinal(dummy); + return false; + } + sLen = ((RSA_PKCS_PSS_PARAMS *)param)->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) - { - ERROR_MSG("Invalid parameters"); - ByteString dummy; - AsymmetricAlgorithm::verifyFinal(dummy); - return false; - } - sLen = ((RSA_PKCS_PSS_PARAMS*) param)->sLen; - if (sLen > ((publicKey->getBitLength()+6)/8-2-64)) - { - ERROR_MSG("sLen (%lu) is too large for current key size (%lu)", + 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) + { + ERROR_MSG("Invalid parameters"); + ByteString dummy; + AsymmetricAlgorithm::verifyFinal(dummy); + return false; + } + sLen = ((RSA_PKCS_PSS_PARAMS *)param)->sLen; + if (sLen > ((publicKey->getBitLength() + 6) / 8 - 2 - 64)) + { + ERROR_MSG("sLen (%lu) is too large for current key size (%lu)", (unsigned long)sLen, publicKey->getBitLength()); - ByteString dummy; - AsymmetricAlgorithm::verifyFinal(dummy); - return false; - } - hash1 = HashAlgo::SHA512; - break; - case AsymMech::RSA_SSL: - hash1 = HashAlgo::MD5; - hash2 = HashAlgo::SHA1; - break; - default: - ERROR_MSG("Invalid mechanism supplied (%i)", mechanism); - ByteString dummy; AsymmetricAlgorithm::verifyFinal(dummy); - return false; + } + hash1 = HashAlgo::SHA512; + break; + case AsymMech::RSA_SSL: + hash1 = HashAlgo::MD5; + hash2 = HashAlgo::SHA1; + break; + default: + ERROR_MSG("Invalid mechanism supplied (%i)", mechanism); + + ByteString dummy; + AsymmetricAlgorithm::verifyFinal(dummy); + + return false; } pCurrentHash = CryptoFactory::i()->getHashAlgorithm(hash1); @@ -1041,7 +1196,7 @@ bool OSSLRSA::verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, return true; } -bool OSSLRSA::verifyUpdate(const ByteString& originalData) +bool OSSLRSA::verifyUpdate(const ByteString &originalData) { if (!AsymmetricAlgorithm::verifyUpdate(originalData)) { @@ -1076,10 +1231,10 @@ bool OSSLRSA::verifyUpdate(const ByteString& originalData) return true; } -bool OSSLRSA::verifyFinal(const ByteString& signature) +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)) @@ -1109,104 +1264,143 @@ bool OSSLRSA::verifyFinal(const ByteString& signature) ByteString digest = firstHash + secondHash; - // Determine the signature NID type - int type = 0; - bool isPSS = false; - const EVP_MD* hash = NULL; + int rsaPadding = 0; + // bool isPSS = false; + const EVP_MD *hash = NULL; switch (mechanism) { - case AsymMech::RSA_MD5_PKCS: - type = NID_md5; - break; - case AsymMech::RSA_SHA1_PKCS: - type = NID_sha1; - break; - case AsymMech::RSA_SHA224_PKCS: - type = NID_sha224; - break; - case AsymMech::RSA_SHA256_PKCS: - type = NID_sha256; - break; - case AsymMech::RSA_SHA384_PKCS: - type = NID_sha384; - break; - case AsymMech::RSA_SHA512_PKCS: - type = NID_sha512; - break; - case AsymMech::RSA_SHA1_PKCS_PSS: - isPSS = true; - hash = EVP_sha1(); - break; - case AsymMech::RSA_SHA224_PKCS_PSS: - isPSS = true; - hash = EVP_sha224(); - break; - case AsymMech::RSA_SHA256_PKCS_PSS: - isPSS = true; - hash = EVP_sha256(); - break; - case AsymMech::RSA_SHA384_PKCS_PSS: - isPSS = true; - hash = EVP_sha384(); - break; - case AsymMech::RSA_SHA512_PKCS_PSS: - isPSS = true; - hash = EVP_sha512(); - break; - case AsymMech::RSA_SSL: - type = NID_md5_sha1; - break; - default: - break; + case AsymMech::RSA_MD5_PKCS: + rsaPadding = RSA_PKCS1_PADDING; + hash = EVP_md5(); + break; + case AsymMech::RSA_SHA1_PKCS: + rsaPadding = RSA_PKCS1_PADDING; + hash = EVP_sha1(); + break; + case AsymMech::RSA_SHA224_PKCS: + rsaPadding = RSA_PKCS1_PADDING; + hash = EVP_sha224(); + break; + case AsymMech::RSA_SHA256_PKCS: + rsaPadding = RSA_PKCS1_PADDING; + hash = EVP_sha256(); + break; + case AsymMech::RSA_SHA384_PKCS: + rsaPadding = RSA_PKCS1_PADDING; + hash = EVP_sha384(); + break; + case AsymMech::RSA_SHA512_PKCS: + rsaPadding = RSA_PKCS1_PADDING; + hash = EVP_sha512(); + break; + case AsymMech::RSA_SHA1_PKCS_PSS: + rsaPadding = RSA_PKCS1_PSS_PADDING; + hash = EVP_sha1(); + break; + case AsymMech::RSA_SHA224_PKCS_PSS: + rsaPadding = RSA_PKCS1_PSS_PADDING; + hash = EVP_sha224(); + break; + case AsymMech::RSA_SHA256_PKCS_PSS: + rsaPadding = RSA_PKCS1_PSS_PADDING; + hash = EVP_sha256(); + break; + case AsymMech::RSA_SHA384_PKCS_PSS: + rsaPadding = RSA_PKCS1_PSS_PADDING; + hash = EVP_sha384(); + break; + case AsymMech::RSA_SHA512_PKCS_PSS: + rsaPadding = RSA_PKCS1_PSS_PADDING; + hash = EVP_sha512(); + break; + case AsymMech::RSA_SSL: + rsaPadding = RSA_PKCS1_PADDING; + hash = EVP_md5_sha1(); + break; + default: + break; } - // Perform the verify operation - bool rv; - if (isPSS) + EVP_PKEY_CTX *ctx = EVP_PKEY_CTX_new(pk->getOSSLKey(), NULL); + if (ctx == NULL) { - 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) + 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 sign verify 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) { - rv = false; - ERROR_MSG("RSA public decrypt failed (0x%08X)", ERR_get_error()); + EVP_PKEY_CTX_free(ctx); + ERROR_MSG("RSA verify set mgf1 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) + { + 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); + + /* + if (isPSS) { - plain.resize(result); - result = RSA_verify_PKCS1_PSS(pk->getOSSLKey(), &digest[0], - hash, &plain[0], sLen); - if (result == 1) + 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 = true; + rv = false; + ERROR_MSG("RSA public decrypt failed (0x%08X)", ERR_get_error()); } else { - rv = false; - ERROR_MSG("RSA PSS verify failed (0x%08X)", ERR_get_error()); + 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()); + } } } - } - else - { - rv = (RSA_verify(type, &digest[0], digest.size(), (unsigned char*) signature.const_byte_str(), signature.size(), pk->getOSSLKey()) == 1); + else + { + 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()); - } + if (!rv) + ERROR_MSG("RSA verify failed (0x%08X)", ERR_get_error()); + } - return rv; + return rv; */ } // Encryption functions -bool OSSLRSA::encrypt(PublicKey* publicKey, const ByteString& data, - ByteString& encryptedData, const AsymMech::Type padding) +bool OSSLRSA::encrypt(PublicKey *publicKey, const ByteString &data, + ByteString &encryptedData, const AsymMech::Type padding, const void *param, const size_t paramLen) { // Check if the public key is the right type if (!publicKey->isOfType(OSSLRSAPublicKey::type)) @@ -1217,16 +1411,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 RSA_PKCS_OAEP_PARAMS *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"); @@ -1237,9 +1434,61 @@ bool OSSLRSA::encrypt(PublicKey* publicKey, const ByteString& data, } else if (padding == AsymMech::RSA_PKCS_OAEP) { + if ((param == NULL)||(paramLen != sizeof(RSA_PKCS_OAEP_PARAMS))) + { + ERROR_MSG("Invalid RSA enryption OAEP parameter supplied"); + return false; + } + oaepParam = (RSA_PKCS_OAEP_PARAMS *)param; + 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->mgf) + { + 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)) + if (data.size() > (size_t)(EVP_PKEY_size(rsa) - (2 * hashLen + 1))) // -41 { ERROR_MSG("Too much data supplied for RSA OAEP encryption"); @@ -1251,13 +1500,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_get_size(rsa)) { ERROR_MSG("Incorrect amount of input data supplied for raw RSA encryption"); return false; } - osslPadding = RSA_NO_PADDING; } else @@ -1268,21 +1516,58 @@ bool OSSLRSA::encrypt(PublicKey* publicKey, const ByteString& data, } // Perform the RSA operation - encryptedData.resize(RSA_size(rsa)); + size_t encLen = EVP_PKEY_get_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 signature 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 failed (0x%08X)", ERR_get_error()); + return false; + } + if (osslPadding == RSA_PKCS1_OAEP_PADDING) + { + void *labelData=NULL; + if (oaepParam->sourceDataLen != 0) + labelData = OPENSSL_memdup(oaepParam->sourceData,oaepParam->sourceDataLen); + if ((EVP_PKEY_CTX_set_rsa_oaep_md(ctx, hash) <= 0) || + (EVP_PKEY_CTX_set_rsa_mgf1_md(ctx, mgf) <= 0) || + (EVP_PKEY_CTX_set0_rsa_oaep_label(ctx, labelData, oaepParam->sourceDataLen) <= 0)) + { + EVP_PKEY_CTX_free(ctx); + ERROR_MSG("RSA encrypt set oaep parameters 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); + /*if (RSA_public_encrypt(data.size(), (unsigned char *)data.const_byte_str(), &encryptedData[0], rsa, osslPadding) == -1) + { + ERROR_MSG("RSA public key encryption failed (0x%08X)", ERR_get_error()); + + return false; + } */ + encryptedData.resize(encLen); return true; } // Decryption functions -bool OSSLRSA::decrypt(PrivateKey* privateKey, const ByteString& encryptedData, - ByteString& data, const AsymMech::Type padding) +bool OSSLRSA::decrypt(PrivateKey *privateKey, const ByteString &encryptedData, + ByteString &data, const AsymMech::Type padding, const void *param, const size_t paramLen) { // Check if the private key is the right type if (!privateKey->isOfType(OSSLRSAPrivateKey::type)) @@ -1293,10 +1578,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 RSA_PKCS_OAEP_PARAMS *oaepParam = NULL; // Check the input size - if (encryptedData.size() != (size_t) RSA_size(rsa)) + if (encryptedData.size() != (size_t)EVP_PKEY_get_size(rsa)) { ERROR_MSG("Invalid amount of input data supplied for RSA decryption"); @@ -1305,34 +1591,119 @@ 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; + osslPadding = RSA_PKCS1_PADDING; + } + else if (padding == AsymMech::RSA_PKCS_OAEP) + { + osslPadding = RSA_PKCS1_OAEP_PADDING; + if ((param == NULL)||(paramLen != sizeof(RSA_PKCS_OAEP_PARAMS))) + { + ERROR_MSG("Invalid RSA decryption OAEP parameter supplied"); + return false; + } + oaepParam = (RSA_PKCS_OAEP_PARAMS *)param; + switch (oaepParam->hashAlg) + { + case HashAlgo::SHA1: + hash = EVP_sha1(); + break; + case HashAlgo::SHA224: + hash = EVP_sha224(); break; - case AsymMech::RSA_PKCS_OAEP: - osslPadding = RSA_PKCS1_OAEP_PADDING; + case HashAlgo::SHA256: + hash = EVP_sha256(); + break; + case HashAlgo::SHA384: + hash = EVP_sha384(); break; - case AsymMech::RSA: - osslPadding = RSA_NO_PADDING; + case HashAlgo::SHA512: + hash = EVP_sha512(); break; default: - ERROR_MSG("Invalid padding mechanism supplied (%i)", padding); return false; + } + switch (oaepParam->mgf) + { + 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)); + size_t decSize = EVP_PKEY_get_size(rsa); - int decSize = RSA_private_decrypt(encryptedData.size(), (unsigned char*) encryptedData.const_byte_str(), &data[0], rsa, osslPadding); + 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_decrypt_init(ctx) <= 0) || + (EVP_PKEY_CTX_set_rsa_padding(ctx, osslPadding) <= 0)) + { + EVP_PKEY_CTX_free(ctx); + ERROR_MSG("RSA encrypt failed (0x%08X)", ERR_get_error()); + return false; + } + if (osslPadding == RSA_PKCS1_OAEP_PADDING) + { + void *labelData=NULL; + if (oaepParam->sourceDataLen != 0) + labelData = OPENSSL_memdup(oaepParam->sourceData,oaepParam->sourceDataLen); + if ((EVP_PKEY_CTX_set_rsa_oaep_md(ctx, hash) <= 0) || + (EVP_PKEY_CTX_set_rsa_mgf1_md(ctx, mgf) <= 0) || + (EVP_PKEY_CTX_set0_rsa_oaep_label(ctx, labelData, oaepParam->sourceDataLen) <= 0)) + { + EVP_PKEY_CTX_free(ctx); + ERROR_MSG("RSA verify set mgf1 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); + + /*int decSize = RSA_private_decrypt(encryptedData.size(), (unsigned char *)encryptedData.const_byte_str(), &data[0], rsa, osslPadding); if (decSize == -1) { ERROR_MSG("RSA private key decryption failed (0x%08X)", ERR_get_error()); return false; - } + } */ data.resize(decSize); @@ -1340,11 +1711,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; } @@ -1356,7 +1727,7 @@ bool OSSLRSA::generateKeyPair(AsymmetricKeyPair** ppKeyPair, AsymmetricParameter return false; } - RSAParameters* params = (RSAParameters*) parameters; + RSAParameters *params = (RSAParameters *)parameters; if (params->getBitLength() < getMinKeySize() || params->getBitLength() > getMaxKeySize()) { @@ -1382,7 +1753,7 @@ bool OSSLRSA::generateKeyPair(AsymmetricKeyPair** ppKeyPair, AsymmetricParameter } // Generate the key-pair - RSA* rsa = RSA_new(); + EVP_PKEY *rsa = EVP_PKEY_new(); if (rsa == NULL) { ERROR_MSG("Failed to instantiate OpenSSL RSA object"); @@ -1390,29 +1761,48 @@ bool OSSLRSA::generateKeyPair(AsymmetricKeyPair** ppKeyPair, AsymmetricParameter return false; } - BIGNUM* bn_e = OSSL::byteString2bn(params->getE()); - + 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)) + EVP_PKEY_CTX *ctx = EVP_PKEY_CTX_new_id(EVP_PKEY_RSA, NULL); + if (ctx == NULL) + { + ERROR_MSG("Failed to create RSA key creation context"); + BN_free(bn_e); + EVP_PKEY_free(rsa); + return false; + } + if ((EVP_PKEY_keygen_init(ctx) <= 0) || + (EVP_PKEY_CTX_set_rsa_keygen_bits(ctx, params->getBitLength()) <= 0) || + (EVP_PKEY_CTX_set1_rsa_keygen_pubexp(ctx, bn_e) <= 0) || + (EVP_PKEY_keygen(ctx, &rsa) <= 0)) { ERROR_MSG("RSA key generation failed (0x%08X)", ERR_get_error()); BN_free(bn_e); - RSA_free(rsa); - + EVP_PKEY_CTX_free(ctx); + EVP_PKEY_free(rsa); return false; } - BN_free(bn_e); + /*if (!RSA_generate_key_ex(rsa, params->getBitLength(), bn_e, NULL)) + { + ERROR_MSG("RSA key generation failed (0x%08X)", ERR_get_error()); + BN_free(bn_e); + EVP_PKEY_free(rsa); + + return false; + }*/ + BN_free(bn_e); + EVP_PKEY_CTX_free(ctx); // Create an asymmetric key-pair object to return - OSSLRSAKeyPair* kp = new OSSLRSAKeyPair(); + 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; } @@ -1432,11 +1822,11 @@ unsigned long OSSLRSA::getMaxKeySize() return OPENSSL_RSA_MAX_MODULUS_BITS; } -bool OSSLRSA::reconstructKeyPair(AsymmetricKeyPair** ppKeyPair, ByteString& serialisedData) +bool OSSLRSA::reconstructKeyPair(AsymmetricKeyPair **ppKeyPair, ByteString &serialisedData) { // Check input if ((ppKeyPair == NULL) || - (serialisedData.size() == 0)) + (serialisedData.size() == 0)) { return false; } @@ -1444,16 +1834,16 @@ bool OSSLRSA::reconstructKeyPair(AsymmetricKeyPair** ppKeyPair, ByteString& seri ByteString dPub = ByteString::chainDeserialise(serialisedData); ByteString dPriv = ByteString::chainDeserialise(serialisedData); - OSSLRSAKeyPair* kp = new OSSLRSAKeyPair(); + OSSLRSAKeyPair *kp = new OSSLRSAKeyPair(); 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; } @@ -1470,16 +1860,16 @@ bool OSSLRSA::reconstructKeyPair(AsymmetricKeyPair** ppKeyPair, ByteString& seri return true; } -bool OSSLRSA::reconstructPublicKey(PublicKey** ppPublicKey, ByteString& serialisedData) +bool OSSLRSA::reconstructPublicKey(PublicKey **ppPublicKey, ByteString &serialisedData) { // Check input if ((ppPublicKey == NULL) || - (serialisedData.size() == 0)) + (serialisedData.size() == 0)) { return false; } - OSSLRSAPublicKey* pub = new OSSLRSAPublicKey(); + OSSLRSAPublicKey *pub = new OSSLRSAPublicKey(); if (!pub->deserialise(serialisedData)) { @@ -1493,16 +1883,16 @@ bool OSSLRSA::reconstructPublicKey(PublicKey** ppPublicKey, ByteString& serialis return true; } -bool OSSLRSA::reconstructPrivateKey(PrivateKey** ppPrivateKey, ByteString& serialisedData) +bool OSSLRSA::reconstructPrivateKey(PrivateKey **ppPrivateKey, ByteString &serialisedData) { // Check input if ((ppPrivateKey == NULL) || - (serialisedData.size() == 0)) + (serialisedData.size() == 0)) { return false; } - OSSLRSAPrivateKey* priv = new OSSLRSAPrivateKey(); + OSSLRSAPrivateKey *priv = new OSSLRSAPrivateKey(); if (!priv->deserialise(serialisedData)) { @@ -1516,22 +1906,22 @@ 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) +bool OSSLRSA::reconstructParameters(AsymmetricParameters **ppParams, ByteString &serialisedData) { // Check input parameters if ((ppParams == NULL) || (serialisedData.size() == 0)) @@ -1539,7 +1929,7 @@ bool OSSLRSA::reconstructParameters(AsymmetricParameters** ppParams, ByteString& return false; } - RSAParameters* params = new RSAParameters(); + RSAParameters *params = new RSAParameters(); if (!params->deserialise(serialisedData)) { diff --git a/src/lib/crypto/OSSLRSA.h b/src/lib/crypto/OSSLRSA.h index 5b7db6d6..1d31090f 100644 --- a/src/lib/crypto/OSSLRSA.h +++ b/src/lib/crypto/OSSLRSA.h @@ -60,10 +60,12 @@ class OSSLRSA : public AsymmetricAlgorithm 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 void* param = NULL, const size_t paramLen = 0); // 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 void* param = NULL, const size_t paramLen = 0); // 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 26065cf3..19e0c9a6 100644 --- a/src/lib/crypto/OSSLRSAPrivateKey.cpp +++ b/src/lib/crypto/OSSLRSAPrivateKey.cpp @@ -37,6 +37,7 @@ #include "OSSLUtil.h" #include #include +#include #ifdef WITH_FIPS #include #endif @@ -48,7 +49,7 @@ OSSLRSAPrivateKey::OSSLRSAPrivateKey() rsa = NULL; } -OSSLRSAPrivateKey::OSSLRSAPrivateKey(const RSA* inRSA) +OSSLRSAPrivateKey::OSSLRSAPrivateKey(const EVP_PKEY *inRSA) { rsa = NULL; @@ -58,27 +59,36 @@ 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) { - const BIGNUM* bn_p = NULL; - const BIGNUM* bn_q = NULL; - const BIGNUM* bn_dmp1 = NULL; - const BIGNUM* bn_dmq1 = NULL; - const BIGNUM* bn_iqmp = NULL; - 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); + 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; +#if OPENSSL_VERSION_NUMBER >= 0x30000000L + 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); +#endif + // 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); if (bn_p) { @@ -123,118 +133,112 @@ void OSSLRSAPrivateKey::setFromOSSL(const RSA* inRSA) } // Check if the key is of the given type -bool OSSLRSAPrivateKey::isOfType(const char* inType) +bool OSSLRSAPrivateKey::isOfType(const char *inType) { return !strcmp(type, inType); } // Setters for the RSA private key components -void OSSLRSAPrivateKey::setP(const ByteString& inP) +void OSSLRSAPrivateKey::setP(const ByteString &inP) { RSAPrivateKey::setP(inP); if (rsa) { - RSA_free(rsa); + EVP_PKEY_free(rsa); rsa = NULL; } } -void OSSLRSAPrivateKey::setQ(const ByteString& inQ) +void OSSLRSAPrivateKey::setQ(const ByteString &inQ) { RSAPrivateKey::setQ(inQ); if (rsa) { - RSA_free(rsa); + EVP_PKEY_free(rsa); rsa = NULL; } } -void OSSLRSAPrivateKey::setPQ(const ByteString& inPQ) +void OSSLRSAPrivateKey::setPQ(const ByteString &inPQ) { RSAPrivateKey::setPQ(inPQ); if (rsa) { - RSA_free(rsa); + EVP_PKEY_free(rsa); rsa = NULL; } } -void OSSLRSAPrivateKey::setDP1(const ByteString& inDP1) +void OSSLRSAPrivateKey::setDP1(const ByteString &inDP1) { RSAPrivateKey::setDP1(inDP1); if (rsa) { - RSA_free(rsa); + EVP_PKEY_free(rsa); rsa = NULL; } } -void OSSLRSAPrivateKey::setDQ1(const ByteString& inDQ1) +void OSSLRSAPrivateKey::setDQ1(const ByteString &inDQ1) { RSAPrivateKey::setDQ1(inDQ1); if (rsa) { - RSA_free(rsa); + EVP_PKEY_free(rsa); rsa = NULL; } } -void OSSLRSAPrivateKey::setD(const ByteString& inD) +void OSSLRSAPrivateKey::setD(const ByteString &inD) { RSAPrivateKey::setD(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) +void OSSLRSAPrivateKey::setN(const ByteString &inN) { RSAPrivateKey::setN(inN); if (rsa) { - RSA_free(rsa); + EVP_PKEY_free(rsa); rsa = NULL; } } -void OSSLRSAPrivateKey::setE(const ByteString& inE) +void OSSLRSAPrivateKey::setE(const ByteString &inE) { RSAPrivateKey::setE(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) { @@ -242,36 +246,38 @@ ByteString OSSLRSAPrivateKey::PKCS8Encode() return der; } der.resize(len); - unsigned char* priv = &der[0]; + 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; } // Decode from PKCS#8 BER -bool OSSLRSAPrivateKey::PKCS8Decode(const ByteString& ber) +bool OSSLRSAPrivateKey::PKCS8Decode(const ByteString &ber) { int len = ber.size(); - 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 (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); 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,15 +285,15 @@ RSA* OSSLRSAPrivateKey::getOSSLKey() // Create the OpenSSL representation of the key void OSSLRSAPrivateKey::createOSSLKey() { - if (rsa != NULL) return; + if (rsa != NULL) + return; - rsa = RSA_new(); + rsa = EVP_PKEY_new(); if (rsa == NULL) { ERROR_MSG("Could not create RSA object"); return; } - // Use the OpenSSL implementation and not any engine #if OPENSSL_VERSION_NUMBER < 0x10100000L || defined(LIBRESSL_VERSION_NUMBER) @@ -301,20 +307,78 @@ void OSSLRSAPrivateKey::createOSSLKey() #endif #else - RSA_set_method(rsa, RSA_PKCS1_OpenSSL()); + // RSA_set_method(rsa, RSA_PKCS1_OpenSSL()); #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); + 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(); + + 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)) + { + OSSL_PARAM_BLD_free(param_bld); + ERROR_MSG("Could not build RSA key parameters"); + EVP_PKEY_free(rsa); + rsa = NULL; + return; + } + if (bn_p != NULL) + OSSL_PARAM_BLD_push_BN(param_bld, "rsa-factor1", bn_p); + if (bn_q != NULL) + OSSL_PARAM_BLD_push_BN(param_bld, "rsa-factor2", bn_q); + if (bn_dmp1 != NULL) + OSSL_PARAM_BLD_push_BN(param_bld, "rsa-exponent1", bn_dmp1); + if (bn_dmq1 != NULL) + OSSL_PARAM_BLD_push_BN(param_bld, "rsa-exponent2", bn_dmq1); + if (bn_iqmp != NULL) + OSSL_PARAM_BLD_push_BN(param_bld, "rsa-coefficient1", bn_iqmp); + + OSSL_PARAM *params = OSSL_PARAM_BLD_to_param(param_bld); + OSSL_PARAM_BLD_free(param_bld); + if (params == NULL) + { + ERROR_MSG("Could not build RSA key parameters"); + EVP_PKEY_free(rsa); + rsa = NULL; + 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); + EVP_PKEY_free(rsa); + rsa = NULL; + 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); + EVP_PKEY_free(rsa); + rsa = NULL; + return; + } + OSSL_PARAM_free(params); + EVP_PKEY_CTX_free(ctx); +#endif + // 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 bb876d50..8294eed5 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 2a6893bf..f29b11bb 100644 --- a/src/lib/crypto/OSSLRSAPublicKey.cpp +++ b/src/lib/crypto/OSSLRSAPublicKey.cpp @@ -37,6 +37,7 @@ #include "OSSLUtil.h" #include #include +#include #ifdef WITH_FIPS #include #endif @@ -47,7 +48,7 @@ OSSLRSAPublicKey::OSSLRSAPublicKey() rsa = NULL; } -OSSLRSAPublicKey::OSSLRSAPublicKey(const RSA* inRSA) +OSSLRSAPublicKey::OSSLRSAPublicKey(const EVP_PKEY *inRSA) { rsa = NULL; @@ -57,65 +58,69 @@ OSSLRSAPublicKey::OSSLRSAPublicKey(const RSA* inRSA) // Destructor OSSLRSAPublicKey::~OSSLRSAPublicKey() { - RSA_free(rsa); + EVP_PKEY_free(rsa); } // The type -/*static*/ const char* OSSLRSAPublicKey::type = "OpenSSL RSA Public Key"; +/*static*/ const char *OSSLRSAPublicKey::type = "OpenSSL RSA Public Key"; // Check if the key is of the given type -bool OSSLRSAPublicKey::isOfType(const char* inType) +bool OSSLRSAPublicKey::isOfType(const char *inType) { return !strcmp(type, 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); - + BIGNUM *bn_n = NULL; + BIGNUM *bn_e = NULL; +#if OPENSSL_VERSION_NUMBER >= 0x30000000L + EVP_PKEY_get_bn_param(inRSA, "n", &bn_n); + EVP_PKEY_get_bn_param(inRSA, "e", &bn_e); +#endif if (bn_n) { ByteString inN = OSSL::bn2ByteString(bn_n); setN(inN); + BN_free(bn_n); } if (bn_e) { ByteString inE = OSSL::bn2ByteString(bn_e); setE(inE); + BN_free(bn_e); } } // Setters for the RSA public key components -void OSSLRSAPublicKey::setN(const ByteString& inN) +void OSSLRSAPublicKey::setN(const ByteString &inN) { RSAPublicKey::setN(inN); if (rsa) { - RSA_free(rsa); + EVP_PKEY_free(rsa); rsa = NULL; } } -void OSSLRSAPublicKey::setE(const ByteString& inE) +void OSSLRSAPublicKey::setE(const ByteString &inE) { RSAPublicKey::setE(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,9 +128,10 @@ RSA* OSSLRSAPublicKey::getOSSLKey() // Create the OpenSSL representation of the key void OSSLRSAPublicKey::createOSSLKey() { - if (rsa != NULL) return; + if (rsa != NULL) + return; - rsa = RSA_new(); + rsa = EVP_PKEY_new(); if (rsa == NULL) { ERROR_MSG("Could not create RSA object"); @@ -145,11 +151,50 @@ void OSSLRSAPublicKey::createOSSLKey() #endif #else - RSA_set_method(rsa, RSA_PKCS1_OpenSSL()); + // RSA_set_method(rsa, RSA_PKCS1_OpenSSL()); #endif BIGNUM* bn_n = OSSL::byteString2bn(n); BIGNUM* bn_e = OSSL::byteString2bn(e); - RSA_set0_key(rsa, bn_n, bn_e, NULL); +#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 )) + { + OSSL_PARAM_BLD_free(param_bld); + ERROR_MSG("Could not build RSA key parameters"); + EVP_PKEY_free(rsa); + rsa = NULL; + return; + } + OSSL_PARAM *params = OSSL_PARAM_BLD_to_param(param_bld); + OSSL_PARAM_BLD_free(param_bld); + + EVP_PKEY_CTX *ctx = EVP_PKEY_CTX_new_from_name(NULL, "RSA", NULL); + if (ctx == NULL) + { + ERROR_MSG("Could not create RSA creation context"); + OSSL_PARAM_free(params); + EVP_PKEY_free(rsa); + rsa = NULL; + 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); + EVP_PKEY_free(rsa); + rsa = NULL; + return; + } + OSSL_PARAM_free(params); + EVP_PKEY_CTX_free(ctx); +#endif } diff --git a/src/lib/crypto/OSSLRSAPublicKey.h b/src/lib/crypto/OSSLRSAPublicKey.h index 98f99f20..5e0fa52d 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(); From 31b359a772c89c48671c1870ca59db9f96ded0d4 Mon Sep 17 00:00:00 2001 From: Golikov Pavel Evgenevich Date: Wed, 24 Dec 2025 17:24:06 +0300 Subject: [PATCH 04/15] Fix RSA encrypt-decrypt tests --- src/lib/crypto/test/RSATests.cpp | 83 +++++++++++++++++++++--- src/lib/test/AsymEncryptDecryptTests.cpp | 5 +- 2 files changed, 77 insertions(+), 11 deletions(-) diff --git a/src/lib/crypto/test/RSATests.cpp b/src/lib/crypto/test/RSATests.cpp index 6af1e19f..95e98a1b 100644 --- a/src/lib/crypto/test/RSATests.cpp +++ b/src/lib/crypto/test/RSATests.cpp @@ -601,7 +601,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 +616,24 @@ 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_PKCS_OAEP); paddings.push_back(AsymMech::RSA); + //OAEP parameters for test + std::vector oaep_parameters; + oaep_parameters.push_back({HashAlgo::SHA1,AsymRSAMGF::MGF1_SHA1, NULL,0}); + oaep_parameters.push_back({HashAlgo::SHA256,AsymRSAMGF::MGF1_SHA256, NULL,0}); + oaep_parameters.push_back({HashAlgo::SHA384,AsymRSAMGF::MGF1_SHA384, NULL,0}); + oaep_parameters.push_back({HashAlgo::SHA512,AsymRSAMGF::MGF1_SHA512, NULL,0}); + oaep_parameters.push_back({HashAlgo::SHA1,AsymRSAMGF::MGF1_SHA256, NULL,0}); + oaep_parameters.push_back({HashAlgo::SHA512,AsymRSAMGF::MGF1_SHA224, TestLabel ,strlen(TestLabel)}); + oaep_parameters.push_back({HashAlgo::SHA1,AsymRSAMGF::MGF1_SHA256, TestLabel ,strlen(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 +650,14 @@ void RSATests::testEncryptDecrypt() { // Generate some test data to encrypt based on the selected padding ByteString testData; + void *parameters = NULL; + size_t paramLen = 0; 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 +670,54 @@ void RSATests::testEncryptDecrypt() // Encrypt the data ByteString encryptedData; + CPPUNIT_ASSERT(rsa->encrypt(kp->getPublicKey(), testData, encryptedData, *pad, parameters, paramLen)); + // 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, parameters, paramLen)); + // 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; + + void *parameters = &(par->hashAlg); + size_t paramLen = sizeof(RSA_PKCS_OAEP_PARAMS); + 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, parameters, paramLen)); // The encrypted data length should equal the modulus length CPPUNIT_ASSERT(encryptedData.size() == (*k >> 3)); CPPUNIT_ASSERT(encryptedData != testData); @@ -669,10 +725,19 @@ 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, parameters, paramLen)); // Check that the data was properly decrypted CPPUNIT_ASSERT(decryptedData == testData); + + // Now decrypt the data with invalid label + ByteString decryptedData1; + RSA_PKCS_OAEP_PARAMS param1; + param1.hashAlg = par->hashAlg; + param1.mgf = par->mgf; + param1.sourceData = InvalidLabel; + param1.sourceDataLen = strlen(InvalidLabel); + CPPUNIT_ASSERT(rsa->decrypt(kp->getPrivateKey(), encryptedData, decryptedData1, AsymMech::RSA_PKCS_OAEP, ¶m1, paramLen) == false); } rsa->recycleKeyPair(kp); diff --git a/src/lib/test/AsymEncryptDecryptTests.cpp b/src/lib/test/AsymEncryptDecryptTests.cpp index 2a537d00..f6b6b9d2 100644 --- a/src/lib/test/AsymEncryptDecryptTests.cpp +++ b/src/lib/test/AsymEncryptDecryptTests.cpp @@ -137,10 +137,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; From 9edab6c8afa1cd56b36c6aa46d63867d75a4510d Mon Sep 17 00:00:00 2001 From: Golikov Pavel Evgenevich Date: Thu, 25 Dec 2025 13:42:45 +0300 Subject: [PATCH 05/15] Fix memory leaks and messages --- src/lib/SoftHSM.cpp | 43 +++++++------ src/lib/crypto/OSSLRSA.cpp | 66 ++++++++----------- src/lib/crypto/OSSLRSAPrivateKey.cpp | 95 ++++++++++++++-------------- src/lib/crypto/OSSLRSAPublicKey.cpp | 53 +++++++--------- 4 files changed, 124 insertions(+), 133 deletions(-) diff --git a/src/lib/SoftHSM.cpp b/src/lib/SoftHSM.cpp index 6c2c8de2..e7e2ad71 100644 --- a/src/lib/SoftHSM.cpp +++ b/src/lib/SoftHSM.cpp @@ -2510,8 +2510,8 @@ CK_RV SoftHSM::AsymEncryptInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMec } else { - return CKR_MECHANISM_INVALID; - } + return CKR_MECHANISM_INVALID; + } // set mechanism parameters void *parameters = NULL; size_t paramLen = 0; @@ -2537,6 +2537,8 @@ CK_RV SoftHSM::AsymEncryptInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMec oaep_param.hashAlg = HashAlgo::SHA512; break; default: + asymCrypto->recyclePublicKey(publicKey); + CryptoFactory::i()->recycleAsymmetricAlgorithm(asymCrypto); return CKR_ARGUMENTS_BAD; } switch (par1->mgf) @@ -2557,6 +2559,8 @@ CK_RV SoftHSM::AsymEncryptInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMec oaep_param.mgf = AsymRSAMGF::MGF1_SHA512; break; default: + asymCrypto->recyclePublicKey(publicKey); + CryptoFactory::i()->recycleAsymmetricAlgorithm(asymCrypto); return CKR_ARGUMENTS_BAD; } // need copy parameters to session context @@ -2564,7 +2568,11 @@ CK_RV SoftHSM::AsymEncryptInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMec paramLen = sizeof(RSA_PKCS_OAEP_PARAMS) + par1->ulSourceDataLen; parameters = malloc(paramLen); if (parameters == NULL) - return CKR_HOST_MEMORY; + { + asymCrypto->recyclePublicKey(publicKey); + CryptoFactory::i()->recycleAsymmetricAlgorithm(asymCrypto); + return CKR_HOST_MEMORY; + } oaep_param.sourceData = (char*)parameters + sizeof(RSA_PKCS_OAEP_PARAMS); oaep_param.sourceDataLen = par1->ulSourceDataLen; memcpy(parameters,&oaep_param,sizeof(RSA_PKCS_OAEP_PARAMS)); @@ -3274,22 +3282,9 @@ CK_RV SoftHSM::AsymDecryptInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMec case CKM_RSA_PKCS_OAEP: if (keyType != CKK_RSA) return CKR_KEY_TYPE_INCONSISTENT; - if (pMechanism->pParameter == NULL_PTR || - pMechanism->ulParameterLen != sizeof(CK_RSA_PKCS_OAEP_PARAMS)) - { - DEBUG_MSG("pParameter must be of type CK_RSA_PKCS_OAEP_PARAMS"); - return CKR_ARGUMENTS_BAD; - } - if (CK_RSA_PKCS_OAEP_PARAMS_PTR(pMechanism->pParameter)->hashAlg != CKM_SHA_1) - { - DEBUG_MSG("hashAlg must be CKM_SHA_1"); - return CKR_ARGUMENTS_BAD; - } - if (CK_RSA_PKCS_OAEP_PARAMS_PTR(pMechanism->pParameter)->mgf != CKG_MGF1_SHA1) - { - DEBUG_MSG("mgf must be CKG_MGF1_SHA1"); - return CKR_ARGUMENTS_BAD; - } + rv = MechParamCheckRSAPKCSOAEP(pMechanism); + if (rv != CKR_OK) + return rv; mechanism = AsymMech::RSA_PKCS_OAEP; isRSA = true; @@ -3354,6 +3349,8 @@ CK_RV SoftHSM::AsymDecryptInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMec oaep_param.hashAlg = HashAlgo::SHA512; break; default: + asymCrypto->recyclePrivateKey(privateKey); + CryptoFactory::i()->recycleAsymmetricAlgorithm(asymCrypto); return CKR_ARGUMENTS_BAD; } switch (par1->mgf) @@ -3374,6 +3371,8 @@ CK_RV SoftHSM::AsymDecryptInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMec oaep_param.mgf = AsymRSAMGF::MGF1_SHA512; break; default: + asymCrypto->recyclePrivateKey(privateKey); + CryptoFactory::i()->recycleAsymmetricAlgorithm(asymCrypto); return CKR_ARGUMENTS_BAD; } // need copy parameters to session context @@ -3381,7 +3380,11 @@ CK_RV SoftHSM::AsymDecryptInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMec paramLen = sizeof(RSA_PKCS_OAEP_PARAMS) + par1->ulSourceDataLen; parameters = malloc(paramLen); if (parameters == NULL) - return CKR_HOST_MEMORY; + { + asymCrypto->recyclePrivateKey(privateKey); + CryptoFactory::i()->recycleAsymmetricAlgorithm(asymCrypto); + return CKR_HOST_MEMORY; + } oaep_param.sourceData = (char*)parameters + sizeof(RSA_PKCS_OAEP_PARAMS); oaep_param.sourceDataLen = par1->ulSourceDataLen; memcpy(parameters,&oaep_param,sizeof(RSA_PKCS_OAEP_PARAMS)); diff --git a/src/lib/crypto/OSSLRSA.cpp b/src/lib/crypto/OSSLRSA.cpp index f173d337..1cf20bf3 100644 --- a/src/lib/crypto/OSSLRSA.cpp +++ b/src/lib/crypto/OSSLRSA.cpp @@ -1436,7 +1436,7 @@ bool OSSLRSA::encrypt(PublicKey *publicKey, const ByteString &data, { if ((param == NULL)||(paramLen != sizeof(RSA_PKCS_OAEP_PARAMS))) { - ERROR_MSG("Invalid RSA enryption OAEP parameter supplied"); + ERROR_MSG("Invalid RSA encryption OAEP parameter supplied"); return false; } oaepParam = (RSA_PKCS_OAEP_PARAMS *)param; @@ -1487,8 +1487,8 @@ bool OSSLRSA::encrypt(PublicKey *publicKey, const ByteString &data, return false; } // The size of the input data cannot be more than the modulus - // length of the key - 41 - if (data.size() > (size_t)(EVP_PKEY_size(rsa) - (2 * hashLen + 1))) // -41 + // length of the key - (2 * hashLen + 1) + if (data.size() > (size_t)(EVP_PKEY_size(rsa) - (2 * hashLen + 1))) { ERROR_MSG("Too much data supplied for RSA OAEP encryption"); @@ -1521,14 +1521,14 @@ bool OSSLRSA::encrypt(PublicKey *publicKey, const ByteString &data, EVP_PKEY_CTX *ctx = EVP_PKEY_CTX_new(rsa, NULL); if (ctx == NULL) { - ERROR_MSG("An error occurred while creating RSA signature context"); + 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 failed (0x%08X)", ERR_get_error()); + ERROR_MSG("RSA encrypt set padding failed (0x%08X)", ERR_get_error()); return false; } if (osslPadding == RSA_PKCS1_OAEP_PADDING) @@ -1538,11 +1538,18 @@ bool OSSLRSA::encrypt(PublicKey *publicKey, const ByteString &data, labelData = OPENSSL_memdup(oaepParam->sourceData,oaepParam->sourceDataLen); if ((EVP_PKEY_CTX_set_rsa_oaep_md(ctx, hash) <= 0) || - (EVP_PKEY_CTX_set_rsa_mgf1_md(ctx, mgf) <= 0) || - (EVP_PKEY_CTX_set0_rsa_oaep_label(ctx, labelData, oaepParam->sourceDataLen) <= 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->sourceDataLen) <= 0) { + OPENSSL_free(labelData); EVP_PKEY_CTX_free(ctx); - ERROR_MSG("RSA encrypt set oaep parameters failed (0x%08X)", ERR_get_error()); + ERROR_MSG("Set OAEP label for RSA decryption failed (0x%08X)", ERR_get_error()); return false; } } @@ -1555,12 +1562,6 @@ bool OSSLRSA::encrypt(PublicKey *publicKey, const ByteString &data, } EVP_PKEY_CTX_free(ctx); - /*if (RSA_public_encrypt(data.size(), (unsigned char *)data.const_byte_str(), &encryptedData[0], rsa, osslPadding) == -1) - { - ERROR_MSG("RSA public key encryption failed (0x%08X)", ERR_get_error()); - - return false; - } */ encryptedData.resize(encLen); return true; } @@ -1663,14 +1664,14 @@ bool OSSLRSA::decrypt(PrivateKey *privateKey, const ByteString &encryptedData, EVP_PKEY_CTX *ctx = EVP_PKEY_CTX_new(rsa, NULL); if (ctx == NULL) { - ERROR_MSG("An error occurred while creating RSA signature context"); + 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("RSA encrypt failed (0x%08X)", ERR_get_error()); + ERROR_MSG("Set padding parameter for RSA decryption failed (0x%08X)", ERR_get_error()); return false; } if (osslPadding == RSA_PKCS1_OAEP_PADDING) @@ -1679,11 +1680,18 @@ bool OSSLRSA::decrypt(PrivateKey *privateKey, const ByteString &encryptedData, if (oaepParam->sourceDataLen != 0) labelData = OPENSSL_memdup(oaepParam->sourceData,oaepParam->sourceDataLen); if ((EVP_PKEY_CTX_set_rsa_oaep_md(ctx, hash) <= 0) || - (EVP_PKEY_CTX_set_rsa_mgf1_md(ctx, mgf) <= 0) || - (EVP_PKEY_CTX_set0_rsa_oaep_label(ctx, labelData, oaepParam->sourceDataLen) <= 0)) + (EVP_PKEY_CTX_set_rsa_mgf1_md(ctx, mgf) <= 0)) { + OPENSSL_free(labelData); EVP_PKEY_CTX_free(ctx); - ERROR_MSG("RSA verify set mgf1 failed (0x%08X)", ERR_get_error()); + 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->sourceDataLen) <= 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; } } @@ -1696,15 +1704,6 @@ bool OSSLRSA::decrypt(PrivateKey *privateKey, const ByteString &encryptedData, } EVP_PKEY_CTX_free(ctx); - /*int decSize = RSA_private_decrypt(encryptedData.size(), (unsigned char *)encryptedData.const_byte_str(), &data[0], rsa, osslPadding); - - if (decSize == -1) - { - ERROR_MSG("RSA private key decryption failed (0x%08X)", ERR_get_error()); - - return false; - } */ - data.resize(decSize); return true; @@ -1753,14 +1752,7 @@ bool OSSLRSA::generateKeyPair(AsymmetricKeyPair **ppKeyPair, AsymmetricParameter } // Generate the key-pair - EVP_PKEY *rsa = EVP_PKEY_new(); - if (rsa == NULL) - { - ERROR_MSG("Failed to instantiate OpenSSL RSA object"); - - return false; - } - + 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); @@ -1768,7 +1760,6 @@ bool OSSLRSA::generateKeyPair(AsymmetricKeyPair **ppKeyPair, AsymmetricParameter { ERROR_MSG("Failed to create RSA key creation context"); BN_free(bn_e); - EVP_PKEY_free(rsa); return false; } if ((EVP_PKEY_keygen_init(ctx) <= 0) || @@ -1779,7 +1770,6 @@ bool OSSLRSA::generateKeyPair(AsymmetricKeyPair **ppKeyPair, AsymmetricParameter ERROR_MSG("RSA key generation failed (0x%08X)", ERR_get_error()); BN_free(bn_e); EVP_PKEY_CTX_free(ctx); - EVP_PKEY_free(rsa); return false; } diff --git a/src/lib/crypto/OSSLRSAPrivateKey.cpp b/src/lib/crypto/OSSLRSAPrivateKey.cpp index 19e0c9a6..f5cb0ed3 100644 --- a/src/lib/crypto/OSSLRSAPrivateKey.cpp +++ b/src/lib/crypto/OSSLRSAPrivateKey.cpp @@ -37,7 +37,9 @@ #include "OSSLUtil.h" #include #include +#if OPENSSL_VERSION_NUMBER >= 0x30000000L #include +#endif #ifdef WITH_FIPS #include #endif @@ -94,41 +96,49 @@ void OSSLRSAPrivateKey::setFromOSSL(const EVP_PKEY *inRSA) { ByteString inP = OSSL::bn2ByteString(bn_p); setP(inP); + BN_free(bn_p); } if (bn_q) { ByteString inQ = OSSL::bn2ByteString(bn_q); setQ(inQ); + BN_free(bn_q); } if (bn_dmp1) { ByteString inDP1 = OSSL::bn2ByteString(bn_dmp1); setDP1(inDP1); + BN_free(bn_dmp1); } if (bn_dmq1) { ByteString inDQ1 = OSSL::bn2ByteString(bn_dmq1); setDQ1(inDQ1); + BN_free(bn_dmq1); } if (bn_iqmp) { ByteString inPQ = OSSL::bn2ByteString(bn_iqmp); setPQ(inPQ); + BN_free(bn_iqmp); } if (bn_n) { ByteString inN = OSSL::bn2ByteString(bn_n); setN(inN); + BN_free(bn_n); } if (bn_e) { ByteString inE = OSSL::bn2ByteString(bn_e); setE(inE); + BN_free(bn_e); } if (bn_d) { ByteString inD = OSSL::bn2ByteString(bn_d); setD(inD); + BN_free(bn_d); } } @@ -288,28 +298,6 @@ void OSSLRSAPrivateKey::createOSSLKey() if (rsa != NULL) return; - rsa = EVP_PKEY_new(); - if (rsa == NULL) - { - ERROR_MSG("Could not create RSA object"); - return; - } - // Use the OpenSSL implementation and not any engine -#if OPENSSL_VERSION_NUMBER < 0x10100000L || defined(LIBRESSL_VERSION_NUMBER) - -#ifdef WITH_FIPS - if (FIPS_mode()) - RSA_set_method(rsa, FIPS_rsa_pkcs1_ssleay()); - else - RSA_set_method(rsa, RSA_PKCS1_SSLeay()); -#else - RSA_set_method(rsa, RSA_PKCS1_SSLeay()); -#endif - -#else - // RSA_set_method(rsa, RSA_PKCS1_OpenSSL()); -#endif - BIGNUM *bn_p = OSSL::byteString2bn(p); BIGNUM *bn_q = OSSL::byteString2bn(q); BIGNUM *bn_dmp1 = OSSL::byteString2bn(dp1); @@ -321,7 +309,7 @@ void OSSLRSAPrivateKey::createOSSLKey() #if OPENSSL_VERSION_NUMBER >= 0x30000000L OSSL_PARAM_BLD *param_bld = OSSL_PARAM_BLD_new(); - + bool bBuildErr = false; if ((param_bld == NULL) || (bn_n == NULL) || (bn_e == NULL) || @@ -330,30 +318,32 @@ void OSSLRSAPrivateKey::createOSSLKey() (OSSL_PARAM_BLD_push_BN(param_bld, "e", bn_e) <= 0) || (OSSL_PARAM_BLD_push_BN(param_bld, "d", bn_d) <= 0)) { - OSSL_PARAM_BLD_free(param_bld); - ERROR_MSG("Could not build RSA key parameters"); - EVP_PKEY_free(rsa); - rsa = NULL; - return; + bBuildErr = true; } - if (bn_p != NULL) - OSSL_PARAM_BLD_push_BN(param_bld, "rsa-factor1", bn_p); - if (bn_q != NULL) - OSSL_PARAM_BLD_push_BN(param_bld, "rsa-factor2", bn_q); - if (bn_dmp1 != NULL) - OSSL_PARAM_BLD_push_BN(param_bld, "rsa-exponent1", bn_dmp1); - if (bn_dmq1 != NULL) - OSSL_PARAM_BLD_push_BN(param_bld, "rsa-exponent2", bn_dmq1); - if (bn_iqmp != NULL) - OSSL_PARAM_BLD_push_BN(param_bld, "rsa-coefficient1", bn_iqmp); + 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); OSSL_PARAM *params = OSSL_PARAM_BLD_to_param(param_bld); OSSL_PARAM_BLD_free(param_bld); - if (params == 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); + if ((bBuildErr)||(params == NULL)) { ERROR_MSG("Could not build RSA key parameters"); - EVP_PKEY_free(rsa); - rsa = NULL; return; } EVP_PKEY_CTX *ctx = EVP_PKEY_CTX_new_from_name(NULL, "RSA", NULL); @@ -361,8 +351,6 @@ void OSSLRSAPrivateKey::createOSSLKey() { ERROR_MSG("Could not create RSA key creation context"); OSSL_PARAM_free(params); - EVP_PKEY_free(rsa); - rsa = NULL; return; } if ((EVP_PKEY_fromdata_init(ctx) <= 0) || @@ -371,14 +359,29 @@ void OSSLRSAPrivateKey::createOSSLKey() ERROR_MSG("Could not create RSA key object"); OSSL_PARAM_free(params); EVP_PKEY_CTX_free(ctx); - EVP_PKEY_free(rsa); rsa = NULL; return; } OSSL_PARAM_free(params); - EVP_PKEY_CTX_free(ctx); + EVP_PKEY_CTX_free(ctx); + +#else +#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()); + else + RSA_set_method(rsa, RSA_PKCS1_SSLeay()); +#else + RSA_set_method(rsa, RSA_PKCS1_SSLeay()); +#endif + +#else + // RSA_set_method(rsa, RSA_PKCS1_OpenSSL()); #endif // 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); + // RSA_set0_key(rsa, bn_n, bn_e, bn_d); +#endif } diff --git a/src/lib/crypto/OSSLRSAPublicKey.cpp b/src/lib/crypto/OSSLRSAPublicKey.cpp index f29b11bb..63be0ff2 100644 --- a/src/lib/crypto/OSSLRSAPublicKey.cpp +++ b/src/lib/crypto/OSSLRSAPublicKey.cpp @@ -37,7 +37,9 @@ #include "OSSLUtil.h" #include #include +#if OPENSSL_VERSION_NUMBER >= 0x30000000L #include +#endif #ifdef WITH_FIPS #include #endif @@ -131,28 +133,6 @@ void OSSLRSAPublicKey::createOSSLKey() if (rsa != NULL) return; - rsa = EVP_PKEY_new(); - if (rsa == NULL) - { - ERROR_MSG("Could not create RSA object"); - return; - } - - // Use the OpenSSL implementation and not any engine -#if OPENSSL_VERSION_NUMBER < 0x10100000L || defined(LIBRESSL_VERSION_NUMBER) - -#ifdef WITH_FIPS - if (FIPS_mode()) - RSA_set_method(rsa, FIPS_rsa_pkcs1_ssleay()); - else - RSA_set_method(rsa, RSA_PKCS1_SSLeay()); -#else - RSA_set_method(rsa, RSA_PKCS1_SSLeay()); -#endif - -#else - // RSA_set_method(rsa, RSA_PKCS1_OpenSSL()); -#endif BIGNUM* bn_n = OSSL::byteString2bn(n); BIGNUM* bn_e = OSSL::byteString2bn(e); @@ -167,21 +147,21 @@ void OSSLRSAPublicKey::createOSSLKey() (OSSL_PARAM_BLD_push_BN(param_bld,"e",bn_e) <= 0 )) { OSSL_PARAM_BLD_free(param_bld); - ERROR_MSG("Could not build RSA key parameters"); - EVP_PKEY_free(rsa); - rsa = NULL; + 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); EVP_PKEY_CTX *ctx = EVP_PKEY_CTX_new_from_name(NULL, "RSA", NULL); if (ctx == NULL) { - ERROR_MSG("Could not create RSA creation context"); + ERROR_MSG("Could not create RSA public key creation context"); OSSL_PARAM_free(params); - EVP_PKEY_free(rsa); - rsa = NULL; return; } if ((EVP_PKEY_fromdata_init(ctx) <= 0) || @@ -190,11 +170,26 @@ void OSSLRSAPublicKey::createOSSLKey() ERROR_MSG("Could not create public RSA key object"); OSSL_PARAM_free(params); EVP_PKEY_CTX_free(ctx); - EVP_PKEY_free(rsa); rsa = NULL; return; } OSSL_PARAM_free(params); EVP_PKEY_CTX_free(ctx); + +#else +#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()); + else + RSA_set_method(rsa, RSA_PKCS1_SSLeay()); +#else + RSA_set_method(rsa, RSA_PKCS1_SSLeay()); +#endif + +#else + RSA_set_method(rsa, RSA_PKCS1_OpenSSL()); +#endif #endif } From 9a03665120346426841cf9620bd43d98633a794d Mon Sep 17 00:00:00 2001 From: Golikov Pavel Evgenevich Date: Thu, 25 Dec 2025 16:47:26 +0300 Subject: [PATCH 06/15] Add BuildRSAOAEPParam fuction --- src/lib/SoftHSM.cpp | 9420 ++++++++++++++++++++++--------------------- src/lib/SoftHSM.h | 4 +- 2 files changed, 4913 insertions(+), 4511 deletions(-) diff --git a/src/lib/SoftHSM.cpp b/src/lib/SoftHSM.cpp index e7e2ad71..43f0cc73 100644 --- a/src/lib/SoftHSM.cpp +++ b/src/lib/SoftHSM.cpp @@ -115,105 +115,106 @@ std::auto_ptr SoftHSM::instance(NULL); static CK_RV newP11Object(CK_OBJECT_CLASS objClass, CK_KEY_TYPE keyType, CK_CERTIFICATE_TYPE certType, P11Object **p11object) { - switch(objClass) { - case CKO_DATA: - *p11object = new P11DataObj(); - break; - case CKO_CERTIFICATE: - if (certType == CKC_X_509) - *p11object = new P11X509CertificateObj(); - else if (certType == CKC_OPENPGP) - *p11object = new P11OpenPGPPublicKeyObj(); - else - return CKR_ATTRIBUTE_VALUE_INVALID; - break; - case CKO_PUBLIC_KEY: - if (keyType == CKK_RSA) - *p11object = new P11RSAPublicKeyObj(); - else if (keyType == CKK_DSA) - *p11object = new P11DSAPublicKeyObj(); - else if (keyType == CKK_EC) - *p11object = new P11ECPublicKeyObj(); - else if (keyType == CKK_DH) - *p11object = new P11DHPublicKeyObj(); - else if (keyType == CKK_GOSTR3410) - *p11object = new P11GOSTPublicKeyObj(); - else if (keyType == CKK_EC_EDWARDS) - *p11object = new P11EDPublicKeyObj(); - else - return CKR_ATTRIBUTE_VALUE_INVALID; - break; - case CKO_PRIVATE_KEY: - // we need to know the type too - if (keyType == CKK_RSA) - *p11object = new P11RSAPrivateKeyObj(); - else if (keyType == CKK_DSA) - *p11object = new P11DSAPrivateKeyObj(); - else if (keyType == CKK_EC) - *p11object = new P11ECPrivateKeyObj(); - else if (keyType == CKK_DH) - *p11object = new P11DHPrivateKeyObj(); - else if (keyType == CKK_GOSTR3410) - *p11object = new P11GOSTPrivateKeyObj(); - else if (keyType == CKK_EC_EDWARDS) - *p11object = new P11EDPrivateKeyObj(); - else - return CKR_ATTRIBUTE_VALUE_INVALID; - break; - case CKO_SECRET_KEY: - if ((keyType == CKK_GENERIC_SECRET) || - (keyType == CKK_MD5_HMAC) || - (keyType == CKK_SHA_1_HMAC) || - (keyType == CKK_SHA224_HMAC) || - (keyType == CKK_SHA256_HMAC) || - (keyType == CKK_SHA384_HMAC) || - (keyType == CKK_SHA512_HMAC)) - { - P11GenericSecretKeyObj* key = new P11GenericSecretKeyObj(); - *p11object = key; - key->setKeyType(keyType); - } - else if (keyType == CKK_AES) - { - *p11object = new P11AESSecretKeyObj(); - } - else if ((keyType == CKK_DES) || + switch (objClass) + { + case CKO_DATA: + *p11object = new P11DataObj(); + break; + case CKO_CERTIFICATE: + if (certType == CKC_X_509) + *p11object = new P11X509CertificateObj(); + else if (certType == CKC_OPENPGP) + *p11object = new P11OpenPGPPublicKeyObj(); + else + return CKR_ATTRIBUTE_VALUE_INVALID; + break; + case CKO_PUBLIC_KEY: + if (keyType == CKK_RSA) + *p11object = new P11RSAPublicKeyObj(); + else if (keyType == CKK_DSA) + *p11object = new P11DSAPublicKeyObj(); + else if (keyType == CKK_EC) + *p11object = new P11ECPublicKeyObj(); + else if (keyType == CKK_DH) + *p11object = new P11DHPublicKeyObj(); + else if (keyType == CKK_GOSTR3410) + *p11object = new P11GOSTPublicKeyObj(); + else if (keyType == CKK_EC_EDWARDS) + *p11object = new P11EDPublicKeyObj(); + else + return CKR_ATTRIBUTE_VALUE_INVALID; + break; + case CKO_PRIVATE_KEY: + // we need to know the type too + if (keyType == CKK_RSA) + *p11object = new P11RSAPrivateKeyObj(); + else if (keyType == CKK_DSA) + *p11object = new P11DSAPrivateKeyObj(); + else if (keyType == CKK_EC) + *p11object = new P11ECPrivateKeyObj(); + else if (keyType == CKK_DH) + *p11object = new P11DHPrivateKeyObj(); + else if (keyType == CKK_GOSTR3410) + *p11object = new P11GOSTPrivateKeyObj(); + else if (keyType == CKK_EC_EDWARDS) + *p11object = new P11EDPrivateKeyObj(); + else + return CKR_ATTRIBUTE_VALUE_INVALID; + break; + case CKO_SECRET_KEY: + if ((keyType == CKK_GENERIC_SECRET) || + (keyType == CKK_MD5_HMAC) || + (keyType == CKK_SHA_1_HMAC) || + (keyType == CKK_SHA224_HMAC) || + (keyType == CKK_SHA256_HMAC) || + (keyType == CKK_SHA384_HMAC) || + (keyType == CKK_SHA512_HMAC)) + { + P11GenericSecretKeyObj *key = new P11GenericSecretKeyObj(); + *p11object = key; + key->setKeyType(keyType); + } + else if (keyType == CKK_AES) + { + *p11object = new P11AESSecretKeyObj(); + } + else if ((keyType == CKK_DES) || (keyType == CKK_DES2) || (keyType == CKK_DES3)) - { - P11DESSecretKeyObj* key = new P11DESSecretKeyObj(); - *p11object = key; - key->setKeyType(keyType); - } - else if (keyType == CKK_GOST28147) - { - *p11object = new P11GOSTSecretKeyObj(); - } - else - return CKR_ATTRIBUTE_VALUE_INVALID; - break; - case CKO_DOMAIN_PARAMETERS: - if (keyType == CKK_DSA) - *p11object = new P11DSADomainObj(); - else if (keyType == CKK_DH) - *p11object = new P11DHDomainObj(); - else - return CKR_ATTRIBUTE_VALUE_INVALID; - break; - default: - return CKR_ATTRIBUTE_VALUE_INVALID; // invalid value for a valid argument + { + P11DESSecretKeyObj *key = new P11DESSecretKeyObj(); + *p11object = key; + key->setKeyType(keyType); + } + else if (keyType == CKK_GOST28147) + { + *p11object = new P11GOSTSecretKeyObj(); + } + else + return CKR_ATTRIBUTE_VALUE_INVALID; + break; + case CKO_DOMAIN_PARAMETERS: + if (keyType == CKK_DSA) + *p11object = new P11DSADomainObj(); + else if (keyType == CKK_DH) + *p11object = new P11DHDomainObj(); + else + return CKR_ATTRIBUTE_VALUE_INVALID; + break; + default: + return CKR_ATTRIBUTE_VALUE_INVALID; // invalid value for a valid argument } return CKR_OK; } static CK_RV extractObjectInformation(CK_ATTRIBUTE_PTR pTemplate, - CK_ULONG ulCount, - CK_OBJECT_CLASS &objClass, - CK_KEY_TYPE &keyType, - CK_CERTIFICATE_TYPE &certType, - CK_BBOOL &isOnToken, - CK_BBOOL &isPrivate, - bool bImplicit) + CK_ULONG ulCount, + CK_OBJECT_CLASS &objClass, + CK_KEY_TYPE &keyType, + CK_CERTIFICATE_TYPE &certType, + CK_BBOOL &isOnToken, + CK_BBOOL &isPrivate, + bool bImplicit) { bool bHasClass = false; bool bHasKeyType = false; @@ -225,42 +226,42 @@ static CK_RV extractObjectInformation(CK_ATTRIBUTE_PTR pTemplate, { switch (pTemplate[i].type) { - case CKA_CLASS: - if (pTemplate[i].ulValueLen == sizeof(CK_OBJECT_CLASS)) - { - objClass = *(CK_OBJECT_CLASS_PTR)pTemplate[i].pValue; - bHasClass = true; - } - break; - case CKA_KEY_TYPE: - if (pTemplate[i].ulValueLen == sizeof(CK_KEY_TYPE)) - { - keyType = *(CK_KEY_TYPE*)pTemplate[i].pValue; - bHasKeyType = true; - } - break; - case CKA_CERTIFICATE_TYPE: - if (pTemplate[i].ulValueLen == sizeof(CK_CERTIFICATE_TYPE)) - { - certType = *(CK_CERTIFICATE_TYPE*)pTemplate[i].pValue; - bHasCertType = true; - } - break; - case CKA_TOKEN: - if (pTemplate[i].ulValueLen == sizeof(CK_BBOOL)) - { - isOnToken = *(CK_BBOOL*)pTemplate[i].pValue; - } - break; - case CKA_PRIVATE: - if (pTemplate[i].ulValueLen == sizeof(CK_BBOOL)) - { - isPrivate = *(CK_BBOOL*)pTemplate[i].pValue; - bHasPrivate = true; - } - break; - default: - break; + case CKA_CLASS: + if (pTemplate[i].ulValueLen == sizeof(CK_OBJECT_CLASS)) + { + objClass = *(CK_OBJECT_CLASS_PTR)pTemplate[i].pValue; + bHasClass = true; + } + break; + case CKA_KEY_TYPE: + if (pTemplate[i].ulValueLen == sizeof(CK_KEY_TYPE)) + { + keyType = *(CK_KEY_TYPE *)pTemplate[i].pValue; + bHasKeyType = true; + } + break; + case CKA_CERTIFICATE_TYPE: + if (pTemplate[i].ulValueLen == sizeof(CK_CERTIFICATE_TYPE)) + { + certType = *(CK_CERTIFICATE_TYPE *)pTemplate[i].pValue; + bHasCertType = true; + } + break; + case CKA_TOKEN: + if (pTemplate[i].ulValueLen == sizeof(CK_BBOOL)) + { + isOnToken = *(CK_BBOOL *)pTemplate[i].pValue; + } + break; + case CKA_PRIVATE: + if (pTemplate[i].ulValueLen == sizeof(CK_BBOOL)) + { + isPrivate = *(CK_BBOOL *)pTemplate[i].pValue; + bHasPrivate = true; + } + break; + default: + break; } } @@ -277,7 +278,7 @@ static CK_RV extractObjectInformation(CK_ATTRIBUTE_PTR pTemplate, bool bKeyTypeRequired = (objClass == CKO_PUBLIC_KEY || objClass == CKO_PRIVATE_KEY || objClass == CKO_SECRET_KEY); if (bKeyTypeRequired && !bHasKeyType) { - return CKR_TEMPLATE_INCOMPLETE; + return CKR_TEMPLATE_INCOMPLETE; } if (objClass == CKO_CERTIFICATE) @@ -304,38 +305,42 @@ static CK_RV extractObjectInformation(CK_ATTRIBUTE_PTR pTemplate, static CK_RV checkKeyLength(CK_KEY_TYPE keyType, size_t byteLen) { - switch (keyType) { - case CKK_GENERIC_SECRET: - break; + switch (keyType) + { + case CKK_GENERIC_SECRET: + break; #ifndef WITH_FIPS - case CKK_DES: - if (byteLen != 8) { - INFO_MSG("CKA_VALUE_LEN must be 8"); - return CKR_TEMPLATE_INCOMPLETE; - } - break; + case CKK_DES: + if (byteLen != 8) + { + INFO_MSG("CKA_VALUE_LEN must be 8"); + return CKR_TEMPLATE_INCOMPLETE; + } + break; #endif - case CKK_DES2: - if (byteLen != 16) { - INFO_MSG("CKA_VALUE_LEN must be 16"); - return CKR_TEMPLATE_INCOMPLETE; - } - break; - case CKK_DES3: - if (byteLen != 24) { - INFO_MSG("CKA_VALUE_LEN must be 24"); - return CKR_TEMPLATE_INCOMPLETE; - } - break; - case CKK_AES: - if (byteLen != 16 && byteLen != 24 && byteLen != 32) - { - INFO_MSG("CKA_VALUE_LEN must be 16, 24, or 32"); - return CKR_ATTRIBUTE_VALUE_INVALID; - } - break; - default: + case CKK_DES2: + if (byteLen != 16) + { + INFO_MSG("CKA_VALUE_LEN must be 16"); + return CKR_TEMPLATE_INCOMPLETE; + } + break; + case CKK_DES3: + if (byteLen != 24) + { + INFO_MSG("CKA_VALUE_LEN must be 24"); + return CKR_TEMPLATE_INCOMPLETE; + } + break; + case CKK_AES: + if (byteLen != 16 && byteLen != 24 && byteLen != 32) + { + INFO_MSG("CKA_VALUE_LEN must be 16, 24, or 32"); return CKR_ATTRIBUTE_VALUE_INVALID; + } + break; + default: + return CKR_ATTRIBUTE_VALUE_INVALID; } return CKR_OK; } @@ -349,7 +354,7 @@ static CK_RV newP11Object(OSObject *object, P11Object **p11object) keyType = object->getUnsignedLongValue(CKA_KEY_TYPE, CKK_RSA); if (object->attributeExists(CKA_CERTIFICATE_TYPE)) certType = object->getUnsignedLongValue(CKA_CERTIFICATE_TYPE, CKC_X_509); - CK_RV rv = newP11Object(objClass,keyType,certType,p11object); + CK_RV rv = newP11Object(objClass, keyType, certType, p11object); if (rv != CKR_OK) return rv; if (!(*p11object)->init(object)) @@ -360,7 +365,7 @@ static CK_RV newP11Object(OSObject *object, P11Object **p11object) #ifdef notyet static CK_ATTRIBUTE bsAttribute(CK_ATTRIBUTE_TYPE type, const ByteString &value) { - CK_ATTRIBUTE attr = {type, (CK_VOID_PTR)value.const_byte_str(), value.size() }; + CK_ATTRIBUTE attr = {type, (CK_VOID_PTR)value.const_byte_str(), value.size()}; return attr; } #endif @@ -377,15 +382,14 @@ static void resetMutexFactoryCallbacks() MutexFactory::i()->setUnlockMutex(OSUnlockMutex); } - // Return the one-and-only instance -SoftHSM* SoftHSM::i() +SoftHSM *SoftHSM::i() { if (!instance.get()) { instance.reset(new SoftHSM()); } - else if(instance->detectFork()) + else if (instance->detectFork()) { if (Configuration::i()->getBool("library.reset_on_fork", false)) { @@ -429,15 +433,20 @@ SoftHSM::SoftHSM() // Destructor SoftHSM::~SoftHSM() { - if (handleManager != NULL) delete handleManager; + if (handleManager != NULL) + delete handleManager; handleManager = NULL; - if (sessionManager != NULL) delete sessionManager; + if (sessionManager != NULL) + delete sessionManager; sessionManager = NULL; - if (slotManager != NULL) delete slotManager; + if (slotManager != NULL) + delete slotManager; slotManager = NULL; - if (objectStore != NULL) delete objectStore; + if (objectStore != NULL) + delete objectStore; objectStore = NULL; - if (sessionObjectStore != NULL) delete sessionObjectStore; + if (sessionObjectStore != NULL) + delete sessionObjectStore; sessionObjectStore = NULL; mechanisms_table.clear(); @@ -484,13 +493,11 @@ CK_RV SoftHSM::C_Initialize(CK_VOID_PTR pInitArgs) // } // Are we not supplied with mutex functions? - if - ( + if ( args->CreateMutex == NULL_PTR && args->DestroyMutex == NULL_PTR && args->LockMutex == NULL_PTR && - args->UnlockMutex == NULL_PTR - ) + args->UnlockMutex == NULL_PTR) { // Can we use our own mutex functions? if (args->flags & CKF_OS_LOCKING_OK) @@ -508,13 +515,11 @@ CK_RV SoftHSM::C_Initialize(CK_VOID_PTR pInitArgs) else { // We must have all mutex functions - if - ( + if ( args->CreateMutex == NULL_PTR || args->DestroyMutex == NULL_PTR || args->LockMutex == NULL_PTR || - args->UnlockMutex == NULL_PTR - ) + args->UnlockMutex == NULL_PTR) { ERROR_MSG("Not all mutex functions are supplied"); return CKR_ARGUMENTS_BAD; @@ -585,7 +590,7 @@ CK_RV SoftHSM::C_Initialize(CK_VOID_PTR pInitArgs) // Load the object store objectStore = new ObjectStore(Configuration::i()->getString("directories.tokendir", DEFAULT_TOKENDIR), - Configuration::i()->getInt("objectstore.umask", DEFAULT_UMASK)); + Configuration::i()->getInt("objectstore.umask", DEFAULT_UMASK)); if (!objectStore->isValid()) { WARNING_MSG("Could not load the object store"); @@ -619,20 +624,27 @@ CK_RV SoftHSM::C_Initialize(CK_VOID_PTR pInitArgs) // PKCS #11 finalisation function CK_RV SoftHSM::C_Finalize(CK_VOID_PTR pReserved) { - if (!isInitialised) return CKR_CRYPTOKI_NOT_INITIALIZED; + if (!isInitialised) + return CKR_CRYPTOKI_NOT_INITIALIZED; // Must be set to NULL_PTR in this version of PKCS#11 - if (pReserved != NULL_PTR) return CKR_ARGUMENTS_BAD; + if (pReserved != NULL_PTR) + return CKR_ARGUMENTS_BAD; - if (handleManager != NULL) delete handleManager; + if (handleManager != NULL) + delete handleManager; handleManager = NULL; - if (sessionManager != NULL) delete sessionManager; + if (sessionManager != NULL) + delete sessionManager; sessionManager = NULL; - if (slotManager != NULL) delete slotManager; + if (slotManager != NULL) + delete slotManager; slotManager = NULL; - if (objectStore != NULL) delete objectStore; + if (objectStore != NULL) + delete objectStore; objectStore = NULL; - if (sessionObjectStore != NULL) delete sessionObjectStore; + if (sessionObjectStore != NULL) + delete sessionObjectStore; sessionObjectStore = NULL; CryptoFactory::reset(); SecureMemoryRegistry::reset(); @@ -648,8 +660,10 @@ CK_RV SoftHSM::C_Finalize(CK_VOID_PTR pReserved) // Return information about the PKCS #11 module CK_RV SoftHSM::C_GetInfo(CK_INFO_PTR pInfo) { - if (!isInitialised) return CKR_CRYPTOKI_NOT_INITIALIZED; - if (pInfo == NULL_PTR) return CKR_ARGUMENTS_BAD; + if (!isInitialised) + return CKR_CRYPTOKI_NOT_INITIALIZED; + if (pInfo == NULL_PTR) + return CKR_ARGUMENTS_BAD; pInfo->cryptokiVersion.major = CRYPTOKI_VERSION_MAJOR; pInfo->cryptokiVersion.minor = CRYPTOKI_VERSION_MINOR; @@ -671,7 +685,8 @@ CK_RV SoftHSM::C_GetInfo(CK_INFO_PTR pInfo) // Return a list of available slots CK_RV SoftHSM::C_GetSlotList(CK_BBOOL tokenPresent, CK_SLOT_ID_PTR pSlotList, CK_ULONG_PTR pulCount) { - if (!isInitialised) return CKR_CRYPTOKI_NOT_INITIALIZED; + if (!isInitialised) + return CKR_CRYPTOKI_NOT_INITIALIZED; return slotManager->getSlotList(objectStore, tokenPresent, pSlotList, pulCount); } @@ -680,20 +695,23 @@ CK_RV SoftHSM::C_GetSlotList(CK_BBOOL tokenPresent, CK_SLOT_ID_PTR pSlotList, CK CK_RV SoftHSM::C_GetSlotInfo(CK_SLOT_ID slotID, CK_SLOT_INFO_PTR pInfo) { CK_RV rv; - if (!isInitialised) return CKR_CRYPTOKI_NOT_INITIALIZED; + if (!isInitialised) + return CKR_CRYPTOKI_NOT_INITIALIZED; - Slot* slot = slotManager->getSlot(slotID); + Slot *slot = slotManager->getSlot(slotID); if (slot == NULL) { return CKR_SLOT_ID_INVALID; } rv = slot->getSlotInfo(pInfo); - if (rv != CKR_OK) { + if (rv != CKR_OK) + { return rv; } - if (isRemovable) { + if (isRemovable) + { pInfo->flags |= CKF_REMOVABLE_DEVICE; } @@ -703,15 +721,16 @@ CK_RV SoftHSM::C_GetSlotInfo(CK_SLOT_ID slotID, CK_SLOT_INFO_PTR pInfo) // Return information about a token in a slot CK_RV SoftHSM::C_GetTokenInfo(CK_SLOT_ID slotID, CK_TOKEN_INFO_PTR pInfo) { - if (!isInitialised) return CKR_CRYPTOKI_NOT_INITIALIZED; + if (!isInitialised) + return CKR_CRYPTOKI_NOT_INITIALIZED; - Slot* slot = slotManager->getSlot(slotID); + Slot *slot = slotManager->getSlot(slotID); if (slot == NULL) { return CKR_SLOT_ID_INVALID; } - Token* token = slot->getToken(); + Token *token = slot->getToken(); if (token == NULL) { return CKR_TOKEN_NOT_PRESENT; @@ -723,107 +742,107 @@ CK_RV SoftHSM::C_GetTokenInfo(CK_SLOT_ID slotID, CK_TOKEN_INFO_PTR pInfo) void SoftHSM::prepareSupportedMechanisms(std::map &t) { #ifndef WITH_FIPS - t["CKM_MD5"] = CKM_MD5; + t["CKM_MD5"] = CKM_MD5; #endif - t["CKM_SHA_1"] = CKM_SHA_1; - t["CKM_SHA224"] = CKM_SHA224; - t["CKM_SHA256"] = CKM_SHA256; - t["CKM_SHA384"] = CKM_SHA384; - t["CKM_SHA512"] = CKM_SHA512; + t["CKM_SHA_1"] = CKM_SHA_1; + t["CKM_SHA224"] = CKM_SHA224; + t["CKM_SHA256"] = CKM_SHA256; + t["CKM_SHA384"] = CKM_SHA384; + t["CKM_SHA512"] = CKM_SHA512; #ifndef WITH_FIPS - t["CKM_MD5_HMAC"] = CKM_MD5_HMAC; + t["CKM_MD5_HMAC"] = CKM_MD5_HMAC; #endif - t["CKM_SHA_1_HMAC"] = CKM_SHA_1_HMAC; - t["CKM_SHA224_HMAC"] = CKM_SHA224_HMAC; - t["CKM_SHA256_HMAC"] = CKM_SHA256_HMAC; - t["CKM_SHA384_HMAC"] = CKM_SHA384_HMAC; - t["CKM_SHA512_HMAC"] = CKM_SHA512_HMAC; - t["CKM_RSA_PKCS_KEY_PAIR_GEN"] = CKM_RSA_PKCS_KEY_PAIR_GEN; - t["CKM_RSA_PKCS"] = CKM_RSA_PKCS; - t["CKM_RSA_X_509"] = CKM_RSA_X_509; + t["CKM_SHA_1_HMAC"] = CKM_SHA_1_HMAC; + t["CKM_SHA224_HMAC"] = CKM_SHA224_HMAC; + t["CKM_SHA256_HMAC"] = CKM_SHA256_HMAC; + t["CKM_SHA384_HMAC"] = CKM_SHA384_HMAC; + t["CKM_SHA512_HMAC"] = CKM_SHA512_HMAC; + t["CKM_RSA_PKCS_KEY_PAIR_GEN"] = CKM_RSA_PKCS_KEY_PAIR_GEN; + t["CKM_RSA_PKCS"] = CKM_RSA_PKCS; + t["CKM_RSA_X_509"] = CKM_RSA_X_509; #ifndef WITH_FIPS - t["CKM_MD5_RSA_PKCS"] = CKM_MD5_RSA_PKCS; + t["CKM_MD5_RSA_PKCS"] = CKM_MD5_RSA_PKCS; #endif - t["CKM_SHA1_RSA_PKCS"] = CKM_SHA1_RSA_PKCS; - t["CKM_RSA_PKCS_OAEP"] = CKM_RSA_PKCS_OAEP; - t["CKM_RSA_AES_KEY_WRAP"] = CKM_RSA_AES_KEY_WRAP; - t["CKM_SHA224_RSA_PKCS"] = CKM_SHA224_RSA_PKCS; - t["CKM_SHA256_RSA_PKCS"] = CKM_SHA256_RSA_PKCS; - t["CKM_SHA384_RSA_PKCS"] = CKM_SHA384_RSA_PKCS; - t["CKM_SHA512_RSA_PKCS"] = CKM_SHA512_RSA_PKCS; + t["CKM_SHA1_RSA_PKCS"] = CKM_SHA1_RSA_PKCS; + t["CKM_RSA_PKCS_OAEP"] = CKM_RSA_PKCS_OAEP; + t["CKM_RSA_AES_KEY_WRAP"] = CKM_RSA_AES_KEY_WRAP; + t["CKM_SHA224_RSA_PKCS"] = CKM_SHA224_RSA_PKCS; + t["CKM_SHA256_RSA_PKCS"] = CKM_SHA256_RSA_PKCS; + t["CKM_SHA384_RSA_PKCS"] = CKM_SHA384_RSA_PKCS; + t["CKM_SHA512_RSA_PKCS"] = CKM_SHA512_RSA_PKCS; #ifdef WITH_RAW_PSS - t["CKM_RSA_PKCS_PSS"] = CKM_RSA_PKCS_PSS; + t["CKM_RSA_PKCS_PSS"] = CKM_RSA_PKCS_PSS; #endif - t["CKM_SHA1_RSA_PKCS_PSS"] = CKM_SHA1_RSA_PKCS_PSS; - t["CKM_SHA224_RSA_PKCS_PSS"] = CKM_SHA224_RSA_PKCS_PSS; - t["CKM_SHA256_RSA_PKCS_PSS"] = CKM_SHA256_RSA_PKCS_PSS; - t["CKM_SHA384_RSA_PKCS_PSS"] = CKM_SHA384_RSA_PKCS_PSS; - t["CKM_SHA512_RSA_PKCS_PSS"] = CKM_SHA512_RSA_PKCS_PSS; - t["CKM_GENERIC_SECRET_KEY_GEN"] = CKM_GENERIC_SECRET_KEY_GEN; + t["CKM_SHA1_RSA_PKCS_PSS"] = CKM_SHA1_RSA_PKCS_PSS; + t["CKM_SHA224_RSA_PKCS_PSS"] = CKM_SHA224_RSA_PKCS_PSS; + t["CKM_SHA256_RSA_PKCS_PSS"] = CKM_SHA256_RSA_PKCS_PSS; + t["CKM_SHA384_RSA_PKCS_PSS"] = CKM_SHA384_RSA_PKCS_PSS; + t["CKM_SHA512_RSA_PKCS_PSS"] = CKM_SHA512_RSA_PKCS_PSS; + t["CKM_GENERIC_SECRET_KEY_GEN"] = CKM_GENERIC_SECRET_KEY_GEN; #ifndef WITH_FIPS - t["CKM_DES_KEY_GEN"] = CKM_DES_KEY_GEN; + t["CKM_DES_KEY_GEN"] = CKM_DES_KEY_GEN; #endif - t["CKM_DES2_KEY_GEN"] = CKM_DES2_KEY_GEN; - t["CKM_DES3_KEY_GEN"] = CKM_DES3_KEY_GEN; + t["CKM_DES2_KEY_GEN"] = CKM_DES2_KEY_GEN; + t["CKM_DES3_KEY_GEN"] = CKM_DES3_KEY_GEN; #ifndef WITH_FIPS - t["CKM_DES_ECB"] = CKM_DES_ECB; - t["CKM_DES_CBC"] = CKM_DES_CBC; - t["CKM_DES_CBC_PAD"] = CKM_DES_CBC_PAD; - t["CKM_DES_ECB_ENCRYPT_DATA"] = CKM_DES_ECB_ENCRYPT_DATA; - t["CKM_DES_CBC_ENCRYPT_DATA"] = CKM_DES_CBC_ENCRYPT_DATA; + t["CKM_DES_ECB"] = CKM_DES_ECB; + t["CKM_DES_CBC"] = CKM_DES_CBC; + t["CKM_DES_CBC_PAD"] = CKM_DES_CBC_PAD; + t["CKM_DES_ECB_ENCRYPT_DATA"] = CKM_DES_ECB_ENCRYPT_DATA; + t["CKM_DES_CBC_ENCRYPT_DATA"] = CKM_DES_CBC_ENCRYPT_DATA; #endif - t["CKM_DES3_ECB"] = CKM_DES3_ECB; - t["CKM_DES3_CBC"] = CKM_DES3_CBC; - t["CKM_DES3_CBC_PAD"] = CKM_DES3_CBC_PAD; - t["CKM_DES3_ECB_ENCRYPT_DATA"] = CKM_DES3_ECB_ENCRYPT_DATA; - t["CKM_DES3_CBC_ENCRYPT_DATA"] = CKM_DES3_CBC_ENCRYPT_DATA; - t["CKM_DES3_CMAC"] = CKM_DES3_CMAC; - t["CKM_AES_KEY_GEN"] = CKM_AES_KEY_GEN; - t["CKM_AES_ECB"] = CKM_AES_ECB; - t["CKM_AES_CBC"] = CKM_AES_CBC; - t["CKM_AES_CBC_PAD"] = CKM_AES_CBC_PAD; - t["CKM_AES_CTR"] = CKM_AES_CTR; - t["CKM_AES_GCM"] = CKM_AES_GCM; - t["CKM_AES_KEY_WRAP"] = CKM_AES_KEY_WRAP; + t["CKM_DES3_ECB"] = CKM_DES3_ECB; + t["CKM_DES3_CBC"] = CKM_DES3_CBC; + t["CKM_DES3_CBC_PAD"] = CKM_DES3_CBC_PAD; + t["CKM_DES3_ECB_ENCRYPT_DATA"] = CKM_DES3_ECB_ENCRYPT_DATA; + t["CKM_DES3_CBC_ENCRYPT_DATA"] = CKM_DES3_CBC_ENCRYPT_DATA; + t["CKM_DES3_CMAC"] = CKM_DES3_CMAC; + t["CKM_AES_KEY_GEN"] = CKM_AES_KEY_GEN; + t["CKM_AES_ECB"] = CKM_AES_ECB; + t["CKM_AES_CBC"] = CKM_AES_CBC; + t["CKM_AES_CBC_PAD"] = CKM_AES_CBC_PAD; + t["CKM_AES_CTR"] = CKM_AES_CTR; + t["CKM_AES_GCM"] = CKM_AES_GCM; + t["CKM_AES_KEY_WRAP"] = CKM_AES_KEY_WRAP; #ifdef HAVE_AES_KEY_WRAP_PAD - t["CKM_AES_KEY_WRAP_PAD"] = CKM_AES_KEY_WRAP_PAD; + t["CKM_AES_KEY_WRAP_PAD"] = CKM_AES_KEY_WRAP_PAD; #endif - t["CKM_AES_ECB_ENCRYPT_DATA"] = CKM_AES_ECB_ENCRYPT_DATA; - t["CKM_AES_CBC_ENCRYPT_DATA"] = CKM_AES_CBC_ENCRYPT_DATA; - t["CKM_AES_CMAC"] = CKM_AES_CMAC; - t["CKM_DSA_PARAMETER_GEN"] = CKM_DSA_PARAMETER_GEN; - t["CKM_DSA_KEY_PAIR_GEN"] = CKM_DSA_KEY_PAIR_GEN; - t["CKM_DSA"] = CKM_DSA; - t["CKM_DSA_SHA1"] = CKM_DSA_SHA1; - t["CKM_DSA_SHA224"] = CKM_DSA_SHA224; - t["CKM_DSA_SHA256"] = CKM_DSA_SHA256; - t["CKM_DSA_SHA384"] = CKM_DSA_SHA384; - t["CKM_DSA_SHA512"] = CKM_DSA_SHA512; - t["CKM_DH_PKCS_KEY_PAIR_GEN"] = CKM_DH_PKCS_KEY_PAIR_GEN; - t["CKM_DH_PKCS_PARAMETER_GEN"] = CKM_DH_PKCS_PARAMETER_GEN; - t["CKM_DH_PKCS_DERIVE"] = CKM_DH_PKCS_DERIVE; + t["CKM_AES_ECB_ENCRYPT_DATA"] = CKM_AES_ECB_ENCRYPT_DATA; + t["CKM_AES_CBC_ENCRYPT_DATA"] = CKM_AES_CBC_ENCRYPT_DATA; + t["CKM_AES_CMAC"] = CKM_AES_CMAC; + t["CKM_DSA_PARAMETER_GEN"] = CKM_DSA_PARAMETER_GEN; + t["CKM_DSA_KEY_PAIR_GEN"] = CKM_DSA_KEY_PAIR_GEN; + t["CKM_DSA"] = CKM_DSA; + t["CKM_DSA_SHA1"] = CKM_DSA_SHA1; + t["CKM_DSA_SHA224"] = CKM_DSA_SHA224; + t["CKM_DSA_SHA256"] = CKM_DSA_SHA256; + t["CKM_DSA_SHA384"] = CKM_DSA_SHA384; + t["CKM_DSA_SHA512"] = CKM_DSA_SHA512; + t["CKM_DH_PKCS_KEY_PAIR_GEN"] = CKM_DH_PKCS_KEY_PAIR_GEN; + t["CKM_DH_PKCS_PARAMETER_GEN"] = CKM_DH_PKCS_PARAMETER_GEN; + t["CKM_DH_PKCS_DERIVE"] = CKM_DH_PKCS_DERIVE; #ifdef WITH_ECC - t["CKM_EC_KEY_PAIR_GEN"] = CKM_EC_KEY_PAIR_GEN; - t["CKM_ECDSA"] = CKM_ECDSA; - t["CKM_ECDSA_SHA1"] = CKM_ECDSA_SHA1; - t["CKM_ECDSA_SHA224"] = CKM_ECDSA_SHA224; - t["CKM_ECDSA_SHA256"] = CKM_ECDSA_SHA256; - t["CKM_ECDSA_SHA384"] = CKM_ECDSA_SHA384; - t["CKM_ECDSA_SHA512"] = CKM_ECDSA_SHA512; + t["CKM_EC_KEY_PAIR_GEN"] = CKM_EC_KEY_PAIR_GEN; + t["CKM_ECDSA"] = CKM_ECDSA; + t["CKM_ECDSA_SHA1"] = CKM_ECDSA_SHA1; + t["CKM_ECDSA_SHA224"] = CKM_ECDSA_SHA224; + t["CKM_ECDSA_SHA256"] = CKM_ECDSA_SHA256; + t["CKM_ECDSA_SHA384"] = CKM_ECDSA_SHA384; + t["CKM_ECDSA_SHA512"] = CKM_ECDSA_SHA512; #endif #if defined(WITH_ECC) || defined(WITH_EDDSA) - t["CKM_ECDH1_DERIVE"] = CKM_ECDH1_DERIVE; + t["CKM_ECDH1_DERIVE"] = CKM_ECDH1_DERIVE; #endif #ifdef WITH_GOST - t["CKM_GOSTR3411"] = CKM_GOSTR3411; - t["CKM_GOSTR3411_HMAC"] = CKM_GOSTR3411_HMAC; - t["CKM_GOSTR3410_KEY_PAIR_GEN"] = CKM_GOSTR3410_KEY_PAIR_GEN; - t["CKM_GOSTR3410"] = CKM_GOSTR3410; + t["CKM_GOSTR3411"] = CKM_GOSTR3411; + t["CKM_GOSTR3411_HMAC"] = CKM_GOSTR3411_HMAC; + t["CKM_GOSTR3410_KEY_PAIR_GEN"] = CKM_GOSTR3410_KEY_PAIR_GEN; + t["CKM_GOSTR3410"] = CKM_GOSTR3410; t["CKM_GOSTR3410_WITH_GOSTR3411"] = CKM_GOSTR3410_WITH_GOSTR3411; #endif #ifdef WITH_EDDSA t["CKM_EC_EDWARDS_KEY_PAIR_GEN"] = CKM_EC_EDWARDS_KEY_PAIR_GEN; - t["CKM_EDDSA"] = CKM_EDDSA; + t["CKM_EDDSA"] = CKM_EDDSA; #endif t["CKM_CONCATENATE_DATA_AND_BASE"] = CKM_CONCATENATE_DATA_AND_BASE; t["CKM_CONCATENATE_BASE_AND_DATA"] = CKM_CONCATENATE_BASE_AND_DATA; @@ -855,7 +874,8 @@ void SoftHSM::prepareSupportedMechanisms(std::mapgetSlot(slotID); + Slot *slot = slotManager->getSlot(slotID); if (slot == NULL) { return CKR_SLOT_ID_INVALID; @@ -930,10 +951,12 @@ CK_RV SoftHSM::C_GetMechanismInfo(CK_SLOT_ID slotID, CK_MECHANISM_TYPE type, CK_ unsigned long eddsaMinSize = 0, eddsaMaxSize = 0; #endif - if (!isInitialised) return CKR_CRYPTOKI_NOT_INITIALIZED; - if (pInfo == NULL_PTR) return CKR_ARGUMENTS_BAD; + if (!isInitialised) + return CKR_CRYPTOKI_NOT_INITIALIZED; + if (pInfo == NULL_PTR) + return CKR_ARGUMENTS_BAD; - Slot* slot = slotManager->getSlot(slotID); + Slot *slot = slotManager->getSlot(slotID); if (slot == NULL) { return CKR_SLOT_ID_INVALID; @@ -941,7 +964,7 @@ CK_RV SoftHSM::C_GetMechanismInfo(CK_SLOT_ID slotID, CK_MECHANISM_TYPE type, CK_ if (!isMechanismPermitted(NULL, type)) return CKR_MECHANISM_INVALID; - AsymmetricAlgorithm* rsa = CryptoFactory::i()->getAsymmetricAlgorithm(AsymAlgo::RSA); + AsymmetricAlgorithm *rsa = CryptoFactory::i()->getAsymmetricAlgorithm(AsymAlgo::RSA); if (rsa != NULL) { rsaMinSize = rsa->getMinKeySize(); @@ -953,7 +976,7 @@ CK_RV SoftHSM::C_GetMechanismInfo(CK_SLOT_ID slotID, CK_MECHANISM_TYPE type, CK_ } CryptoFactory::i()->recycleAsymmetricAlgorithm(rsa); - AsymmetricAlgorithm* dsa = CryptoFactory::i()->getAsymmetricAlgorithm(AsymAlgo::DSA); + AsymmetricAlgorithm *dsa = CryptoFactory::i()->getAsymmetricAlgorithm(AsymAlgo::DSA); if (dsa != NULL) { dsaMinSize = dsa->getMinKeySize(); @@ -976,7 +999,7 @@ CK_RV SoftHSM::C_GetMechanismInfo(CK_SLOT_ID slotID, CK_MECHANISM_TYPE type, CK_ } CryptoFactory::i()->recycleAsymmetricAlgorithm(dsa); - AsymmetricAlgorithm* dh = CryptoFactory::i()->getAsymmetricAlgorithm(AsymAlgo::DH); + AsymmetricAlgorithm *dh = CryptoFactory::i()->getAsymmetricAlgorithm(AsymAlgo::DH); if (dh != NULL) { dhMinSize = dh->getMinKeySize(); @@ -989,7 +1012,7 @@ CK_RV SoftHSM::C_GetMechanismInfo(CK_SLOT_ID slotID, CK_MECHANISM_TYPE type, CK_ CryptoFactory::i()->recycleAsymmetricAlgorithm(dh); #ifdef WITH_ECC - AsymmetricAlgorithm* ecdsa = CryptoFactory::i()->getAsymmetricAlgorithm(AsymAlgo::ECDSA); + AsymmetricAlgorithm *ecdsa = CryptoFactory::i()->getAsymmetricAlgorithm(AsymAlgo::ECDSA); if (ecdsa != NULL) { ecdsaMinSize = ecdsa->getMinKeySize(); @@ -1001,7 +1024,7 @@ CK_RV SoftHSM::C_GetMechanismInfo(CK_SLOT_ID slotID, CK_MECHANISM_TYPE type, CK_ } CryptoFactory::i()->recycleAsymmetricAlgorithm(ecdsa); - AsymmetricAlgorithm* ecdh = CryptoFactory::i()->getAsymmetricAlgorithm(AsymAlgo::ECDH); + AsymmetricAlgorithm *ecdh = CryptoFactory::i()->getAsymmetricAlgorithm(AsymAlgo::ECDH); if (ecdh != NULL) { ecdhMinSize = ecdh->getMinKeySize(); @@ -1015,7 +1038,7 @@ CK_RV SoftHSM::C_GetMechanismInfo(CK_SLOT_ID slotID, CK_MECHANISM_TYPE type, CK_ #endif #ifdef WITH_EDDSA - AsymmetricAlgorithm* eddsa = CryptoFactory::i()->getAsymmetricAlgorithm(AsymAlgo::EDDSA); + AsymmetricAlgorithm *eddsa = CryptoFactory::i()->getAsymmetricAlgorithm(AsymAlgo::EDDSA); if (eddsa != NULL) { eddsaMinSize = eddsa->getMinKeySize(); @@ -1027,307 +1050,307 @@ CK_RV SoftHSM::C_GetMechanismInfo(CK_SLOT_ID slotID, CK_MECHANISM_TYPE type, CK_ } CryptoFactory::i()->recycleAsymmetricAlgorithm(eddsa); #endif - pInfo->flags = 0; // initialize flags + pInfo->flags = 0; // initialize flags switch (type) { #ifndef WITH_FIPS - case CKM_MD5: + case CKM_MD5: #endif - case CKM_SHA_1: - case CKM_SHA224: - case CKM_SHA256: - case CKM_SHA384: - case CKM_SHA512: - // Key size is not in use - pInfo->ulMinKeySize = 0; - pInfo->ulMaxKeySize = 0; - pInfo->flags = CKF_DIGEST; - break; + case CKM_SHA_1: + case CKM_SHA224: + case CKM_SHA256: + case CKM_SHA384: + case CKM_SHA512: + // Key size is not in use + pInfo->ulMinKeySize = 0; + pInfo->ulMaxKeySize = 0; + pInfo->flags = CKF_DIGEST; + break; #ifndef WITH_FIPS - case CKM_MD5_HMAC: - pInfo->ulMinKeySize = 16; - pInfo->ulMaxKeySize = 512; - pInfo->flags = CKF_SIGN | CKF_VERIFY; - break; + case CKM_MD5_HMAC: + pInfo->ulMinKeySize = 16; + pInfo->ulMaxKeySize = 512; + pInfo->flags = CKF_SIGN | CKF_VERIFY; + break; #endif - case CKM_SHA_1_HMAC: - pInfo->ulMinKeySize = 20; - pInfo->ulMaxKeySize = 512; - pInfo->flags = CKF_SIGN | CKF_VERIFY; - break; - case CKM_SHA224_HMAC: - pInfo->ulMinKeySize = 28; - pInfo->ulMaxKeySize = 512; - pInfo->flags = CKF_SIGN | CKF_VERIFY; - break; - case CKM_SHA256_HMAC: - pInfo->ulMinKeySize = 32; - pInfo->ulMaxKeySize = 512; - pInfo->flags = CKF_SIGN | CKF_VERIFY; - break; - case CKM_SHA384_HMAC: - pInfo->ulMinKeySize = 48; - pInfo->ulMaxKeySize = 512; - pInfo->flags = CKF_SIGN | CKF_VERIFY; - break; - case CKM_SHA512_HMAC: - pInfo->ulMinKeySize = 64; - pInfo->ulMaxKeySize = 512; - pInfo->flags = CKF_SIGN | CKF_VERIFY; - break; - case CKM_RSA_PKCS_KEY_PAIR_GEN: - pInfo->ulMinKeySize = rsaMinSize; - pInfo->ulMaxKeySize = rsaMaxSize; - pInfo->flags = CKF_GENERATE_KEY_PAIR; - break; - case CKM_RSA_PKCS: - pInfo->ulMinKeySize = rsaMinSize; - pInfo->ulMaxKeySize = rsaMaxSize; - pInfo->flags = CKF_SIGN | CKF_VERIFY | CKF_ENCRYPT | CKF_DECRYPT | CKF_WRAP | CKF_UNWRAP; - break; - case CKM_RSA_X_509: - pInfo->ulMinKeySize = rsaMinSize; - pInfo->ulMaxKeySize = rsaMaxSize; - pInfo->flags = CKF_SIGN | CKF_VERIFY | CKF_ENCRYPT | CKF_DECRYPT; - break; + case CKM_SHA_1_HMAC: + pInfo->ulMinKeySize = 20; + pInfo->ulMaxKeySize = 512; + pInfo->flags = CKF_SIGN | CKF_VERIFY; + break; + case CKM_SHA224_HMAC: + pInfo->ulMinKeySize = 28; + pInfo->ulMaxKeySize = 512; + pInfo->flags = CKF_SIGN | CKF_VERIFY; + break; + case CKM_SHA256_HMAC: + pInfo->ulMinKeySize = 32; + pInfo->ulMaxKeySize = 512; + pInfo->flags = CKF_SIGN | CKF_VERIFY; + break; + case CKM_SHA384_HMAC: + pInfo->ulMinKeySize = 48; + pInfo->ulMaxKeySize = 512; + pInfo->flags = CKF_SIGN | CKF_VERIFY; + break; + case CKM_SHA512_HMAC: + pInfo->ulMinKeySize = 64; + pInfo->ulMaxKeySize = 512; + pInfo->flags = CKF_SIGN | CKF_VERIFY; + break; + case CKM_RSA_PKCS_KEY_PAIR_GEN: + pInfo->ulMinKeySize = rsaMinSize; + pInfo->ulMaxKeySize = rsaMaxSize; + pInfo->flags = CKF_GENERATE_KEY_PAIR; + break; + case CKM_RSA_PKCS: + pInfo->ulMinKeySize = rsaMinSize; + pInfo->ulMaxKeySize = rsaMaxSize; + pInfo->flags = CKF_SIGN | CKF_VERIFY | CKF_ENCRYPT | CKF_DECRYPT | CKF_WRAP | CKF_UNWRAP; + break; + case CKM_RSA_X_509: + pInfo->ulMinKeySize = rsaMinSize; + pInfo->ulMaxKeySize = rsaMaxSize; + pInfo->flags = CKF_SIGN | CKF_VERIFY | CKF_ENCRYPT | CKF_DECRYPT; + break; #ifndef WITH_FIPS - case CKM_MD5_RSA_PKCS: + case CKM_MD5_RSA_PKCS: #endif - case CKM_SHA1_RSA_PKCS: - case CKM_SHA224_RSA_PKCS: - case CKM_SHA256_RSA_PKCS: - case CKM_SHA384_RSA_PKCS: - case CKM_SHA512_RSA_PKCS: + case CKM_SHA1_RSA_PKCS: + case CKM_SHA224_RSA_PKCS: + case CKM_SHA256_RSA_PKCS: + case CKM_SHA384_RSA_PKCS: + case CKM_SHA512_RSA_PKCS: #ifdef WITH_RAW_PSS - case CKM_RSA_PKCS_PSS: + case CKM_RSA_PKCS_PSS: #endif - case CKM_SHA1_RSA_PKCS_PSS: - case CKM_SHA224_RSA_PKCS_PSS: - case CKM_SHA256_RSA_PKCS_PSS: - case CKM_SHA384_RSA_PKCS_PSS: - case CKM_SHA512_RSA_PKCS_PSS: - pInfo->ulMinKeySize = rsaMinSize; - pInfo->ulMaxKeySize = rsaMaxSize; - pInfo->flags = CKF_SIGN | CKF_VERIFY; - break; - case CKM_RSA_PKCS_OAEP: - pInfo->ulMinKeySize = rsaMinSize; - pInfo->ulMaxKeySize = rsaMaxSize; - pInfo->flags = CKF_ENCRYPT | CKF_DECRYPT | CKF_WRAP | CKF_UNWRAP; - break; - case CKM_GENERIC_SECRET_KEY_GEN: - pInfo->ulMinKeySize = 1; - pInfo->ulMaxKeySize = 0x80000000; - pInfo->flags = CKF_GENERATE; - break; + case CKM_SHA1_RSA_PKCS_PSS: + case CKM_SHA224_RSA_PKCS_PSS: + case CKM_SHA256_RSA_PKCS_PSS: + case CKM_SHA384_RSA_PKCS_PSS: + case CKM_SHA512_RSA_PKCS_PSS: + pInfo->ulMinKeySize = rsaMinSize; + pInfo->ulMaxKeySize = rsaMaxSize; + pInfo->flags = CKF_SIGN | CKF_VERIFY; + break; + case CKM_RSA_PKCS_OAEP: + pInfo->ulMinKeySize = rsaMinSize; + pInfo->ulMaxKeySize = rsaMaxSize; + pInfo->flags = CKF_ENCRYPT | CKF_DECRYPT | CKF_WRAP | CKF_UNWRAP; + break; + case CKM_GENERIC_SECRET_KEY_GEN: + pInfo->ulMinKeySize = 1; + pInfo->ulMaxKeySize = 0x80000000; + pInfo->flags = CKF_GENERATE; + break; #ifndef WITH_FIPS - case CKM_DES_KEY_GEN: + case CKM_DES_KEY_GEN: #endif - case CKM_DES2_KEY_GEN: - case CKM_DES3_KEY_GEN: - // Key size is not in use - pInfo->ulMinKeySize = 0; - pInfo->ulMaxKeySize = 0; - pInfo->flags = CKF_GENERATE; - break; + case CKM_DES2_KEY_GEN: + case CKM_DES3_KEY_GEN: + // Key size is not in use + pInfo->ulMinKeySize = 0; + pInfo->ulMaxKeySize = 0; + pInfo->flags = CKF_GENERATE; + break; #ifndef WITH_FIPS - case CKM_DES_CBC_PAD: - /* FALLTHROUGH */ + case CKM_DES_CBC_PAD: + /* FALLTHROUGH */ #endif - case CKM_DES3_CBC_PAD: - pInfo->flags = CKF_WRAP | CKF_UNWRAP; - /* FALLTHROUGH */ + case CKM_DES3_CBC_PAD: + pInfo->flags = CKF_WRAP | CKF_UNWRAP; + /* FALLTHROUGH */ #ifndef WITH_FIPS - /* FALLTHROUGH - extra needed due to gcc issue. */ - case CKM_DES_ECB: - /* FALLTHROUGH */ - case CKM_DES_CBC: - /* FALLTHROUGH */ + /* FALLTHROUGH - extra needed due to gcc issue. */ + case CKM_DES_ECB: + /* FALLTHROUGH */ + case CKM_DES_CBC: + /* FALLTHROUGH */ #endif - case CKM_DES3_CBC: - pInfo->flags |= CKF_WRAP; - /* FALLTHROUGH */ - case CKM_DES3_ECB: - // Key size is not in use - pInfo->ulMinKeySize = 0; - pInfo->ulMaxKeySize = 0; - pInfo->flags |= CKF_ENCRYPT | CKF_DECRYPT; - break; - case CKM_DES3_CMAC: - // Key size is not in use - pInfo->ulMinKeySize = 0; - pInfo->ulMaxKeySize = 0; - pInfo->flags = CKF_SIGN | CKF_VERIFY; - break; - case CKM_AES_KEY_GEN: - pInfo->ulMinKeySize = 16; - pInfo->ulMaxKeySize = 32; - pInfo->flags = CKF_GENERATE; - break; - case CKM_AES_CBC_PAD: - pInfo->flags = CKF_UNWRAP | CKF_WRAP; - /* FALLTHROUGH */ - case CKM_AES_CBC: - pInfo->flags |= CKF_WRAP; - /* FALLTHROUGH */ - case CKM_AES_ECB: - case CKM_AES_CTR: - case CKM_AES_GCM: - pInfo->ulMinKeySize = 16; - pInfo->ulMaxKeySize = 32; - pInfo->flags |= CKF_ENCRYPT | CKF_DECRYPT; - break; - case CKM_AES_KEY_WRAP: - pInfo->ulMinKeySize = 16; - pInfo->ulMaxKeySize = 0x80000000; - pInfo->flags = CKF_WRAP | CKF_UNWRAP; - break; + case CKM_DES3_CBC: + pInfo->flags |= CKF_WRAP; + /* FALLTHROUGH */ + case CKM_DES3_ECB: + // Key size is not in use + pInfo->ulMinKeySize = 0; + pInfo->ulMaxKeySize = 0; + pInfo->flags |= CKF_ENCRYPT | CKF_DECRYPT; + break; + case CKM_DES3_CMAC: + // Key size is not in use + pInfo->ulMinKeySize = 0; + pInfo->ulMaxKeySize = 0; + pInfo->flags = CKF_SIGN | CKF_VERIFY; + break; + case CKM_AES_KEY_GEN: + pInfo->ulMinKeySize = 16; + pInfo->ulMaxKeySize = 32; + pInfo->flags = CKF_GENERATE; + break; + case CKM_AES_CBC_PAD: + pInfo->flags = CKF_UNWRAP | CKF_WRAP; + /* FALLTHROUGH */ + case CKM_AES_CBC: + pInfo->flags |= CKF_WRAP; + /* FALLTHROUGH */ + case CKM_AES_ECB: + case CKM_AES_CTR: + case CKM_AES_GCM: + pInfo->ulMinKeySize = 16; + pInfo->ulMaxKeySize = 32; + pInfo->flags |= CKF_ENCRYPT | CKF_DECRYPT; + break; + case CKM_AES_KEY_WRAP: + pInfo->ulMinKeySize = 16; + pInfo->ulMaxKeySize = 0x80000000; + pInfo->flags = CKF_WRAP | CKF_UNWRAP; + break; #ifdef HAVE_AES_KEY_WRAP_PAD - case CKM_AES_KEY_WRAP_PAD: - pInfo->ulMinKeySize = 1; - pInfo->ulMaxKeySize = 0x80000000; - pInfo->flags = CKF_WRAP | CKF_UNWRAP; - break; + case CKM_AES_KEY_WRAP_PAD: + pInfo->ulMinKeySize = 1; + pInfo->ulMaxKeySize = 0x80000000; + pInfo->flags = CKF_WRAP | CKF_UNWRAP; + break; #endif - case CKM_RSA_AES_KEY_WRAP: - pInfo->ulMinKeySize = rsaMinSize; - pInfo->ulMaxKeySize = rsaMaxSize; - pInfo->flags = CKF_WRAP | CKF_UNWRAP; - break; + case CKM_RSA_AES_KEY_WRAP: + pInfo->ulMinKeySize = rsaMinSize; + pInfo->ulMaxKeySize = rsaMaxSize; + pInfo->flags = CKF_WRAP | CKF_UNWRAP; + break; #ifndef WITH_FIPS - case CKM_DES_ECB_ENCRYPT_DATA: - case CKM_DES_CBC_ENCRYPT_DATA: + case CKM_DES_ECB_ENCRYPT_DATA: + case CKM_DES_CBC_ENCRYPT_DATA: #endif - case CKM_DES3_ECB_ENCRYPT_DATA: - case CKM_DES3_CBC_ENCRYPT_DATA: - case CKM_AES_ECB_ENCRYPT_DATA: - case CKM_AES_CBC_ENCRYPT_DATA: - // Key size is not in use - pInfo->ulMinKeySize = 0; - pInfo->ulMaxKeySize = 0; - pInfo->flags = CKF_DERIVE; - break; - case CKM_AES_CMAC: - pInfo->ulMinKeySize = 16; - pInfo->ulMaxKeySize = 32; - pInfo->flags = CKF_SIGN | CKF_VERIFY; - break; - case CKM_DSA_PARAMETER_GEN: - pInfo->ulMinKeySize = dsaMinSize; - pInfo->ulMaxKeySize = dsaMaxSize; - pInfo->flags = CKF_GENERATE; - break; - case CKM_DSA_KEY_PAIR_GEN: - pInfo->ulMinKeySize = dsaMinSize; - pInfo->ulMaxKeySize = dsaMaxSize; - pInfo->flags = CKF_GENERATE_KEY_PAIR; - break; - case CKM_DSA: - case CKM_DSA_SHA1: - case CKM_DSA_SHA224: - case CKM_DSA_SHA256: - case CKM_DSA_SHA384: - case CKM_DSA_SHA512: - pInfo->ulMinKeySize = dsaMinSize; - pInfo->ulMaxKeySize = dsaMaxSize; - pInfo->flags = CKF_SIGN | CKF_VERIFY; - break; - case CKM_DH_PKCS_KEY_PAIR_GEN: - pInfo->ulMinKeySize = dhMinSize; - pInfo->ulMaxKeySize = dhMaxSize; - pInfo->flags = CKF_GENERATE_KEY_PAIR; - break; - case CKM_DH_PKCS_PARAMETER_GEN: - pInfo->ulMinKeySize = dhMinSize; - pInfo->ulMaxKeySize = dhMaxSize; - pInfo->flags = CKF_GENERATE; - break; - case CKM_DH_PKCS_DERIVE: - pInfo->ulMinKeySize = dhMinSize; - pInfo->ulMaxKeySize = dhMaxSize; - pInfo->flags = CKF_DERIVE; - break; + case CKM_DES3_ECB_ENCRYPT_DATA: + case CKM_DES3_CBC_ENCRYPT_DATA: + case CKM_AES_ECB_ENCRYPT_DATA: + case CKM_AES_CBC_ENCRYPT_DATA: + // Key size is not in use + pInfo->ulMinKeySize = 0; + pInfo->ulMaxKeySize = 0; + pInfo->flags = CKF_DERIVE; + break; + case CKM_AES_CMAC: + pInfo->ulMinKeySize = 16; + pInfo->ulMaxKeySize = 32; + pInfo->flags = CKF_SIGN | CKF_VERIFY; + break; + case CKM_DSA_PARAMETER_GEN: + pInfo->ulMinKeySize = dsaMinSize; + pInfo->ulMaxKeySize = dsaMaxSize; + pInfo->flags = CKF_GENERATE; + break; + case CKM_DSA_KEY_PAIR_GEN: + pInfo->ulMinKeySize = dsaMinSize; + pInfo->ulMaxKeySize = dsaMaxSize; + pInfo->flags = CKF_GENERATE_KEY_PAIR; + break; + case CKM_DSA: + case CKM_DSA_SHA1: + case CKM_DSA_SHA224: + case CKM_DSA_SHA256: + case CKM_DSA_SHA384: + case CKM_DSA_SHA512: + pInfo->ulMinKeySize = dsaMinSize; + pInfo->ulMaxKeySize = dsaMaxSize; + pInfo->flags = CKF_SIGN | CKF_VERIFY; + break; + case CKM_DH_PKCS_KEY_PAIR_GEN: + pInfo->ulMinKeySize = dhMinSize; + pInfo->ulMaxKeySize = dhMaxSize; + pInfo->flags = CKF_GENERATE_KEY_PAIR; + break; + case CKM_DH_PKCS_PARAMETER_GEN: + pInfo->ulMinKeySize = dhMinSize; + pInfo->ulMaxKeySize = dhMaxSize; + pInfo->flags = CKF_GENERATE; + break; + case CKM_DH_PKCS_DERIVE: + pInfo->ulMinKeySize = dhMinSize; + pInfo->ulMaxKeySize = dhMaxSize; + pInfo->flags = CKF_DERIVE; + break; #ifdef WITH_ECC - case CKM_EC_KEY_PAIR_GEN: - pInfo->ulMinKeySize = ecdsaMinSize; - pInfo->ulMaxKeySize = ecdsaMaxSize; -#define CKF_EC_COMMOM (CKF_EC_F_P | CKF_EC_NAMEDCURVE | CKF_EC_UNCOMPRESS) - pInfo->flags = CKF_GENERATE_KEY_PAIR | CKF_EC_COMMOM; - break; - case CKM_ECDSA: - case CKM_ECDSA_SHA1: - case CKM_ECDSA_SHA224: - case CKM_ECDSA_SHA256: - case CKM_ECDSA_SHA384: - case CKM_ECDSA_SHA512: - pInfo->ulMinKeySize = ecdsaMinSize; - pInfo->ulMaxKeySize = ecdsaMaxSize; - pInfo->flags = CKF_SIGN | CKF_VERIFY | CKF_EC_COMMOM; - break; + case CKM_EC_KEY_PAIR_GEN: + pInfo->ulMinKeySize = ecdsaMinSize; + pInfo->ulMaxKeySize = ecdsaMaxSize; +#define CKF_EC_COMMOM (CKF_EC_F_P | CKF_EC_NAMEDCURVE | CKF_EC_UNCOMPRESS) + pInfo->flags = CKF_GENERATE_KEY_PAIR | CKF_EC_COMMOM; + break; + case CKM_ECDSA: + case CKM_ECDSA_SHA1: + case CKM_ECDSA_SHA224: + case CKM_ECDSA_SHA256: + case CKM_ECDSA_SHA384: + case CKM_ECDSA_SHA512: + pInfo->ulMinKeySize = ecdsaMinSize; + pInfo->ulMaxKeySize = ecdsaMaxSize; + pInfo->flags = CKF_SIGN | CKF_VERIFY | CKF_EC_COMMOM; + break; #endif #if defined(WITH_ECC) || defined(WITH_EDDSA) - case CKM_ECDH1_DERIVE: - pInfo->ulMinKeySize = ecdhMinSize ? ecdhMinSize : eddsaMinSize; - pInfo->ulMaxKeySize = ecdhMaxSize ? ecdhMaxSize : eddsaMaxSize; - pInfo->flags = CKF_DERIVE; - break; + case CKM_ECDH1_DERIVE: + pInfo->ulMinKeySize = ecdhMinSize ? ecdhMinSize : eddsaMinSize; + pInfo->ulMaxKeySize = ecdhMaxSize ? ecdhMaxSize : eddsaMaxSize; + pInfo->flags = CKF_DERIVE; + break; #endif #ifdef WITH_GOST - case CKM_GOSTR3411: - // Key size is not in use - pInfo->ulMinKeySize = 0; - pInfo->ulMaxKeySize = 0; - pInfo->flags = CKF_DIGEST; - break; - case CKM_GOSTR3411_HMAC: - // Key size is not in use - pInfo->ulMinKeySize = 32; - pInfo->ulMaxKeySize = 512; - pInfo->flags = CKF_SIGN | CKF_VERIFY; - break; - case CKM_GOSTR3410_KEY_PAIR_GEN: - // Key size is not in use - pInfo->ulMinKeySize = 0; - pInfo->ulMaxKeySize = 0; - pInfo->flags = CKF_GENERATE_KEY_PAIR; - break; - case CKM_GOSTR3410: - // Key size is not in use - pInfo->ulMinKeySize = 0; - pInfo->ulMaxKeySize = 0; - pInfo->flags = CKF_SIGN | CKF_VERIFY; - break; - case CKM_GOSTR3410_WITH_GOSTR3411: - // Key size is not in use - pInfo->ulMinKeySize = 0; - pInfo->ulMaxKeySize = 0; - pInfo->flags = CKF_SIGN | CKF_VERIFY; - break; + case CKM_GOSTR3411: + // Key size is not in use + pInfo->ulMinKeySize = 0; + pInfo->ulMaxKeySize = 0; + pInfo->flags = CKF_DIGEST; + break; + case CKM_GOSTR3411_HMAC: + // Key size is not in use + pInfo->ulMinKeySize = 32; + pInfo->ulMaxKeySize = 512; + pInfo->flags = CKF_SIGN | CKF_VERIFY; + break; + case CKM_GOSTR3410_KEY_PAIR_GEN: + // Key size is not in use + pInfo->ulMinKeySize = 0; + pInfo->ulMaxKeySize = 0; + pInfo->flags = CKF_GENERATE_KEY_PAIR; + break; + case CKM_GOSTR3410: + // Key size is not in use + pInfo->ulMinKeySize = 0; + pInfo->ulMaxKeySize = 0; + pInfo->flags = CKF_SIGN | CKF_VERIFY; + break; + case CKM_GOSTR3410_WITH_GOSTR3411: + // Key size is not in use + pInfo->ulMinKeySize = 0; + pInfo->ulMaxKeySize = 0; + pInfo->flags = CKF_SIGN | CKF_VERIFY; + break; #endif #ifdef WITH_EDDSA - case CKM_EC_EDWARDS_KEY_PAIR_GEN: - pInfo->ulMinKeySize = eddsaMinSize; - pInfo->ulMaxKeySize = eddsaMaxSize; - pInfo->flags = CKF_GENERATE_KEY_PAIR; - break; - case CKM_EDDSA: - pInfo->ulMinKeySize = eddsaMinSize; - pInfo->ulMaxKeySize = eddsaMaxSize; - pInfo->flags = CKF_SIGN | CKF_VERIFY; - break; + case CKM_EC_EDWARDS_KEY_PAIR_GEN: + pInfo->ulMinKeySize = eddsaMinSize; + pInfo->ulMaxKeySize = eddsaMaxSize; + pInfo->flags = CKF_GENERATE_KEY_PAIR; + break; + case CKM_EDDSA: + pInfo->ulMinKeySize = eddsaMinSize; + pInfo->ulMaxKeySize = eddsaMaxSize; + pInfo->flags = CKF_SIGN | CKF_VERIFY; + break; #endif - case CKM_CONCATENATE_DATA_AND_BASE: - case CKM_CONCATENATE_BASE_AND_DATA: - case CKM_CONCATENATE_BASE_AND_KEY: - pInfo->ulMinKeySize = 1; - pInfo->ulMaxKeySize = 512; - pInfo->flags = CKF_DERIVE; - break; - default: - DEBUG_MSG("The selected mechanism is not supported"); - return CKR_MECHANISM_INVALID; - break; + case CKM_CONCATENATE_DATA_AND_BASE: + case CKM_CONCATENATE_BASE_AND_DATA: + case CKM_CONCATENATE_BASE_AND_KEY: + pInfo->ulMinKeySize = 1; + pInfo->ulMaxKeySize = 512; + pInfo->flags = CKF_DERIVE; + break; + default: + DEBUG_MSG("The selected mechanism is not supported"); + return CKR_MECHANISM_INVALID; + break; } return CKR_OK; @@ -1336,9 +1359,10 @@ CK_RV SoftHSM::C_GetMechanismInfo(CK_SLOT_ID slotID, CK_MECHANISM_TYPE type, CK_ // Initialise the token in the specified slot CK_RV SoftHSM::C_InitToken(CK_SLOT_ID slotID, CK_UTF8CHAR_PTR pPin, CK_ULONG ulPinLen, CK_UTF8CHAR_PTR pLabel) { - if (!isInitialised) return CKR_CRYPTOKI_NOT_INITIALIZED; + if (!isInitialised) + return CKR_CRYPTOKI_NOT_INITIALIZED; - Slot* slot = slotManager->getSlot(slotID); + Slot *slot = slotManager->getSlot(slotID); if (slot == NULL) { return CKR_SLOT_ID_INVALID; @@ -1351,8 +1375,10 @@ CK_RV SoftHSM::C_InitToken(CK_SLOT_ID slotID, CK_UTF8CHAR_PTR pPin, CK_ULONG ulP } // Check the PIN - if (pPin == NULL_PTR) return CKR_ARGUMENTS_BAD; - if (ulPinLen < MIN_PIN_LEN || ulPinLen > MAX_PIN_LEN) return CKR_PIN_INCORRECT; + if (pPin == NULL_PTR) + return CKR_ARGUMENTS_BAD; + if (ulPinLen < MIN_PIN_LEN || ulPinLen > MAX_PIN_LEN) + return CKR_PIN_INCORRECT; ByteString soPIN(pPin, ulPinLen); @@ -1362,22 +1388,28 @@ CK_RV SoftHSM::C_InitToken(CK_SLOT_ID slotID, CK_UTF8CHAR_PTR pPin, CK_ULONG ulP // Initialise the user PIN CK_RV SoftHSM::C_InitPIN(CK_SESSION_HANDLE hSession, CK_UTF8CHAR_PTR pPin, CK_ULONG ulPinLen) { - if (!isInitialised) return CKR_CRYPTOKI_NOT_INITIALIZED; + if (!isInitialised) + return CKR_CRYPTOKI_NOT_INITIALIZED; // Get the session - Session* session = (Session*)handleManager->getSession(hSession); - if (session == NULL) return CKR_SESSION_HANDLE_INVALID; + Session *session = (Session *)handleManager->getSession(hSession); + if (session == NULL) + return CKR_SESSION_HANDLE_INVALID; // The SO must be logged in - if (session->getState() != CKS_RW_SO_FUNCTIONS) return CKR_USER_NOT_LOGGED_IN; + if (session->getState() != CKS_RW_SO_FUNCTIONS) + return CKR_USER_NOT_LOGGED_IN; // Get the token - Token* token = session->getToken(); - if (token == NULL) return CKR_GENERAL_ERROR; + Token *token = session->getToken(); + if (token == NULL) + return CKR_GENERAL_ERROR; // Check the PIN - if (pPin == NULL_PTR) return CKR_ARGUMENTS_BAD; - if (ulPinLen < MIN_PIN_LEN || ulPinLen > MAX_PIN_LEN) return CKR_PIN_LEN_RANGE; + if (pPin == NULL_PTR) + return CKR_ARGUMENTS_BAD; + if (ulPinLen < MIN_PIN_LEN || ulPinLen > MAX_PIN_LEN) + return CKR_PIN_LEN_RANGE; ByteString userPIN(pPin, ulPinLen); @@ -1389,35 +1421,41 @@ CK_RV SoftHSM::C_SetPIN(CK_SESSION_HANDLE hSession, CK_UTF8CHAR_PTR pOldPin, CK_ { CK_RV rv = CKR_OK; - if (!isInitialised) return CKR_CRYPTOKI_NOT_INITIALIZED; + if (!isInitialised) + return CKR_CRYPTOKI_NOT_INITIALIZED; // Get the session - Session* session = (Session*)handleManager->getSession(hSession); - if (session == NULL) return CKR_SESSION_HANDLE_INVALID; - + Session *session = (Session *)handleManager->getSession(hSession); + if (session == NULL) + return CKR_SESSION_HANDLE_INVALID; + // Check the new PINs - if (pOldPin == NULL_PTR) return CKR_ARGUMENTS_BAD; - if (pNewPin == NULL_PTR) return CKR_ARGUMENTS_BAD; - if (ulNewLen < MIN_PIN_LEN || ulNewLen > MAX_PIN_LEN) return CKR_PIN_LEN_RANGE; + if (pOldPin == NULL_PTR) + return CKR_ARGUMENTS_BAD; + if (pNewPin == NULL_PTR) + return CKR_ARGUMENTS_BAD; + if (ulNewLen < MIN_PIN_LEN || ulNewLen > MAX_PIN_LEN) + return CKR_PIN_LEN_RANGE; ByteString oldPIN(pOldPin, ulOldLen); ByteString newPIN(pNewPin, ulNewLen); // Get the token - Token* token = session->getToken(); - if (token == NULL) return CKR_GENERAL_ERROR; + Token *token = session->getToken(); + if (token == NULL) + return CKR_GENERAL_ERROR; switch (session->getState()) { - case CKS_RW_PUBLIC_SESSION: - case CKS_RW_USER_FUNCTIONS: - rv = token->setUserPIN(oldPIN, newPIN); - break; - case CKS_RW_SO_FUNCTIONS: - rv = token->setSOPIN(oldPIN, newPIN); - break; - default: - return CKR_SESSION_READ_ONLY; + case CKS_RW_PUBLIC_SESSION: + case CKS_RW_USER_FUNCTIONS: + rv = token->setUserPIN(oldPIN, newPIN); + break; + case CKS_RW_SO_FUNCTIONS: + rv = token->setSOPIN(oldPIN, newPIN); + break; + default: + return CKR_SESSION_READ_ONLY; } return rv; @@ -1426,18 +1464,20 @@ CK_RV SoftHSM::C_SetPIN(CK_SESSION_HANDLE hSession, CK_UTF8CHAR_PTR pOldPin, CK_ // Open a new session to the specified slot CK_RV SoftHSM::C_OpenSession(CK_SLOT_ID slotID, CK_FLAGS flags, CK_VOID_PTR pApplication, CK_NOTIFY notify, CK_SESSION_HANDLE_PTR phSession) { - if (!isInitialised) return CKR_CRYPTOKI_NOT_INITIALIZED; + if (!isInitialised) + return CKR_CRYPTOKI_NOT_INITIALIZED; - Slot* slot = slotManager->getSlot(slotID); + Slot *slot = slotManager->getSlot(slotID); CK_RV rv = sessionManager->openSession(slot, flags, pApplication, notify, phSession); if (rv != CKR_OK) return rv; // Get a pointer to the session object and store it in the handle manager. - Session* session = sessionManager->getSession(*phSession); - if (session == NULL) return CKR_SESSION_HANDLE_INVALID; - *phSession = handleManager->addSession(slotID,session); + Session *session = sessionManager->getSession(*phSession); + if (session == NULL) + return CKR_SESSION_HANDLE_INVALID; + *phSession = handleManager->addSession(slotID, session); return CKR_OK; } @@ -1445,16 +1485,17 @@ CK_RV SoftHSM::C_OpenSession(CK_SLOT_ID slotID, CK_FLAGS flags, CK_VOID_PTR pApp // Close the given session CK_RV SoftHSM::C_CloseSession(CK_SESSION_HANDLE hSession) { - if (!isInitialised) return CKR_CRYPTOKI_NOT_INITIALIZED; + if (!isInitialised) + return CKR_CRYPTOKI_NOT_INITIALIZED; // Get the session - Session* session = (Session*)handleManager->getSession(hSession); - if (session == NULL) return CKR_SESSION_HANDLE_INVALID; + Session *session = (Session *)handleManager->getSession(hSession); + if (session == NULL) + return CKR_SESSION_HANDLE_INVALID; // Tell the handle manager the session has been closed. handleManager->sessionClosed(hSession); - // Tell the session object store that the session has closed. sessionObjectStore->sessionClosed(hSession); @@ -1465,15 +1506,18 @@ CK_RV SoftHSM::C_CloseSession(CK_SESSION_HANDLE hSession) // Close all open sessions CK_RV SoftHSM::C_CloseAllSessions(CK_SLOT_ID slotID) { - if (!isInitialised) return CKR_CRYPTOKI_NOT_INITIALIZED; + if (!isInitialised) + return CKR_CRYPTOKI_NOT_INITIALIZED; // Get the slot - Slot* slot = slotManager->getSlot(slotID); - if (slot == NULL) return CKR_SLOT_ID_INVALID; + Slot *slot = slotManager->getSlot(slotID); + if (slot == NULL) + return CKR_SLOT_ID_INVALID; // Get the token - Token* token = slot->getToken(); - if (token == NULL) return CKR_TOKEN_NOT_PRESENT; + Token *token = slot->getToken(); + if (token == NULL) + return CKR_TOKEN_NOT_PRESENT; // Tell the handle manager all sessions were closed for the given slotID. // The handle manager should then remove all session and object handles for this slot. @@ -1491,11 +1535,13 @@ CK_RV SoftHSM::C_CloseAllSessions(CK_SLOT_ID slotID) // Retrieve information about the specified session CK_RV SoftHSM::C_GetSessionInfo(CK_SESSION_HANDLE hSession, CK_SESSION_INFO_PTR pInfo) { - if (!isInitialised) return CKR_CRYPTOKI_NOT_INITIALIZED; + if (!isInitialised) + return CKR_CRYPTOKI_NOT_INITIALIZED; // Get the session - Session* session = (Session*)handleManager->getSession(hSession); - if (session == NULL) return CKR_SESSION_HANDLE_INVALID; + Session *session = (Session *)handleManager->getSession(hSession); + if (session == NULL) + return CKR_SESSION_HANDLE_INVALID; return session->getInfo(pInfo); } @@ -1503,11 +1549,13 @@ CK_RV SoftHSM::C_GetSessionInfo(CK_SESSION_HANDLE hSession, CK_SESSION_INFO_PTR // Determine the state of a running operation in a session CK_RV SoftHSM::C_GetOperationState(CK_SESSION_HANDLE hSession, CK_BYTE_PTR /*pOperationState*/, CK_ULONG_PTR /*pulOperationStateLen*/) { - if (!isInitialised) return CKR_CRYPTOKI_NOT_INITIALIZED; + if (!isInitialised) + return CKR_CRYPTOKI_NOT_INITIALIZED; // Get the session - Session* session = (Session*)handleManager->getSession(hSession); - if (session == NULL) return CKR_SESSION_HANDLE_INVALID; + Session *session = (Session *)handleManager->getSession(hSession); + if (session == NULL) + return CKR_SESSION_HANDLE_INVALID; return CKR_FUNCTION_NOT_SUPPORTED; } @@ -1515,11 +1563,13 @@ CK_RV SoftHSM::C_GetOperationState(CK_SESSION_HANDLE hSession, CK_BYTE_PTR /*pOp // Set the operation sate in a session CK_RV SoftHSM::C_SetOperationState(CK_SESSION_HANDLE hSession, CK_BYTE_PTR /*pOperationState*/, CK_ULONG /*ulOperationStateLen*/, CK_OBJECT_HANDLE /*hEncryptionKey*/, CK_OBJECT_HANDLE /*hAuthenticationKey*/) { - if (!isInitialised) return CKR_CRYPTOKI_NOT_INITIALIZED; + if (!isInitialised) + return CKR_CRYPTOKI_NOT_INITIALIZED; // Get the session - Session* session = (Session*)handleManager->getSession(hSession); - if (session == NULL) return CKR_SESSION_HANDLE_INVALID; + Session *session = (Session *)handleManager->getSession(hSession); + if (session == NULL) + return CKR_SESSION_HANDLE_INVALID; return CKR_FUNCTION_NOT_SUPPORTED; } @@ -1529,43 +1579,50 @@ CK_RV SoftHSM::C_Login(CK_SESSION_HANDLE hSession, CK_USER_TYPE userType, CK_UTF { CK_RV rv = CKR_OK; - if (!isInitialised) return CKR_CRYPTOKI_NOT_INITIALIZED; + if (!isInitialised) + return CKR_CRYPTOKI_NOT_INITIALIZED; // Get the session - Session* session = (Session*)handleManager->getSession(hSession); - if (session == NULL) return CKR_SESSION_HANDLE_INVALID; + Session *session = (Session *)handleManager->getSession(hSession); + if (session == NULL) + return CKR_SESSION_HANDLE_INVALID; // Get the PIN - if (pPin == NULL_PTR) return CKR_ARGUMENTS_BAD; + if (pPin == NULL_PTR) + return CKR_ARGUMENTS_BAD; ByteString pin(pPin, ulPinLen); // Get the token - Token* token = session->getToken(); - if (token == NULL) return CKR_GENERAL_ERROR; + Token *token = session->getToken(); + if (token == NULL) + return CKR_GENERAL_ERROR; switch (userType) { - case CKU_SO: - // There cannot exist a R/O session on this slot - if (sessionManager->haveROSession(session->getSlot()->getSlotID())) return CKR_SESSION_READ_ONLY_EXISTS; + case CKU_SO: + // There cannot exist a R/O session on this slot + if (sessionManager->haveROSession(session->getSlot()->getSlotID())) + return CKR_SESSION_READ_ONLY_EXISTS; - // Login - rv = token->loginSO(pin); - break; - case CKU_USER: - // Login - rv = token->loginUser(pin); - break; - case CKU_CONTEXT_SPECIFIC: - // Check if re-authentication is required - if (!session->getReAuthentication()) return CKR_OPERATION_NOT_INITIALIZED; + // Login + rv = token->loginSO(pin); + break; + case CKU_USER: + // Login + rv = token->loginUser(pin); + break; + case CKU_CONTEXT_SPECIFIC: + // Check if re-authentication is required + if (!session->getReAuthentication()) + return CKR_OPERATION_NOT_INITIALIZED; - // Re-authenticate - rv = token->reAuthenticate(pin); - if (rv == CKR_OK) session->setReAuthentication(false); - break; - default: - return CKR_USER_TYPE_INVALID; + // Re-authenticate + rv = token->reAuthenticate(pin); + if (rv == CKR_OK) + session->setReAuthentication(false); + break; + default: + return CKR_USER_TYPE_INVALID; } return rv; @@ -1574,15 +1631,18 @@ CK_RV SoftHSM::C_Login(CK_SESSION_HANDLE hSession, CK_USER_TYPE userType, CK_UTF // Log out of the token in the specified session CK_RV SoftHSM::C_Logout(CK_SESSION_HANDLE hSession) { - if (!isInitialised) return CKR_CRYPTOKI_NOT_INITIALIZED; + if (!isInitialised) + return CKR_CRYPTOKI_NOT_INITIALIZED; // Get the session - Session* session = (Session*)handleManager->getSession(hSession); - if (session == NULL) return CKR_SESSION_HANDLE_INVALID; + Session *session = (Session *)handleManager->getSession(hSession); + if (session == NULL) + return CKR_SESSION_HANDLE_INVALID; // Get the token - Token* token = session->getToken(); - if (token == NULL) return CKR_GENERAL_ERROR; + Token *token = session->getToken(); + if (token == NULL) + return CKR_GENERAL_ERROR; // Logout token->logout(); @@ -1603,33 +1663,40 @@ CK_RV SoftHSM::C_Logout(CK_SESSION_HANDLE hSession) // Create a new object on the token in the specified session using the given attribute template CK_RV SoftHSM::C_CreateObject(CK_SESSION_HANDLE hSession, CK_ATTRIBUTE_PTR pTemplate, CK_ULONG ulCount, CK_OBJECT_HANDLE_PTR phObject) { - return this->CreateObject(hSession,pTemplate,ulCount,phObject,OBJECT_OP_CREATE); + return this->CreateObject(hSession, pTemplate, ulCount, phObject, OBJECT_OP_CREATE); } // Create a copy of the object with the specified handle CK_RV SoftHSM::C_CopyObject(CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE hObject, CK_ATTRIBUTE_PTR pTemplate, CK_ULONG ulCount, CK_OBJECT_HANDLE_PTR phNewObject) { - if (!isInitialised) return CKR_CRYPTOKI_NOT_INITIALIZED; + if (!isInitialised) + return CKR_CRYPTOKI_NOT_INITIALIZED; - if (pTemplate == NULL_PTR) return CKR_ARGUMENTS_BAD; - if (phNewObject == NULL_PTR) return CKR_ARGUMENTS_BAD; + if (pTemplate == NULL_PTR) + return CKR_ARGUMENTS_BAD; + if (phNewObject == NULL_PTR) + return CKR_ARGUMENTS_BAD; *phNewObject = CK_INVALID_HANDLE; // Get the session - Session* session = (Session*)handleManager->getSession(hSession); - if (session == NULL) return CKR_SESSION_HANDLE_INVALID; + Session *session = (Session *)handleManager->getSession(hSession); + if (session == NULL) + return CKR_SESSION_HANDLE_INVALID; // Get the slot - Slot* slot = session->getSlot(); - if (slot == NULL_PTR) return CKR_GENERAL_ERROR; + Slot *slot = session->getSlot(); + if (slot == NULL_PTR) + return CKR_GENERAL_ERROR; // Get the token - Token* token = session->getToken(); - if (token == NULL_PTR) return CKR_GENERAL_ERROR; + Token *token = session->getToken(); + if (token == NULL_PTR) + return CKR_GENERAL_ERROR; // Check the object handle. OSObject *object = (OSObject *)handleManager->getObject(hObject); - if (object == NULL_PTR || !object->isValid()) return CKR_OBJECT_HANDLE_INVALID; + if (object == NULL_PTR || !object->isValid()) + return CKR_OBJECT_HANDLE_INVALID; CK_BBOOL wasOnToken = object->getBooleanValue(CKA_TOKEN, false); CK_BBOOL wasPrivate = object->getBooleanValue(CKA_PRIVATE, true); @@ -1646,7 +1713,8 @@ CK_RV SoftHSM::C_CopyObject(CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE hObject // Check if the object is copyable CK_BBOOL isCopyable = object->getBooleanValue(CKA_COPYABLE, true); - if (!isCopyable) return CKR_ACTION_PROHIBITED; + if (!isCopyable) + return CKR_ACTION_PROHIBITED; // Extract critical information from the template CK_BBOOL isOnToken = wasOnToken; @@ -1656,18 +1724,19 @@ CK_RV SoftHSM::C_CopyObject(CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE hObject { if ((pTemplate[i].type == CKA_TOKEN) && (pTemplate[i].ulValueLen == sizeof(CK_BBOOL))) { - isOnToken = *(CK_BBOOL*)pTemplate[i].pValue; + isOnToken = *(CK_BBOOL *)pTemplate[i].pValue; continue; } if ((pTemplate[i].type == CKA_PRIVATE) && (pTemplate[i].ulValueLen == sizeof(CK_BBOOL))) { - isPrivate = *(CK_BBOOL*)pTemplate[i].pValue; + isPrivate = *(CK_BBOOL *)pTemplate[i].pValue; continue; } } // Check privacy does not downgrade - if (wasPrivate && !isPrivate) return CKR_TEMPLATE_INCONSISTENT; + if (wasPrivate && !isPrivate) + return CKR_TEMPLATE_INCONSISTENT; // Check write user credentials rv = haveWrite(session->getState(), isOnToken, isPrivate); @@ -1685,13 +1754,14 @@ CK_RV SoftHSM::C_CopyObject(CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE hObject OSObject *newobject = NULL_PTR; if (isOnToken) { - newobject = (OSObject*) token->createObject(); + newobject = (OSObject *)token->createObject(); } else { newobject = sessionObjectStore->createObject(slot->getSlotID(), hSession, isPrivate != CK_FALSE); } - if (newobject == NULL) return CKR_GENERAL_ERROR; + if (newobject == NULL) + return CKR_GENERAL_ERROR; // Copy attributes from object class (CKA_CLASS=0 so the first) if (!newobject->startTransaction()) @@ -1713,12 +1783,12 @@ CK_RV SoftHSM::C_CopyObject(CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE hObject // Upgrade privacy has to encrypt byte strings if (!wasPrivate && isPrivate && - attr.isByteStringAttribute() && - attr.getByteStringValue().size() != 0) + attr.isByteStringAttribute() && + attr.getByteStringValue().size() != 0) { ByteString value; if (!token->encrypt(attr.getByteStringValue(), value) || - !newobject->setAttribute(attrType, value)) + !newobject->setAttribute(attrType, value)) { rv = CKR_FUNCTION_FAILED; break; @@ -1733,8 +1803,7 @@ CK_RV SoftHSM::C_CopyObject(CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE hObject } } attrType = object->nextAttributeType(attrType); - } - while (attrType != CKA_CLASS); + } while (attrType != CKA_CLASS); if (rv != CKR_OK) { @@ -1752,8 +1821,8 @@ CK_RV SoftHSM::C_CopyObject(CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE hObject } // Get the new P11 object - P11Object* newp11object = NULL; - rv = newP11Object(newobject,&newp11object); + P11Object *newp11object = NULL; + rv = newP11Object(newobject, &newp11object); if (rv != CKR_OK) { newobject->destroyObject(); @@ -1786,19 +1855,23 @@ CK_RV SoftHSM::C_CopyObject(CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE hObject // Destroy the specified object CK_RV SoftHSM::C_DestroyObject(CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE hObject) { - if (!isInitialised) return CKR_CRYPTOKI_NOT_INITIALIZED; + if (!isInitialised) + return CKR_CRYPTOKI_NOT_INITIALIZED; // Get the session - Session* session = (Session*)handleManager->getSession(hSession); - if (session == NULL) return CKR_SESSION_HANDLE_INVALID; + Session *session = (Session *)handleManager->getSession(hSession); + if (session == NULL) + return CKR_SESSION_HANDLE_INVALID; // Get the token - Token* token = session->getToken(); - if (token == NULL_PTR) return CKR_GENERAL_ERROR; + Token *token = session->getToken(); + if (token == NULL_PTR) + return CKR_GENERAL_ERROR; // Check the object handle. OSObject *object = (OSObject *)handleManager->getObject(hObject); - if (object == NULL_PTR || !object->isValid()) return CKR_OBJECT_HANDLE_INVALID; + if (object == NULL_PTR || !object->isValid()) + return CKR_OBJECT_HANDLE_INVALID; CK_BBOOL isOnToken = object->getBooleanValue(CKA_TOKEN, false); CK_BBOOL isPrivate = object->getBooleanValue(CKA_PRIVATE, true); @@ -1817,7 +1890,8 @@ CK_RV SoftHSM::C_DestroyObject(CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE hObj // Check if the object is destroyable CK_BBOOL isDestroyable = object->getBooleanValue(CKA_DESTROYABLE, true); - if (!isDestroyable) return CKR_ACTION_PROHIBITED; + if (!isDestroyable) + return CKR_ACTION_PROHIBITED; // Tell the handleManager to forget about the object. handleManager->destroyObject(hObject); @@ -1832,21 +1906,26 @@ CK_RV SoftHSM::C_DestroyObject(CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE hObj // Determine the size of the specified object CK_RV SoftHSM::C_GetObjectSize(CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE hObject, CK_ULONG_PTR pulSize) { - if (!isInitialised) return CKR_CRYPTOKI_NOT_INITIALIZED; + if (!isInitialised) + return CKR_CRYPTOKI_NOT_INITIALIZED; - if (pulSize == NULL) return CKR_ARGUMENTS_BAD; + if (pulSize == NULL) + return CKR_ARGUMENTS_BAD; // Get the session - Session* session = (Session*)handleManager->getSession(hSession); - if (session == NULL) return CKR_SESSION_HANDLE_INVALID; + Session *session = (Session *)handleManager->getSession(hSession); + if (session == NULL) + return CKR_SESSION_HANDLE_INVALID; // Get the token - Token* token = session->getToken(); - if (token == NULL_PTR) return CKR_GENERAL_ERROR; + Token *token = session->getToken(); + if (token == NULL_PTR) + return CKR_GENERAL_ERROR; // Check the object handle. OSObject *object = (OSObject *)handleManager->getObject(hObject); - if (object == NULL_PTR || !object->isValid()) return CKR_OBJECT_HANDLE_INVALID; + if (object == NULL_PTR || !object->isValid()) + return CKR_OBJECT_HANDLE_INVALID; *pulSize = CK_UNAVAILABLE_INFORMATION; @@ -1856,21 +1935,26 @@ CK_RV SoftHSM::C_GetObjectSize(CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE hObj // Retrieve the specified attributes for the given object CK_RV SoftHSM::C_GetAttributeValue(CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE hObject, CK_ATTRIBUTE_PTR pTemplate, CK_ULONG ulCount) { - if (!isInitialised) return CKR_CRYPTOKI_NOT_INITIALIZED; + if (!isInitialised) + return CKR_CRYPTOKI_NOT_INITIALIZED; - if (pTemplate == NULL) return CKR_ARGUMENTS_BAD; + if (pTemplate == NULL) + return CKR_ARGUMENTS_BAD; // Get the session - Session* session = (Session*)handleManager->getSession(hSession); - if (session == NULL) return CKR_SESSION_HANDLE_INVALID; + Session *session = (Session *)handleManager->getSession(hSession); + if (session == NULL) + return CKR_SESSION_HANDLE_INVALID; // Get the token - Token* token = session->getToken(); - if (token == NULL) return CKR_GENERAL_ERROR; + Token *token = session->getToken(); + if (token == NULL) + return CKR_GENERAL_ERROR; // Check the object handle. OSObject *object = (OSObject *)handleManager->getObject(hObject); - if (object == NULL_PTR || !object->isValid()) return CKR_OBJECT_HANDLE_INVALID; + if (object == NULL_PTR || !object->isValid()) + return CKR_OBJECT_HANDLE_INVALID; CK_BBOOL isOnToken = object->getBooleanValue(CKA_TOKEN, false); CK_BBOOL isPrivate = object->getBooleanValue(CKA_PRIVATE, true); @@ -1889,13 +1973,13 @@ CK_RV SoftHSM::C_GetAttributeValue(CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE // Wrap a P11Object around the OSObject so we can access the attributes in the // context of the object in which it is defined. - P11Object* p11object = NULL; - rv = newP11Object(object,&p11object); + P11Object *p11object = NULL; + rv = newP11Object(object, &p11object); if (rv != CKR_OK) return rv; // Ask the P11Object to fill the template with attribute values. - rv = p11object->loadTemplate(token, pTemplate,ulCount); + rv = p11object->loadTemplate(token, pTemplate, ulCount); delete p11object; return rv; } @@ -1903,21 +1987,26 @@ CK_RV SoftHSM::C_GetAttributeValue(CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE // Change or set the value of the specified attributes on the specified object CK_RV SoftHSM::C_SetAttributeValue(CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE hObject, CK_ATTRIBUTE_PTR pTemplate, CK_ULONG ulCount) { - if (!isInitialised) return CKR_CRYPTOKI_NOT_INITIALIZED; + if (!isInitialised) + return CKR_CRYPTOKI_NOT_INITIALIZED; - if (pTemplate == NULL) return CKR_ARGUMENTS_BAD; + if (pTemplate == NULL) + return CKR_ARGUMENTS_BAD; // Get the session - Session* session = (Session*)handleManager->getSession(hSession); - if (session == NULL) return CKR_SESSION_HANDLE_INVALID; + Session *session = (Session *)handleManager->getSession(hSession); + if (session == NULL) + return CKR_SESSION_HANDLE_INVALID; // Get the token - Token* token = session->getToken(); - if (token == NULL) return CKR_GENERAL_ERROR; + Token *token = session->getToken(); + if (token == NULL) + return CKR_GENERAL_ERROR; // Check the object handle. OSObject *object = (OSObject *)handleManager->getObject(hObject); - if (object == NULL_PTR || !object->isValid()) return CKR_OBJECT_HANDLE_INVALID; + if (object == NULL_PTR || !object->isValid()) + return CKR_OBJECT_HANDLE_INVALID; CK_BBOOL isOnToken = object->getBooleanValue(CKA_TOKEN, false); CK_BBOOL isPrivate = object->getBooleanValue(CKA_PRIVATE, true); @@ -1936,17 +2025,18 @@ CK_RV SoftHSM::C_SetAttributeValue(CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE // Check if the object is modifiable CK_BBOOL isModifiable = object->getBooleanValue(CKA_MODIFIABLE, true); - if (!isModifiable) return CKR_ACTION_PROHIBITED; + if (!isModifiable) + return CKR_ACTION_PROHIBITED; // Wrap a P11Object around the OSObject so we can access the attributes in the // context of the object in which it is defined. - P11Object* p11object = NULL; - rv = newP11Object(object,&p11object); + P11Object *p11object = NULL; + rv = newP11Object(object, &p11object); if (rv != CKR_OK) return rv; // Ask the P11Object to save the template with attribute values. - rv = p11object->saveTemplate(token, isPrivate != CK_FALSE, pTemplate,ulCount,OBJECT_OP_SET); + rv = p11object->saveTemplate(token, isPrivate != CK_FALSE, pTemplate, ulCount, OBJECT_OP_SET); delete p11object; return rv; } @@ -1954,51 +2044,60 @@ CK_RV SoftHSM::C_SetAttributeValue(CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE // Initialise object search in the specified session using the specified attribute template as search parameters CK_RV SoftHSM::C_FindObjectsInit(CK_SESSION_HANDLE hSession, CK_ATTRIBUTE_PTR pTemplate, CK_ULONG ulCount) { - if (!isInitialised) return CKR_CRYPTOKI_NOT_INITIALIZED; - if (pTemplate == NULL_PTR && ulCount != 0) return CKR_ARGUMENTS_BAD; + if (!isInitialised) + return CKR_CRYPTOKI_NOT_INITIALIZED; + if (pTemplate == NULL_PTR && ulCount != 0) + return CKR_ARGUMENTS_BAD; // Get the session - Session* session = (Session*)handleManager->getSession(hSession); - if (session == NULL) return CKR_SESSION_HANDLE_INVALID; + Session *session = (Session *)handleManager->getSession(hSession); + if (session == NULL) + return CKR_SESSION_HANDLE_INVALID; // Get the slot - Slot* slot = session->getSlot(); - if (slot == NULL_PTR) return CKR_GENERAL_ERROR; + Slot *slot = session->getSlot(); + if (slot == NULL_PTR) + return CKR_GENERAL_ERROR; // Determine whether we have a public session or not. bool isPublicSession; - switch (session->getState()) { - case CKS_RO_USER_FUNCTIONS: - case CKS_RW_USER_FUNCTIONS: - isPublicSession = false; - break; - default: - isPublicSession = true; + switch (session->getState()) + { + case CKS_RO_USER_FUNCTIONS: + case CKS_RW_USER_FUNCTIONS: + isPublicSession = false; + break; + default: + isPublicSession = true; } // Get the token - Token* token = session->getToken(); - if (token == NULL_PTR) return CKR_GENERAL_ERROR; + Token *token = session->getToken(); + if (token == NULL_PTR) + return CKR_GENERAL_ERROR; // Check if we have another operation - if (session->getOpType() != SESSION_OP_NONE) return CKR_OPERATION_ACTIVE; + if (session->getOpType() != SESSION_OP_NONE) + return CKR_OPERATION_ACTIVE; session->setOpType(SESSION_OP_FIND); FindOperation *findOp = FindOperation::create(); // Check if we are out of memory - if (findOp == NULL_PTR) return CKR_HOST_MEMORY; + if (findOp == NULL_PTR) + return CKR_HOST_MEMORY; - std::set allObjects; + std::set allObjects; token->getObjects(allObjects); - sessionObjectStore->getObjects(slot->getSlotID(),allObjects); + sessionObjectStore->getObjects(slot->getSlotID(), allObjects); std::set handles; - std::set::iterator it; - for (it=allObjects.begin(); it != allObjects.end(); ++it) + std::set::iterator it; + for (it = allObjects.begin(); it != allObjects.end(); ++it) { // Refresh object and check if it is valid - if (!(*it)->isValid()) { + if (!(*it)->isValid()) + { DEBUG_MSG("Object is not valid, skipping"); continue; } @@ -2012,7 +2111,7 @@ CK_RV SoftHSM::C_FindObjectsInit(CK_SESSION_HANDLE hSession, CK_ATTRIBUTE_PTR pT // Perform the actual attribute matching. bool bAttrMatch = true; // We let an empty template match everything. - for (CK_ULONG i=0; iaddTokenObject(slotID,isPrivate,*it); + hObject = handleManager->addTokenObject(slotID, isPrivate, *it); else - hObject = handleManager->addSessionObject(slotID,hSession,isPrivate,*it); + hObject = handleManager->addSessionObject(slotID, hSession, isPrivate, *it); if (hObject == CK_INVALID_HANDLE) { delete findOp; @@ -2104,26 +2203,32 @@ CK_RV SoftHSM::C_FindObjectsInit(CK_SESSION_HANDLE hSession, CK_ATTRIBUTE_PTR pT // Continue the search for objects in the specified session CK_RV SoftHSM::C_FindObjects(CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE_PTR phObject, CK_ULONG ulMaxObjectCount, CK_ULONG_PTR pulObjectCount) { - if (!isInitialised) return CKR_CRYPTOKI_NOT_INITIALIZED; - if (phObject == NULL_PTR) return CKR_ARGUMENTS_BAD; - if (pulObjectCount == NULL_PTR) return CKR_ARGUMENTS_BAD; + if (!isInitialised) + return CKR_CRYPTOKI_NOT_INITIALIZED; + if (phObject == NULL_PTR) + return CKR_ARGUMENTS_BAD; + if (pulObjectCount == NULL_PTR) + return CKR_ARGUMENTS_BAD; // Get the session - Session* session = (Session*)handleManager->getSession(hSession); - if (session == NULL) return CKR_SESSION_HANDLE_INVALID; + Session *session = (Session *)handleManager->getSession(hSession); + if (session == NULL) + return CKR_SESSION_HANDLE_INVALID; // Check if we are doing the correct operation - if (session->getOpType() != SESSION_OP_FIND) return CKR_OPERATION_NOT_INITIALIZED; + if (session->getOpType() != SESSION_OP_FIND) + return CKR_OPERATION_NOT_INITIALIZED; // return the object handles that have been added to the find operation. FindOperation *findOp = session->getFindOp(); - if (findOp == NULL) return CKR_GENERAL_ERROR; + if (findOp == NULL) + return CKR_GENERAL_ERROR; // Ask the find operation to retrieve the object handles - *pulObjectCount = findOp->retrieveHandles(phObject,ulMaxObjectCount); + *pulObjectCount = findOp->retrieveHandles(phObject, ulMaxObjectCount); // Erase the object handles from the find operation. - findOp->eraseHandles(0,*pulObjectCount); + findOp->eraseHandles(0, *pulObjectCount); return CKR_OK; } @@ -2131,14 +2236,17 @@ CK_RV SoftHSM::C_FindObjects(CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE_PTR ph // Finish searching for objects CK_RV SoftHSM::C_FindObjectsFinal(CK_SESSION_HANDLE hSession) { - if (!isInitialised) return CKR_CRYPTOKI_NOT_INITIALIZED; + if (!isInitialised) + return CKR_CRYPTOKI_NOT_INITIALIZED; // Get the session - Session* session = (Session*)handleManager->getSession(hSession); - if (session == NULL) return CKR_SESSION_HANDLE_INVALID; + Session *session = (Session *)handleManager->getSession(hSession); + if (session == NULL) + return CKR_SESSION_HANDLE_INVALID; // Check if we are doing the correct operation - if (session->getOpType() != SESSION_OP_FIND) return CKR_OPERATION_NOT_INITIALIZED; + if (session->getOpType() != SESSION_OP_FIND) + return CKR_OPERATION_NOT_INITIALIZED; session->resetOp(); return CKR_OK; @@ -2147,47 +2255,55 @@ CK_RV SoftHSM::C_FindObjectsFinal(CK_SESSION_HANDLE hSession) // Encrypt*/Decrypt*() is for Symmetrical ciphers too static bool isSymMechanism(CK_MECHANISM_PTR pMechanism) { - if (pMechanism == NULL_PTR) return false; - - switch(pMechanism->mechanism) { - case CKM_DES_ECB: - case CKM_DES_CBC: - case CKM_DES_CBC_PAD: - case CKM_DES3_ECB: - case CKM_DES3_CBC: - case CKM_DES3_CBC_PAD: - case CKM_AES_ECB: - case CKM_AES_CBC: - case CKM_AES_CBC_PAD: - case CKM_AES_CTR: - case CKM_AES_GCM: - return true; - default: - return false; + if (pMechanism == NULL_PTR) + return false; + + switch (pMechanism->mechanism) + { + case CKM_DES_ECB: + case CKM_DES_CBC: + case CKM_DES_CBC_PAD: + case CKM_DES3_ECB: + case CKM_DES3_CBC: + case CKM_DES3_CBC_PAD: + case CKM_AES_ECB: + case CKM_AES_CBC: + case CKM_AES_CBC_PAD: + case CKM_AES_CTR: + case CKM_AES_GCM: + return true; + default: + return false; } } // SymAlgorithm version of C_EncryptInit CK_RV SoftHSM::SymEncryptInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechanism, CK_OBJECT_HANDLE hKey) { - if (!isInitialised) return CKR_CRYPTOKI_NOT_INITIALIZED; + if (!isInitialised) + return CKR_CRYPTOKI_NOT_INITIALIZED; - if (pMechanism == NULL_PTR) return CKR_ARGUMENTS_BAD; + if (pMechanism == NULL_PTR) + return CKR_ARGUMENTS_BAD; // Get the session - Session* session = (Session*)handleManager->getSession(hSession); - if (session == NULL) return CKR_SESSION_HANDLE_INVALID; + Session *session = (Session *)handleManager->getSession(hSession); + if (session == NULL) + return CKR_SESSION_HANDLE_INVALID; // Check if we have another operation - if (session->getOpType() != SESSION_OP_NONE) return CKR_OPERATION_ACTIVE; + if (session->getOpType() != SESSION_OP_NONE) + return CKR_OPERATION_ACTIVE; // Get the token - Token* token = session->getToken(); - if (token == NULL) return CKR_GENERAL_ERROR; + Token *token = session->getToken(); + if (token == NULL) + return CKR_GENERAL_ERROR; // Check the key handle. OSObject *key = (OSObject *)handleManager->getObject(hKey); - if (key == NULL_PTR || !key->isValid()) return CKR_OBJECT_HANDLE_INVALID; + if (key == NULL_PTR || !key->isValid()) + return CKR_OBJECT_HANDLE_INVALID; CK_BBOOL isOnToken = key->getBooleanValue(CKA_TOKEN, false); CK_BBOOL isPrivate = key->getBooleanValue(CKA_PRIVATE, true); @@ -2222,171 +2338,173 @@ CK_RV SoftHSM::SymEncryptInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMech size_t counterBits = 0; ByteString aad; size_t tagBytes = 0; - switch(pMechanism->mechanism) { + switch (pMechanism->mechanism) + { #ifndef WITH_FIPS - case CKM_DES_ECB: - if (keyType != CKK_DES) - return CKR_KEY_TYPE_INCONSISTENT; - algo = SymAlgo::DES; - mode = SymMode::ECB; - bb = 7; - break; - case CKM_DES_CBC: - if (keyType != CKK_DES) - return CKR_KEY_TYPE_INCONSISTENT; - algo = SymAlgo::DES; - mode = SymMode::CBC; - if (pMechanism->pParameter == NULL_PTR || - pMechanism->ulParameterLen == 0) - { - DEBUG_MSG("CBC mode requires an init vector"); - return CKR_ARGUMENTS_BAD; - } - iv.resize(pMechanism->ulParameterLen); - memcpy(&iv[0], pMechanism->pParameter, pMechanism->ulParameterLen); - bb = 7; - break; - case CKM_DES_CBC_PAD: - if (keyType != CKK_DES) - return CKR_KEY_TYPE_INCONSISTENT; - algo = SymAlgo::DES; - mode = SymMode::CBC; - padding = true; - if (pMechanism->pParameter == NULL_PTR || - pMechanism->ulParameterLen == 0) - { - DEBUG_MSG("CBC mode requires an init vector"); - return CKR_ARGUMENTS_BAD; - } - iv.resize(pMechanism->ulParameterLen); - memcpy(&iv[0], pMechanism->pParameter, pMechanism->ulParameterLen); - bb = 7; - break; + case CKM_DES_ECB: + if (keyType != CKK_DES) + return CKR_KEY_TYPE_INCONSISTENT; + algo = SymAlgo::DES; + mode = SymMode::ECB; + bb = 7; + break; + case CKM_DES_CBC: + if (keyType != CKK_DES) + return CKR_KEY_TYPE_INCONSISTENT; + algo = SymAlgo::DES; + mode = SymMode::CBC; + if (pMechanism->pParameter == NULL_PTR || + pMechanism->ulParameterLen == 0) + { + DEBUG_MSG("CBC mode requires an init vector"); + return CKR_ARGUMENTS_BAD; + } + iv.resize(pMechanism->ulParameterLen); + memcpy(&iv[0], pMechanism->pParameter, pMechanism->ulParameterLen); + bb = 7; + break; + case CKM_DES_CBC_PAD: + if (keyType != CKK_DES) + return CKR_KEY_TYPE_INCONSISTENT; + algo = SymAlgo::DES; + mode = SymMode::CBC; + padding = true; + if (pMechanism->pParameter == NULL_PTR || + pMechanism->ulParameterLen == 0) + { + DEBUG_MSG("CBC mode requires an init vector"); + return CKR_ARGUMENTS_BAD; + } + iv.resize(pMechanism->ulParameterLen); + memcpy(&iv[0], pMechanism->pParameter, pMechanism->ulParameterLen); + bb = 7; + break; #endif - case CKM_DES3_ECB: - if (keyType != CKK_DES2 && keyType != CKK_DES3) - return CKR_KEY_TYPE_INCONSISTENT; - algo = SymAlgo::DES3; - mode = SymMode::ECB; - bb = 7; - break; - case CKM_DES3_CBC: - if (keyType != CKK_DES2 && keyType != CKK_DES3) - return CKR_KEY_TYPE_INCONSISTENT; - algo = SymAlgo::DES3; - mode = SymMode::CBC; - if (pMechanism->pParameter == NULL_PTR || - pMechanism->ulParameterLen == 0) - { - DEBUG_MSG("CBC mode requires an init vector"); - return CKR_ARGUMENTS_BAD; - } - iv.resize(pMechanism->ulParameterLen); - memcpy(&iv[0], pMechanism->pParameter, pMechanism->ulParameterLen); - bb = 7; - break; - case CKM_DES3_CBC_PAD: - if (keyType != CKK_DES2 && keyType != CKK_DES3) - return CKR_KEY_TYPE_INCONSISTENT; - algo = SymAlgo::DES3; - mode = SymMode::CBC; - padding = true; - if (pMechanism->pParameter == NULL_PTR || - pMechanism->ulParameterLen == 0) - { - DEBUG_MSG("CBC mode requires an init vector"); - return CKR_ARGUMENTS_BAD; - } - iv.resize(pMechanism->ulParameterLen); - memcpy(&iv[0], pMechanism->pParameter, pMechanism->ulParameterLen); - bb = 7; - break; - case CKM_AES_ECB: - if (keyType != CKK_AES) - return CKR_KEY_TYPE_INCONSISTENT; - algo = SymAlgo::AES; - mode = SymMode::ECB; - break; - case CKM_AES_CBC: - if (keyType != CKK_AES) - return CKR_KEY_TYPE_INCONSISTENT; - algo = SymAlgo::AES; - mode = SymMode::CBC; - if (pMechanism->pParameter == NULL_PTR || - pMechanism->ulParameterLen == 0) - { - DEBUG_MSG("CBC mode requires an init vector"); - return CKR_ARGUMENTS_BAD; - } - iv.resize(pMechanism->ulParameterLen); - memcpy(&iv[0], pMechanism->pParameter, pMechanism->ulParameterLen); - break; - case CKM_AES_CBC_PAD: - if (keyType != CKK_AES) - return CKR_KEY_TYPE_INCONSISTENT; - algo = SymAlgo::AES; - mode = SymMode::CBC; - padding = true; - if (pMechanism->pParameter == NULL_PTR || - pMechanism->ulParameterLen == 0) - { - DEBUG_MSG("CBC mode requires an init vector"); - return CKR_ARGUMENTS_BAD; - } - iv.resize(pMechanism->ulParameterLen); - memcpy(&iv[0], pMechanism->pParameter, pMechanism->ulParameterLen); - break; - case CKM_AES_CTR: - if (keyType != CKK_AES) - return CKR_KEY_TYPE_INCONSISTENT; - algo = SymAlgo::AES; - mode = SymMode::CTR; - if (pMechanism->pParameter == NULL_PTR || - pMechanism->ulParameterLen != sizeof(CK_AES_CTR_PARAMS)) - { - DEBUG_MSG("CTR mode requires a counter block"); - return CKR_ARGUMENTS_BAD; - } - counterBits = CK_AES_CTR_PARAMS_PTR(pMechanism->pParameter)->ulCounterBits; - if (counterBits == 0 || counterBits > 128) - { - DEBUG_MSG("Invalid ulCounterBits"); - return CKR_MECHANISM_PARAM_INVALID; - } - iv.resize(16); - memcpy(&iv[0], CK_AES_CTR_PARAMS_PTR(pMechanism->pParameter)->cb, 16); - break; - case CKM_AES_GCM: - if (keyType != CKK_AES) - return CKR_KEY_TYPE_INCONSISTENT; - algo = SymAlgo::AES; - mode = SymMode::GCM; - if (pMechanism->pParameter == NULL_PTR || - pMechanism->ulParameterLen != sizeof(CK_GCM_PARAMS)) - { - DEBUG_MSG("GCM mode requires parameters"); - return CKR_ARGUMENTS_BAD; - } - iv.resize(CK_GCM_PARAMS_PTR(pMechanism->pParameter)->ulIvLen); - memcpy(&iv[0], CK_GCM_PARAMS_PTR(pMechanism->pParameter)->pIv, CK_GCM_PARAMS_PTR(pMechanism->pParameter)->ulIvLen); - aad.resize(CK_GCM_PARAMS_PTR(pMechanism->pParameter)->ulAADLen); - if (CK_GCM_PARAMS_PTR(pMechanism->pParameter)->ulAADLen > 0) - memcpy(&aad[0], CK_GCM_PARAMS_PTR(pMechanism->pParameter)->pAAD, CK_GCM_PARAMS_PTR(pMechanism->pParameter)->ulAADLen); - tagBytes = CK_GCM_PARAMS_PTR(pMechanism->pParameter)->ulTagBits; - if (tagBytes > 128 || tagBytes % 8 != 0) - { - DEBUG_MSG("Invalid ulTagBits value"); - return CKR_ARGUMENTS_BAD; - } - tagBytes = tagBytes / 8; - break; - default: - return CKR_MECHANISM_INVALID; + case CKM_DES3_ECB: + if (keyType != CKK_DES2 && keyType != CKK_DES3) + return CKR_KEY_TYPE_INCONSISTENT; + algo = SymAlgo::DES3; + mode = SymMode::ECB; + bb = 7; + break; + case CKM_DES3_CBC: + if (keyType != CKK_DES2 && keyType != CKK_DES3) + return CKR_KEY_TYPE_INCONSISTENT; + algo = SymAlgo::DES3; + mode = SymMode::CBC; + if (pMechanism->pParameter == NULL_PTR || + pMechanism->ulParameterLen == 0) + { + DEBUG_MSG("CBC mode requires an init vector"); + return CKR_ARGUMENTS_BAD; + } + iv.resize(pMechanism->ulParameterLen); + memcpy(&iv[0], pMechanism->pParameter, pMechanism->ulParameterLen); + bb = 7; + break; + case CKM_DES3_CBC_PAD: + if (keyType != CKK_DES2 && keyType != CKK_DES3) + return CKR_KEY_TYPE_INCONSISTENT; + algo = SymAlgo::DES3; + mode = SymMode::CBC; + padding = true; + if (pMechanism->pParameter == NULL_PTR || + pMechanism->ulParameterLen == 0) + { + DEBUG_MSG("CBC mode requires an init vector"); + return CKR_ARGUMENTS_BAD; + } + iv.resize(pMechanism->ulParameterLen); + memcpy(&iv[0], pMechanism->pParameter, pMechanism->ulParameterLen); + bb = 7; + break; + case CKM_AES_ECB: + if (keyType != CKK_AES) + return CKR_KEY_TYPE_INCONSISTENT; + algo = SymAlgo::AES; + mode = SymMode::ECB; + break; + case CKM_AES_CBC: + if (keyType != CKK_AES) + return CKR_KEY_TYPE_INCONSISTENT; + algo = SymAlgo::AES; + mode = SymMode::CBC; + if (pMechanism->pParameter == NULL_PTR || + pMechanism->ulParameterLen == 0) + { + DEBUG_MSG("CBC mode requires an init vector"); + return CKR_ARGUMENTS_BAD; + } + iv.resize(pMechanism->ulParameterLen); + memcpy(&iv[0], pMechanism->pParameter, pMechanism->ulParameterLen); + break; + case CKM_AES_CBC_PAD: + if (keyType != CKK_AES) + return CKR_KEY_TYPE_INCONSISTENT; + algo = SymAlgo::AES; + mode = SymMode::CBC; + padding = true; + if (pMechanism->pParameter == NULL_PTR || + pMechanism->ulParameterLen == 0) + { + DEBUG_MSG("CBC mode requires an init vector"); + return CKR_ARGUMENTS_BAD; + } + iv.resize(pMechanism->ulParameterLen); + memcpy(&iv[0], pMechanism->pParameter, pMechanism->ulParameterLen); + break; + case CKM_AES_CTR: + if (keyType != CKK_AES) + return CKR_KEY_TYPE_INCONSISTENT; + algo = SymAlgo::AES; + mode = SymMode::CTR; + if (pMechanism->pParameter == NULL_PTR || + pMechanism->ulParameterLen != sizeof(CK_AES_CTR_PARAMS)) + { + DEBUG_MSG("CTR mode requires a counter block"); + return CKR_ARGUMENTS_BAD; + } + counterBits = CK_AES_CTR_PARAMS_PTR(pMechanism->pParameter)->ulCounterBits; + if (counterBits == 0 || counterBits > 128) + { + DEBUG_MSG("Invalid ulCounterBits"); + return CKR_MECHANISM_PARAM_INVALID; + } + iv.resize(16); + memcpy(&iv[0], CK_AES_CTR_PARAMS_PTR(pMechanism->pParameter)->cb, 16); + break; + case CKM_AES_GCM: + if (keyType != CKK_AES) + return CKR_KEY_TYPE_INCONSISTENT; + algo = SymAlgo::AES; + mode = SymMode::GCM; + if (pMechanism->pParameter == NULL_PTR || + pMechanism->ulParameterLen != sizeof(CK_GCM_PARAMS)) + { + DEBUG_MSG("GCM mode requires parameters"); + return CKR_ARGUMENTS_BAD; + } + iv.resize(CK_GCM_PARAMS_PTR(pMechanism->pParameter)->ulIvLen); + memcpy(&iv[0], CK_GCM_PARAMS_PTR(pMechanism->pParameter)->pIv, CK_GCM_PARAMS_PTR(pMechanism->pParameter)->ulIvLen); + aad.resize(CK_GCM_PARAMS_PTR(pMechanism->pParameter)->ulAADLen); + if (CK_GCM_PARAMS_PTR(pMechanism->pParameter)->ulAADLen > 0) + memcpy(&aad[0], CK_GCM_PARAMS_PTR(pMechanism->pParameter)->pAAD, CK_GCM_PARAMS_PTR(pMechanism->pParameter)->ulAADLen); + tagBytes = CK_GCM_PARAMS_PTR(pMechanism->pParameter)->ulTagBits; + if (tagBytes > 128 || tagBytes % 8 != 0) + { + DEBUG_MSG("Invalid ulTagBits value"); + return CKR_ARGUMENTS_BAD; + } + tagBytes = tagBytes / 8; + break; + default: + return CKR_MECHANISM_INVALID; } - SymmetricAlgorithm* cipher = CryptoFactory::i()->getSymmetricAlgorithm(algo); - if (cipher == NULL) return CKR_MECHANISM_INVALID; + SymmetricAlgorithm *cipher = CryptoFactory::i()->getSymmetricAlgorithm(algo); + if (cipher == NULL) + return CKR_MECHANISM_INVALID; - SymmetricKey* secretkey = new SymmetricKey(); + SymmetricKey *secretkey = new SymmetricKey(); if (getSymmetricKey(secretkey, token, key) != CKR_OK) { @@ -2418,24 +2536,30 @@ CK_RV SoftHSM::SymEncryptInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMech // AsymAlgorithm version of C_EncryptInit CK_RV SoftHSM::AsymEncryptInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechanism, CK_OBJECT_HANDLE hKey) { - if (!isInitialised) return CKR_CRYPTOKI_NOT_INITIALIZED; + if (!isInitialised) + return CKR_CRYPTOKI_NOT_INITIALIZED; - if (pMechanism == NULL_PTR) return CKR_ARGUMENTS_BAD; + if (pMechanism == NULL_PTR) + return CKR_ARGUMENTS_BAD; // Get the session - Session* session = (Session*)handleManager->getSession(hSession); - if (session == NULL) return CKR_SESSION_HANDLE_INVALID; + Session *session = (Session *)handleManager->getSession(hSession); + if (session == NULL) + return CKR_SESSION_HANDLE_INVALID; // Check if we have another operation - if (session->getOpType() != SESSION_OP_NONE) return CKR_OPERATION_ACTIVE; + if (session->getOpType() != SESSION_OP_NONE) + return CKR_OPERATION_ACTIVE; // Get the token - Token* token = session->getToken(); - if (token == NULL) return CKR_GENERAL_ERROR; + Token *token = session->getToken(); + if (token == NULL) + return CKR_GENERAL_ERROR; // Check the key handle. OSObject *key = (OSObject *)handleManager->getObject(hKey); - if (key == NULL_PTR || !key->isValid()) return CKR_OBJECT_HANDLE_INVALID; + if (key == NULL_PTR || !key->isValid()) + return CKR_OBJECT_HANDLE_INVALID; CK_BBOOL isOnToken = key->getBooleanValue(CKA_TOKEN, false); CK_BBOOL isPrivate = key->getBooleanValue(CKA_PRIVATE, true); @@ -2460,39 +2584,41 @@ 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; - switch(pMechanism->mechanism) { - case CKM_RSA_PKCS: - if (keyType != CKK_RSA) - return CKR_KEY_TYPE_INCONSISTENT; - mechanism = AsymMech::RSA_PKCS; - isRSA = true; - break; - case CKM_RSA_X_509: - if (keyType != CKK_RSA) - return CKR_KEY_TYPE_INCONSISTENT; - mechanism = AsymMech::RSA; - isRSA = true; - break; - case CKM_RSA_PKCS_OAEP: - if (keyType != CKK_RSA) - return CKR_KEY_TYPE_INCONSISTENT; - rv = MechParamCheckRSAPKCSOAEP(pMechanism); - if (rv != CKR_OK) - return rv; + switch (pMechanism->mechanism) + { + case CKM_RSA_PKCS: + if (keyType != CKK_RSA) + return CKR_KEY_TYPE_INCONSISTENT; + mechanism = AsymMech::RSA_PKCS; + isRSA = true; + break; + case CKM_RSA_X_509: + if (keyType != CKK_RSA) + return CKR_KEY_TYPE_INCONSISTENT; + mechanism = AsymMech::RSA; + isRSA = true; + break; + case CKM_RSA_PKCS_OAEP: + if (keyType != CKK_RSA) + return CKR_KEY_TYPE_INCONSISTENT; + rv = MechParamCheckRSAPKCSOAEP(pMechanism); + if (rv != CKR_OK) + return rv; - mechanism = AsymMech::RSA_PKCS_OAEP; - isRSA = true; - break; - default: - return CKR_MECHANISM_INVALID; + mechanism = AsymMech::RSA_PKCS_OAEP; + isRSA = true; + break; + default: + return CKR_MECHANISM_INVALID; } - AsymmetricAlgorithm* asymCrypto = NULL; - PublicKey* publicKey = NULL; + AsymmetricAlgorithm *asymCrypto = NULL; + PublicKey *publicKey = NULL; if (isRSA) { asymCrypto = CryptoFactory::i()->getAsymmetricAlgorithm(AsymAlgo::RSA); - if (asymCrypto == NULL) return CKR_MECHANISM_INVALID; + if (asymCrypto == NULL) + return CKR_MECHANISM_INVALID; publicKey = asymCrypto->newPublicKey(); if (publicKey == NULL) @@ -2501,7 +2627,7 @@ CK_RV SoftHSM::AsymEncryptInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMec return CKR_HOST_MEMORY; } - if (getRSAPublicKey((RSAPublicKey*)publicKey, token, key) != CKR_OK) + if (getRSAPublicKey((RSAPublicKey *)publicKey, token, key) != CKR_OK) { asymCrypto->recyclePublicKey(publicKey); CryptoFactory::i()->recycleAsymmetricAlgorithm(asymCrypto); @@ -2510,74 +2636,22 @@ CK_RV SoftHSM::AsymEncryptInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMec } else { - return CKR_MECHANISM_INVALID; - } + return CKR_MECHANISM_INVALID; + } // set mechanism parameters - void *parameters = NULL; + void *parameters = NULL; size_t paramLen = 0; - RSA_PKCS_OAEP_PARAMS oaep_param; if (pMechanism->mechanism == CKM_RSA_PKCS_OAEP) { - CK_RSA_PKCS_OAEP_PARAMS* par1 = (CK_RSA_PKCS_OAEP_PARAMS*) pMechanism->pParameter; - switch (par1->hashAlg) - { - case CKM_SHA_1: - oaep_param.hashAlg = HashAlgo::SHA1; - break; - case CKM_SHA224: - oaep_param.hashAlg = HashAlgo::SHA224; - break; - case CKM_SHA256: - oaep_param.hashAlg = HashAlgo::SHA256; - break; - case CKM_SHA384: - oaep_param.hashAlg = HashAlgo::SHA384; - break; - case CKM_SHA512: - oaep_param.hashAlg = HashAlgo::SHA512; - break; - default: - asymCrypto->recyclePublicKey(publicKey); - CryptoFactory::i()->recycleAsymmetricAlgorithm(asymCrypto); - return CKR_ARGUMENTS_BAD; - } - switch (par1->mgf) - { - case CKG_MGF1_SHA1: - oaep_param.mgf = AsymRSAMGF::MGF1_SHA1; - break; - case CKG_MGF1_SHA224: - oaep_param.mgf = AsymRSAMGF::MGF1_SHA224; - break; - case CKG_MGF1_SHA256: - oaep_param.mgf = AsymRSAMGF::MGF1_SHA256; - break; - case CKG_MGF1_SHA384: - oaep_param.mgf = AsymRSAMGF::MGF1_SHA384; - break; - case CKG_MGF1_SHA512: - oaep_param.mgf = AsymRSAMGF::MGF1_SHA512; - break; - default: - asymCrypto->recyclePublicKey(publicKey); - CryptoFactory::i()->recycleAsymmetricAlgorithm(asymCrypto); - return CKR_ARGUMENTS_BAD; - } - // need copy parameters to session context - // label source data will be copyed to end of parameter block - paramLen = sizeof(RSA_PKCS_OAEP_PARAMS) + par1->ulSourceDataLen; - parameters = malloc(paramLen); - if (parameters == NULL) + rv = BuildRSAOAEPParam((CK_RSA_PKCS_OAEP_PARAMS *)pMechanism->pParameter, + ¶meters, ¶mLen); + if (rv != CKR_OK) { asymCrypto->recyclePublicKey(publicKey); CryptoFactory::i()->recycleAsymmetricAlgorithm(asymCrypto); - return CKR_HOST_MEMORY; + return rv; } - oaep_param.sourceData = (char*)parameters + sizeof(RSA_PKCS_OAEP_PARAMS); - oaep_param.sourceDataLen = par1->ulSourceDataLen; - memcpy(parameters,&oaep_param,sizeof(RSA_PKCS_OAEP_PARAMS)); - memcpy(oaep_param.sourceData,par1->pSourceData,par1->ulSourceDataLen); - } + } session->setOpType(SESSION_OP_ENCRYPT); session->setAsymmetricCryptoOp(asymCrypto); @@ -2603,9 +2677,9 @@ CK_RV SoftHSM::C_EncryptInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMecha } // SymAlgorithm version of C_Encrypt -static CK_RV SymEncrypt(Session* session, CK_BYTE_PTR pData, CK_ULONG ulDataLen, CK_BYTE_PTR pEncryptedData, CK_ULONG_PTR pulEncryptedDataLen) +static CK_RV SymEncrypt(Session *session, CK_BYTE_PTR pData, CK_ULONG ulDataLen, CK_BYTE_PTR pEncryptedData, CK_ULONG_PTR pulEncryptedDataLen) { - SymmetricAlgorithm* cipher = session->getSymmetricCryptoOp(); + SymmetricAlgorithm *cipher = session->getSymmetricCryptoOp(); if (cipher == NULL || !session->getAllowSinglePartOp()) { session->resetOp(); @@ -2681,13 +2755,13 @@ static CK_RV SymEncrypt(Session* session, CK_BYTE_PTR pData, CK_ULONG ulDataLen, } // AsymAlgorithm version of C_Encrypt -static CK_RV AsymEncrypt(Session* session, CK_BYTE_PTR pData, CK_ULONG ulDataLen, CK_BYTE_PTR pEncryptedData, CK_ULONG_PTR pulEncryptedDataLen) +static CK_RV AsymEncrypt(Session *session, CK_BYTE_PTR pData, CK_ULONG ulDataLen, CK_BYTE_PTR pEncryptedData, CK_ULONG_PTR pulEncryptedDataLen) { - AsymmetricAlgorithm* asymCrypto = session->getAsymmetricCryptoOp(); + AsymmetricAlgorithm *asymCrypto = session->getAsymmetricCryptoOp(); AsymMech::Type mechanism = session->getMechanism(); - PublicKey* publicKey = session->getPublicKey(); + PublicKey *publicKey = session->getPublicKey(); size_t paramLen = 0; - void* parameters = session->getParameters(paramLen); + void *parameters = session->getParameters(paramLen); if (asymCrypto == NULL || !session->getAllowSinglePartOp() || publicKey == NULL) { session->resetOp(); @@ -2715,14 +2789,15 @@ static CK_RV AsymEncrypt(Session* session, CK_BYTE_PTR pData, CK_ULONG ulDataLen ByteString encryptedData; // We must allow input length <= k and therfore need to prepend the data with zeroes. - if (mechanism == AsymMech::RSA) { - data.wipe(size-ulDataLen); + if (mechanism == AsymMech::RSA) + { + data.wipe(size - ulDataLen); } data += ByteString(pData, ulDataLen); - // Encrypt the data - if (!asymCrypto->encrypt(publicKey,data,encryptedData,mechanism, parameters, paramLen)) + // Encrypt the data + if (!asymCrypto->encrypt(publicKey, data, encryptedData, mechanism, parameters, paramLen)) { session->resetOp(); return CKR_GENERAL_ERROR; @@ -2745,11 +2820,13 @@ static CK_RV AsymEncrypt(Session* session, CK_BYTE_PTR pData, CK_ULONG ulDataLen // Perform a single operation encryption operation in the specified session CK_RV SoftHSM::C_Encrypt(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pData, CK_ULONG ulDataLen, CK_BYTE_PTR pEncryptedData, CK_ULONG_PTR pulEncryptedDataLen) { - if (!isInitialised) return CKR_CRYPTOKI_NOT_INITIALIZED; + if (!isInitialised) + return CKR_CRYPTOKI_NOT_INITIALIZED; // Get the session - Session* session = (Session*)handleManager->getSession(hSession); - if (session == NULL) return CKR_SESSION_HANDLE_INVALID; + Session *session = (Session *)handleManager->getSession(hSession); + if (session == NULL) + return CKR_SESSION_HANDLE_INVALID; if ((pData == NULL_PTR) || (pulEncryptedDataLen == NULL_PTR)) { @@ -2765,16 +2842,16 @@ CK_RV SoftHSM::C_Encrypt(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pData, CK_ULONG if (session->getSymmetricCryptoOp() != NULL) return SymEncrypt(session, pData, ulDataLen, - pEncryptedData, pulEncryptedDataLen); + pEncryptedData, pulEncryptedDataLen); else return AsymEncrypt(session, pData, ulDataLen, - pEncryptedData, pulEncryptedDataLen); + pEncryptedData, pulEncryptedDataLen); } // SymAlgorithm version of C_EncryptUpdate -static CK_RV SymEncryptUpdate(Session* session, CK_BYTE_PTR pData, CK_ULONG ulDataLen, CK_BYTE_PTR pEncryptedData, CK_ULONG_PTR pulEncryptedDataLen) +static CK_RV SymEncryptUpdate(Session *session, CK_BYTE_PTR pData, CK_ULONG ulDataLen, CK_BYTE_PTR pEncryptedData, CK_ULONG_PTR pulEncryptedDataLen) { - SymmetricAlgorithm* cipher = session->getSymmetricCryptoOp(); + SymmetricAlgorithm *cipher = session->getSymmetricCryptoOp(); if (cipher == NULL || !session->getAllowMultiPartOp()) { session->resetOp(); @@ -2807,7 +2884,7 @@ static CK_RV SymEncryptUpdate(Session* session, CK_BYTE_PTR pData, CK_ULONG ulDa if (*pulEncryptedDataLen < maxSize) { DEBUG_MSG("ulDataLen: %#5x output buffer size: %#5x blockSize: %#3x remainingSize: %#4x maxSize: %#5x", - ulDataLen, *pulEncryptedDataLen, blockSize, remainingSize, maxSize); + ulDataLen, *pulEncryptedDataLen, blockSize, remainingSize, maxSize); *pulEncryptedDataLen = maxSize; return CKR_BUFFER_TOO_SMALL; } @@ -2823,14 +2900,14 @@ static CK_RV SymEncryptUpdate(Session* session, CK_BYTE_PTR pData, CK_ULONG ulDa return CKR_GENERAL_ERROR; } DEBUG_MSG("ulDataLen: %#5x output buffer size: %#5x blockSize: %#3x remainingSize: %#4x maxSize: %#5x encryptedData.size(): %#5x", - ulDataLen, *pulEncryptedDataLen, blockSize, remainingSize, maxSize, encryptedData.size()); + ulDataLen, *pulEncryptedDataLen, blockSize, remainingSize, maxSize, encryptedData.size()); // Check output size from crypto. Unrecoverable error if to large. if (*pulEncryptedDataLen < encryptedData.size()) { session->resetOp(); ERROR_MSG("EncryptUpdate returning too much data. Length of output data buffer is %i but %i bytes was returned by the encrypt.", - *pulEncryptedDataLen, encryptedData.size()); + *pulEncryptedDataLen, encryptedData.size()); return CKR_GENERAL_ERROR; } @@ -2846,11 +2923,13 @@ static CK_RV SymEncryptUpdate(Session* session, CK_BYTE_PTR pData, CK_ULONG ulDa // Feed data to the running encryption operation in a session CK_RV SoftHSM::C_EncryptUpdate(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pData, CK_ULONG ulDataLen, CK_BYTE_PTR pEncryptedData, CK_ULONG_PTR pulEncryptedDataLen) { - if (!isInitialised) return CKR_CRYPTOKI_NOT_INITIALIZED; + if (!isInitialised) + return CKR_CRYPTOKI_NOT_INITIALIZED; // Get the session - Session* session = (Session*)handleManager->getSession(hSession); - if (session == NULL) return CKR_SESSION_HANDLE_INVALID; + Session *session = (Session *)handleManager->getSession(hSession); + if (session == NULL) + return CKR_SESSION_HANDLE_INVALID; if ((pData == NULL_PTR) || (pulEncryptedDataLen == NULL_PTR)) { @@ -2865,15 +2944,15 @@ CK_RV SoftHSM::C_EncryptUpdate(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pData, CK if (session->getSymmetricCryptoOp() != NULL) return SymEncryptUpdate(session, pData, ulDataLen, - pEncryptedData, pulEncryptedDataLen); + pEncryptedData, pulEncryptedDataLen); else return CKR_FUNCTION_NOT_SUPPORTED; } // SymAlgorithm version of C_EncryptFinal -static CK_RV SymEncryptFinal(Session* session, CK_BYTE_PTR pEncryptedData, CK_ULONG_PTR pulEncryptedDataLen) +static CK_RV SymEncryptFinal(Session *session, CK_BYTE_PTR pEncryptedData, CK_ULONG_PTR pulEncryptedDataLen) { - SymmetricAlgorithm* cipher = session->getSymmetricCryptoOp(); + SymmetricAlgorithm *cipher = session->getSymmetricCryptoOp(); if (cipher == NULL || !session->getAllowMultiPartOp()) { session->resetOp(); @@ -2891,7 +2970,7 @@ static CK_RV SymEncryptFinal(Session* session, CK_BYTE_PTR pEncryptedData, CK_UL { session->resetOp(); DEBUG_MSG("Remaining buffer size is not an integral of the block size. Block size: %#2x Remaining size: %#2x", - blockSize, remainingSize); + blockSize, remainingSize); return CKR_DATA_LEN_RANGE; } // when padding: an integral of the block size that is longer than the remaining data. @@ -2909,7 +2988,7 @@ static CK_RV SymEncryptFinal(Session* session, CK_BYTE_PTR pEncryptedData, CK_UL if (*pulEncryptedDataLen < size) { DEBUG_MSG("output buffer size: %#5x size: %#5x", - *pulEncryptedDataLen, size); + *pulEncryptedDataLen, size); *pulEncryptedDataLen = size; return CKR_BUFFER_TOO_SMALL; } @@ -2922,14 +3001,14 @@ static CK_RV SymEncryptFinal(Session* session, CK_BYTE_PTR pEncryptedData, CK_UL return CKR_GENERAL_ERROR; } DEBUG_MSG("output buffer size: %#2x size: %#2x encryptedFinal.size(): %#2x", - *pulEncryptedDataLen, size, encryptedFinal.size()); + *pulEncryptedDataLen, size, encryptedFinal.size()); // Check output size from crypto. Unrecoverable error if to large. if (*pulEncryptedDataLen < encryptedFinal.size()) { session->resetOp(); ERROR_MSG("EncryptFinal returning too much data. Length of output data buffer is %i but %i bytes was returned by the encrypt.", - *pulEncryptedDataLen, encryptedFinal.size()); + *pulEncryptedDataLen, encryptedFinal.size()); return CKR_GENERAL_ERROR; } @@ -2946,11 +3025,13 @@ static CK_RV SymEncryptFinal(Session* session, CK_BYTE_PTR pEncryptedData, CK_UL // Finalise the encryption operation CK_RV SoftHSM::C_EncryptFinal(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pEncryptedData, CK_ULONG_PTR pulEncryptedDataLen) { - if (!isInitialised) return CKR_CRYPTOKI_NOT_INITIALIZED; + if (!isInitialised) + return CKR_CRYPTOKI_NOT_INITIALIZED; // Get the session - Session* session = (Session*)handleManager->getSession(hSession); - if (session == NULL) return CKR_SESSION_HANDLE_INVALID; + Session *session = (Session *)handleManager->getSession(hSession); + if (session == NULL) + return CKR_SESSION_HANDLE_INVALID; // Github issue #469, check NULL_PTR on pulEncryptedDataLen if (pulEncryptedDataLen == NULL) @@ -2960,7 +3041,8 @@ CK_RV SoftHSM::C_EncryptFinal(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pEncrypted } // Check if we are doing the correct operation - if (session->getOpType() != SESSION_OP_ENCRYPT) return CKR_OPERATION_NOT_INITIALIZED; + if (session->getOpType() != SESSION_OP_ENCRYPT) + return CKR_OPERATION_NOT_INITIALIZED; if (session->getSymmetricCryptoOp() != NULL) return SymEncryptFinal(session, pEncryptedData, pulEncryptedDataLen); @@ -2971,24 +3053,30 @@ CK_RV SoftHSM::C_EncryptFinal(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pEncrypted // SymAlgorithm version of C_DecryptInit CK_RV SoftHSM::SymDecryptInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechanism, CK_OBJECT_HANDLE hKey) { - if (!isInitialised) return CKR_CRYPTOKI_NOT_INITIALIZED; + if (!isInitialised) + return CKR_CRYPTOKI_NOT_INITIALIZED; - if (pMechanism == NULL_PTR) return CKR_ARGUMENTS_BAD; + if (pMechanism == NULL_PTR) + return CKR_ARGUMENTS_BAD; // Get the session - Session* session = (Session*)handleManager->getSession(hSession); - if (session == NULL) return CKR_SESSION_HANDLE_INVALID; + Session *session = (Session *)handleManager->getSession(hSession); + if (session == NULL) + return CKR_SESSION_HANDLE_INVALID; // Get the token - Token* token = session->getToken(); - if (token == NULL) return CKR_GENERAL_ERROR; + Token *token = session->getToken(); + if (token == NULL) + return CKR_GENERAL_ERROR; // Check if we have another operation - if (session->getOpType() != SESSION_OP_NONE) return CKR_OPERATION_ACTIVE; + if (session->getOpType() != SESSION_OP_NONE) + return CKR_OPERATION_ACTIVE; // Check the key handle. OSObject *key = (OSObject *)handleManager->getObject(hKey); - if (key == NULL_PTR || !key->isValid()) return CKR_OBJECT_HANDLE_INVALID; + if (key == NULL_PTR || !key->isValid()) + return CKR_OBJECT_HANDLE_INVALID; CK_BBOOL isOnToken = key->getBooleanValue(CKA_TOKEN, false); CK_BBOOL isPrivate = key->getBooleanValue(CKA_PRIVATE, true); @@ -3007,7 +3095,6 @@ CK_RV SoftHSM::SymDecryptInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMech if (!key->getBooleanValue(CKA_DECRYPT, false)) return CKR_KEY_FUNCTION_NOT_PERMITTED; - // Check if the specified mechanism is allowed for the key if (!isMechanismPermitted(key, pMechanism->mechanism)) return CKR_MECHANISM_INVALID; @@ -3024,171 +3111,173 @@ CK_RV SoftHSM::SymDecryptInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMech size_t counterBits = 0; ByteString aad; size_t tagBytes = 0; - switch(pMechanism->mechanism) { + switch (pMechanism->mechanism) + { #ifndef WITH_FIPS - case CKM_DES_ECB: - if (keyType != CKK_DES) - return CKR_KEY_TYPE_INCONSISTENT; - algo = SymAlgo::DES; - mode = SymMode::ECB; - bb = 7; - break; - case CKM_DES_CBC: - if (keyType != CKK_DES) - return CKR_KEY_TYPE_INCONSISTENT; - algo = SymAlgo::DES; - mode = SymMode::CBC; - if (pMechanism->pParameter == NULL_PTR || - pMechanism->ulParameterLen == 0) - { - DEBUG_MSG("CBC mode requires an init vector"); - return CKR_ARGUMENTS_BAD; - } - iv.resize(pMechanism->ulParameterLen); - memcpy(&iv[0], pMechanism->pParameter, pMechanism->ulParameterLen); - bb = 7; - break; - case CKM_DES_CBC_PAD: - if (keyType != CKK_DES) - return CKR_KEY_TYPE_INCONSISTENT; - algo = SymAlgo::DES; - mode = SymMode::CBC; - padding = true; - if (pMechanism->pParameter == NULL_PTR || - pMechanism->ulParameterLen == 0) - { - DEBUG_MSG("CBC mode requires an init vector"); - return CKR_ARGUMENTS_BAD; - } - iv.resize(pMechanism->ulParameterLen); - memcpy(&iv[0], pMechanism->pParameter, pMechanism->ulParameterLen); - bb = 7; - break; + case CKM_DES_ECB: + if (keyType != CKK_DES) + return CKR_KEY_TYPE_INCONSISTENT; + algo = SymAlgo::DES; + mode = SymMode::ECB; + bb = 7; + break; + case CKM_DES_CBC: + if (keyType != CKK_DES) + return CKR_KEY_TYPE_INCONSISTENT; + algo = SymAlgo::DES; + mode = SymMode::CBC; + if (pMechanism->pParameter == NULL_PTR || + pMechanism->ulParameterLen == 0) + { + DEBUG_MSG("CBC mode requires an init vector"); + return CKR_ARGUMENTS_BAD; + } + iv.resize(pMechanism->ulParameterLen); + memcpy(&iv[0], pMechanism->pParameter, pMechanism->ulParameterLen); + bb = 7; + break; + case CKM_DES_CBC_PAD: + if (keyType != CKK_DES) + return CKR_KEY_TYPE_INCONSISTENT; + algo = SymAlgo::DES; + mode = SymMode::CBC; + padding = true; + if (pMechanism->pParameter == NULL_PTR || + pMechanism->ulParameterLen == 0) + { + DEBUG_MSG("CBC mode requires an init vector"); + return CKR_ARGUMENTS_BAD; + } + iv.resize(pMechanism->ulParameterLen); + memcpy(&iv[0], pMechanism->pParameter, pMechanism->ulParameterLen); + bb = 7; + break; #endif - case CKM_DES3_ECB: - if (keyType != CKK_DES2 && keyType != CKK_DES3) - return CKR_KEY_TYPE_INCONSISTENT; - algo = SymAlgo::DES3; - mode = SymMode::ECB; - bb = 7; - break; - case CKM_DES3_CBC: - if (keyType != CKK_DES2 && keyType != CKK_DES3) - return CKR_KEY_TYPE_INCONSISTENT; - algo = SymAlgo::DES3; - mode = SymMode::CBC; - if (pMechanism->pParameter == NULL_PTR || - pMechanism->ulParameterLen == 0) - { - DEBUG_MSG("CBC mode requires an init vector"); - return CKR_ARGUMENTS_BAD; - } - iv.resize(pMechanism->ulParameterLen); - memcpy(&iv[0], pMechanism->pParameter, pMechanism->ulParameterLen); - bb = 7; - break; - case CKM_DES3_CBC_PAD: - if (keyType != CKK_DES2 && keyType != CKK_DES3) - return CKR_KEY_TYPE_INCONSISTENT; - algo = SymAlgo::DES3; - mode = SymMode::CBC; - padding = true; - if (pMechanism->pParameter == NULL_PTR || - pMechanism->ulParameterLen == 0) - { - DEBUG_MSG("CBC mode requires an init vector"); - return CKR_ARGUMENTS_BAD; - } - iv.resize(pMechanism->ulParameterLen); - memcpy(&iv[0], pMechanism->pParameter, pMechanism->ulParameterLen); - bb = 7; - break; - case CKM_AES_ECB: - if (keyType != CKK_AES) - return CKR_KEY_TYPE_INCONSISTENT; - algo = SymAlgo::AES; - mode = SymMode::ECB; - break; - case CKM_AES_CBC: - if (keyType != CKK_AES) - return CKR_KEY_TYPE_INCONSISTENT; - algo = SymAlgo::AES; - mode = SymMode::CBC; - if (pMechanism->pParameter == NULL_PTR || - pMechanism->ulParameterLen == 0) - { - DEBUG_MSG("CBC mode requires an init vector"); - return CKR_ARGUMENTS_BAD; - } - iv.resize(pMechanism->ulParameterLen); - memcpy(&iv[0], pMechanism->pParameter, pMechanism->ulParameterLen); - break; - case CKM_AES_CBC_PAD: - if (keyType != CKK_AES) - return CKR_KEY_TYPE_INCONSISTENT; - algo = SymAlgo::AES; - mode = SymMode::CBC; - padding = true; - if (pMechanism->pParameter == NULL_PTR || - pMechanism->ulParameterLen == 0) - { - DEBUG_MSG("CBC mode requires an init vector"); - return CKR_ARGUMENTS_BAD; - } - iv.resize(pMechanism->ulParameterLen); - memcpy(&iv[0], pMechanism->pParameter, pMechanism->ulParameterLen); - break; - case CKM_AES_CTR: - if (keyType != CKK_AES) - return CKR_KEY_TYPE_INCONSISTENT; - algo = SymAlgo::AES; - mode = SymMode::CTR; - if (pMechanism->pParameter == NULL_PTR || - pMechanism->ulParameterLen != sizeof(CK_AES_CTR_PARAMS)) - { - DEBUG_MSG("CTR mode requires a counter block"); - return CKR_ARGUMENTS_BAD; - } - counterBits = CK_AES_CTR_PARAMS_PTR(pMechanism->pParameter)->ulCounterBits; - if (counterBits == 0 || counterBits > 128) - { - DEBUG_MSG("Invalid ulCounterBits"); - return CKR_MECHANISM_PARAM_INVALID; - } - iv.resize(16); - memcpy(&iv[0], CK_AES_CTR_PARAMS_PTR(pMechanism->pParameter)->cb, 16); - break; - case CKM_AES_GCM: - if (keyType != CKK_AES) - return CKR_KEY_TYPE_INCONSISTENT; - algo = SymAlgo::AES; - mode = SymMode::GCM; - if (pMechanism->pParameter == NULL_PTR || - pMechanism->ulParameterLen != sizeof(CK_GCM_PARAMS)) - { - DEBUG_MSG("GCM mode requires parameters"); - return CKR_ARGUMENTS_BAD; - } - iv.resize(CK_GCM_PARAMS_PTR(pMechanism->pParameter)->ulIvLen); - memcpy(&iv[0], CK_GCM_PARAMS_PTR(pMechanism->pParameter)->pIv, CK_GCM_PARAMS_PTR(pMechanism->pParameter)->ulIvLen); - aad.resize(CK_GCM_PARAMS_PTR(pMechanism->pParameter)->ulAADLen); - if (CK_GCM_PARAMS_PTR(pMechanism->pParameter)->ulAADLen > 0) - memcpy(&aad[0], CK_GCM_PARAMS_PTR(pMechanism->pParameter)->pAAD, CK_GCM_PARAMS_PTR(pMechanism->pParameter)->ulAADLen); - tagBytes = CK_GCM_PARAMS_PTR(pMechanism->pParameter)->ulTagBits; - if (tagBytes > 128 || tagBytes % 8 != 0) - { - DEBUG_MSG("Invalid ulTagBits value"); - return CKR_ARGUMENTS_BAD; - } - tagBytes = tagBytes / 8; - break; - default: - return CKR_MECHANISM_INVALID; + case CKM_DES3_ECB: + if (keyType != CKK_DES2 && keyType != CKK_DES3) + return CKR_KEY_TYPE_INCONSISTENT; + algo = SymAlgo::DES3; + mode = SymMode::ECB; + bb = 7; + break; + case CKM_DES3_CBC: + if (keyType != CKK_DES2 && keyType != CKK_DES3) + return CKR_KEY_TYPE_INCONSISTENT; + algo = SymAlgo::DES3; + mode = SymMode::CBC; + if (pMechanism->pParameter == NULL_PTR || + pMechanism->ulParameterLen == 0) + { + DEBUG_MSG("CBC mode requires an init vector"); + return CKR_ARGUMENTS_BAD; + } + iv.resize(pMechanism->ulParameterLen); + memcpy(&iv[0], pMechanism->pParameter, pMechanism->ulParameterLen); + bb = 7; + break; + case CKM_DES3_CBC_PAD: + if (keyType != CKK_DES2 && keyType != CKK_DES3) + return CKR_KEY_TYPE_INCONSISTENT; + algo = SymAlgo::DES3; + mode = SymMode::CBC; + padding = true; + if (pMechanism->pParameter == NULL_PTR || + pMechanism->ulParameterLen == 0) + { + DEBUG_MSG("CBC mode requires an init vector"); + return CKR_ARGUMENTS_BAD; + } + iv.resize(pMechanism->ulParameterLen); + memcpy(&iv[0], pMechanism->pParameter, pMechanism->ulParameterLen); + bb = 7; + break; + case CKM_AES_ECB: + if (keyType != CKK_AES) + return CKR_KEY_TYPE_INCONSISTENT; + algo = SymAlgo::AES; + mode = SymMode::ECB; + break; + case CKM_AES_CBC: + if (keyType != CKK_AES) + return CKR_KEY_TYPE_INCONSISTENT; + algo = SymAlgo::AES; + mode = SymMode::CBC; + if (pMechanism->pParameter == NULL_PTR || + pMechanism->ulParameterLen == 0) + { + DEBUG_MSG("CBC mode requires an init vector"); + return CKR_ARGUMENTS_BAD; + } + iv.resize(pMechanism->ulParameterLen); + memcpy(&iv[0], pMechanism->pParameter, pMechanism->ulParameterLen); + break; + case CKM_AES_CBC_PAD: + if (keyType != CKK_AES) + return CKR_KEY_TYPE_INCONSISTENT; + algo = SymAlgo::AES; + mode = SymMode::CBC; + padding = true; + if (pMechanism->pParameter == NULL_PTR || + pMechanism->ulParameterLen == 0) + { + DEBUG_MSG("CBC mode requires an init vector"); + return CKR_ARGUMENTS_BAD; + } + iv.resize(pMechanism->ulParameterLen); + memcpy(&iv[0], pMechanism->pParameter, pMechanism->ulParameterLen); + break; + case CKM_AES_CTR: + if (keyType != CKK_AES) + return CKR_KEY_TYPE_INCONSISTENT; + algo = SymAlgo::AES; + mode = SymMode::CTR; + if (pMechanism->pParameter == NULL_PTR || + pMechanism->ulParameterLen != sizeof(CK_AES_CTR_PARAMS)) + { + DEBUG_MSG("CTR mode requires a counter block"); + return CKR_ARGUMENTS_BAD; + } + counterBits = CK_AES_CTR_PARAMS_PTR(pMechanism->pParameter)->ulCounterBits; + if (counterBits == 0 || counterBits > 128) + { + DEBUG_MSG("Invalid ulCounterBits"); + return CKR_MECHANISM_PARAM_INVALID; + } + iv.resize(16); + memcpy(&iv[0], CK_AES_CTR_PARAMS_PTR(pMechanism->pParameter)->cb, 16); + break; + case CKM_AES_GCM: + if (keyType != CKK_AES) + return CKR_KEY_TYPE_INCONSISTENT; + algo = SymAlgo::AES; + mode = SymMode::GCM; + if (pMechanism->pParameter == NULL_PTR || + pMechanism->ulParameterLen != sizeof(CK_GCM_PARAMS)) + { + DEBUG_MSG("GCM mode requires parameters"); + return CKR_ARGUMENTS_BAD; + } + iv.resize(CK_GCM_PARAMS_PTR(pMechanism->pParameter)->ulIvLen); + memcpy(&iv[0], CK_GCM_PARAMS_PTR(pMechanism->pParameter)->pIv, CK_GCM_PARAMS_PTR(pMechanism->pParameter)->ulIvLen); + aad.resize(CK_GCM_PARAMS_PTR(pMechanism->pParameter)->ulAADLen); + if (CK_GCM_PARAMS_PTR(pMechanism->pParameter)->ulAADLen > 0) + memcpy(&aad[0], CK_GCM_PARAMS_PTR(pMechanism->pParameter)->pAAD, CK_GCM_PARAMS_PTR(pMechanism->pParameter)->ulAADLen); + tagBytes = CK_GCM_PARAMS_PTR(pMechanism->pParameter)->ulTagBits; + if (tagBytes > 128 || tagBytes % 8 != 0) + { + DEBUG_MSG("Invalid ulTagBits value"); + return CKR_ARGUMENTS_BAD; + } + tagBytes = tagBytes / 8; + break; + default: + return CKR_MECHANISM_INVALID; } - SymmetricAlgorithm* cipher = CryptoFactory::i()->getSymmetricAlgorithm(algo); - if (cipher == NULL) return CKR_MECHANISM_INVALID; + SymmetricAlgorithm *cipher = CryptoFactory::i()->getSymmetricAlgorithm(algo); + if (cipher == NULL) + return CKR_MECHANISM_INVALID; - SymmetricKey* secretkey = new SymmetricKey(); + SymmetricKey *secretkey = new SymmetricKey(); if (getSymmetricKey(secretkey, token, key) != CKR_OK) { @@ -3220,24 +3309,30 @@ CK_RV SoftHSM::SymDecryptInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMech // AsymAlgorithm version of C_DecryptInit CK_RV SoftHSM::AsymDecryptInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechanism, CK_OBJECT_HANDLE hKey) { - if (!isInitialised) return CKR_CRYPTOKI_NOT_INITIALIZED; + if (!isInitialised) + return CKR_CRYPTOKI_NOT_INITIALIZED; - if (pMechanism == NULL_PTR) return CKR_ARGUMENTS_BAD; + if (pMechanism == NULL_PTR) + return CKR_ARGUMENTS_BAD; // Get the session - Session* session = (Session*)handleManager->getSession(hSession); - if (session == NULL) return CKR_SESSION_HANDLE_INVALID; + Session *session = (Session *)handleManager->getSession(hSession); + if (session == NULL) + return CKR_SESSION_HANDLE_INVALID; // Get the token - Token* token = session->getToken(); - if (token == NULL) return CKR_GENERAL_ERROR; + Token *token = session->getToken(); + if (token == NULL) + return CKR_GENERAL_ERROR; // Check if we have another operation - if (session->getOpType() != SESSION_OP_NONE) return CKR_OPERATION_ACTIVE; + if (session->getOpType() != SESSION_OP_NONE) + return CKR_OPERATION_ACTIVE; // Check the key handle. OSObject *key = (OSObject *)handleManager->getObject(hKey); - if (key == NULL_PTR || !key->isValid()) return CKR_OBJECT_HANDLE_INVALID; + if (key == NULL_PTR || !key->isValid()) + return CKR_OBJECT_HANDLE_INVALID; CK_BBOOL isOnToken = key->getBooleanValue(CKA_TOKEN, false); CK_BBOOL isPrivate = key->getBooleanValue(CKA_PRIVATE, true); @@ -3266,39 +3361,41 @@ CK_RV SoftHSM::AsymDecryptInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMec // Get the asymmetric algorithm matching the mechanism AsymMech::Type mechanism = AsymMech::Unknown; bool isRSA = false; - switch(pMechanism->mechanism) { - case CKM_RSA_PKCS: - if (keyType != CKK_RSA) - return CKR_KEY_TYPE_INCONSISTENT; - mechanism = AsymMech::RSA_PKCS; - isRSA = true; - break; - case CKM_RSA_X_509: - if (keyType != CKK_RSA) - return CKR_KEY_TYPE_INCONSISTENT; - mechanism = AsymMech::RSA; - isRSA = true; - break; - case CKM_RSA_PKCS_OAEP: - if (keyType != CKK_RSA) - return CKR_KEY_TYPE_INCONSISTENT; - rv = MechParamCheckRSAPKCSOAEP(pMechanism); - if (rv != CKR_OK) - return rv; + switch (pMechanism->mechanism) + { + case CKM_RSA_PKCS: + if (keyType != CKK_RSA) + return CKR_KEY_TYPE_INCONSISTENT; + mechanism = AsymMech::RSA_PKCS; + isRSA = true; + break; + case CKM_RSA_X_509: + if (keyType != CKK_RSA) + return CKR_KEY_TYPE_INCONSISTENT; + mechanism = AsymMech::RSA; + isRSA = true; + break; + case CKM_RSA_PKCS_OAEP: + if (keyType != CKK_RSA) + return CKR_KEY_TYPE_INCONSISTENT; + rv = MechParamCheckRSAPKCSOAEP(pMechanism); + if (rv != CKR_OK) + return rv; - mechanism = AsymMech::RSA_PKCS_OAEP; - isRSA = true; - break; - default: - return CKR_MECHANISM_INVALID; + mechanism = AsymMech::RSA_PKCS_OAEP; + isRSA = true; + break; + default: + return CKR_MECHANISM_INVALID; } - AsymmetricAlgorithm* asymCrypto = NULL; - PrivateKey* privateKey = NULL; + AsymmetricAlgorithm *asymCrypto = NULL; + PrivateKey *privateKey = NULL; if (isRSA) { asymCrypto = CryptoFactory::i()->getAsymmetricAlgorithm(AsymAlgo::RSA); - if (asymCrypto == NULL) return CKR_MECHANISM_INVALID; + if (asymCrypto == NULL) + return CKR_MECHANISM_INVALID; privateKey = asymCrypto->newPrivateKey(); if (privateKey == NULL) @@ -3307,7 +3404,7 @@ CK_RV SoftHSM::AsymDecryptInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMec return CKR_HOST_MEMORY; } - if (getRSAPrivateKey((RSAPrivateKey*)privateKey, token, key) != CKR_OK) + if (getRSAPrivateKey((RSAPrivateKey *)privateKey, token, key) != CKR_OK) { asymCrypto->recyclePrivateKey(privateKey); CryptoFactory::i()->recycleAsymmetricAlgorithm(asymCrypto); @@ -3317,80 +3414,27 @@ CK_RV SoftHSM::AsymDecryptInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMec else { return CKR_MECHANISM_INVALID; - } + } // Check if re-authentication is required if (key->getBooleanValue(CKA_ALWAYS_AUTHENTICATE, false)) { session->setReAuthentication(true); } - // set mechanism parameters - void *parameters = NULL; + // set mechanism parameters + void *parameters = NULL; size_t paramLen = 0; - RSA_PKCS_OAEP_PARAMS oaep_param; if (pMechanism->mechanism == CKM_RSA_PKCS_OAEP) { - CK_RSA_PKCS_OAEP_PARAMS* par1 = (CK_RSA_PKCS_OAEP_PARAMS*) pMechanism->pParameter; - switch (par1->hashAlg) - { - case CKM_SHA_1: - oaep_param.hashAlg = HashAlgo::SHA1; - break; - case CKM_SHA224: - oaep_param.hashAlg = HashAlgo::SHA224; - break; - case CKM_SHA256: - oaep_param.hashAlg = HashAlgo::SHA256; - break; - case CKM_SHA384: - oaep_param.hashAlg = HashAlgo::SHA384; - break; - case CKM_SHA512: - oaep_param.hashAlg = HashAlgo::SHA512; - break; - default: - asymCrypto->recyclePrivateKey(privateKey); - CryptoFactory::i()->recycleAsymmetricAlgorithm(asymCrypto); - return CKR_ARGUMENTS_BAD; - } - switch (par1->mgf) + rv = BuildRSAOAEPParam((CK_RSA_PKCS_OAEP_PARAMS *)pMechanism->pParameter, + ¶meters, ¶mLen); + if (rv != CKR_OK) { - case CKG_MGF1_SHA1: - oaep_param.mgf = AsymRSAMGF::MGF1_SHA1; - break; - case CKG_MGF1_SHA224: - oaep_param.mgf = AsymRSAMGF::MGF1_SHA224; - break; - case CKG_MGF1_SHA256: - oaep_param.mgf = AsymRSAMGF::MGF1_SHA256; - break; - case CKG_MGF1_SHA384: - oaep_param.mgf = AsymRSAMGF::MGF1_SHA384; - break; - case CKG_MGF1_SHA512: - oaep_param.mgf = AsymRSAMGF::MGF1_SHA512; - break; - default: - asymCrypto->recyclePrivateKey(privateKey); - CryptoFactory::i()->recycleAsymmetricAlgorithm(asymCrypto); - return CKR_ARGUMENTS_BAD; - } - // need copy parameters to session context - // label source data will be copyed to end of parameter block - paramLen = sizeof(RSA_PKCS_OAEP_PARAMS) + par1->ulSourceDataLen; - parameters = malloc(paramLen); - if (parameters == NULL) - { asymCrypto->recyclePrivateKey(privateKey); CryptoFactory::i()->recycleAsymmetricAlgorithm(asymCrypto); - return CKR_HOST_MEMORY; + return rv; } - oaep_param.sourceData = (char*)parameters + sizeof(RSA_PKCS_OAEP_PARAMS); - oaep_param.sourceDataLen = par1->ulSourceDataLen; - memcpy(parameters,&oaep_param,sizeof(RSA_PKCS_OAEP_PARAMS)); - memcpy(oaep_param.sourceData,par1->pSourceData,par1->ulSourceDataLen); - } - + } session->setOpType(SESSION_OP_DECRYPT); session->setAsymmetricCryptoOp(asymCrypto); session->setMechanism(mechanism); @@ -3399,7 +3443,7 @@ CK_RV SoftHSM::AsymDecryptInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMec session->setPrivateKey(privateKey); if (parameters != NULL) { - session->setParameters(parameters,paramLen); + session->setParameters(parameters, paramLen); free(parameters); } return CKR_OK; @@ -3415,9 +3459,9 @@ CK_RV SoftHSM::C_DecryptInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMecha } // SymAlgorithm version of C_Decrypt -static CK_RV SymDecrypt(Session* session, CK_BYTE_PTR pEncryptedData, CK_ULONG ulEncryptedDataLen, CK_BYTE_PTR pData, CK_ULONG_PTR pulDataLen) +static CK_RV SymDecrypt(Session *session, CK_BYTE_PTR pEncryptedData, CK_ULONG ulEncryptedDataLen, CK_BYTE_PTR pData, CK_ULONG_PTR pulDataLen) { - SymmetricAlgorithm* cipher = session->getSymmetricCryptoOp(); + SymmetricAlgorithm *cipher = session->getSymmetricCryptoOp(); if (cipher == NULL || !session->getAllowSinglePartOp()) { session->resetOp(); @@ -3454,7 +3498,7 @@ static CK_RV SymDecrypt(Session* session, CK_BYTE_PTR pEncryptedData, CK_ULONG u ByteString data; // Decrypt the data - if (!cipher->decryptUpdate(encryptedData,data)) + if (!cipher->decryptUpdate(encryptedData, data)) { session->resetOp(); return CKR_ENCRYPTED_DATA_INVALID; @@ -3481,17 +3525,16 @@ static CK_RV SymDecrypt(Session* session, CK_BYTE_PTR pEncryptedData, CK_ULONG u session->resetOp(); return CKR_OK; - } // AsymAlgorithm version of C_Decrypt -static CK_RV AsymDecrypt(Session* session, CK_BYTE_PTR pEncryptedData, CK_ULONG ulEncryptedDataLen, CK_BYTE_PTR pData, CK_ULONG_PTR pulDataLen) +static CK_RV AsymDecrypt(Session *session, CK_BYTE_PTR pEncryptedData, CK_ULONG ulEncryptedDataLen, CK_BYTE_PTR pData, CK_ULONG_PTR pulDataLen) { - AsymmetricAlgorithm* asymCrypto = session->getAsymmetricCryptoOp(); + AsymmetricAlgorithm *asymCrypto = session->getAsymmetricCryptoOp(); AsymMech::Type mechanism = session->getMechanism(); - PrivateKey* privateKey = session->getPrivateKey(); + PrivateKey *privateKey = session->getPrivateKey(); size_t paramLen = 0; - void* parameters = session->getParameters(paramLen); + void *parameters = session->getParameters(paramLen); if (asymCrypto == NULL || !session->getAllowSinglePartOp() || privateKey == NULL) { session->resetOp(); @@ -3525,7 +3568,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,parameters,paramLen)) + if (!asymCrypto->decrypt(privateKey, encryptedData, data, mechanism, parameters, paramLen)) { session->resetOp(); return CKR_ENCRYPTED_DATA_INVALID; @@ -3546,17 +3589,18 @@ static CK_RV AsymDecrypt(Session* session, CK_BYTE_PTR pEncryptedData, CK_ULONG session->resetOp(); return CKR_OK; - } // Perform a single operation decryption in the given session CK_RV SoftHSM::C_Decrypt(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pEncryptedData, CK_ULONG ulEncryptedDataLen, CK_BYTE_PTR pData, CK_ULONG_PTR pulDataLen) { - if (!isInitialised) return CKR_CRYPTOKI_NOT_INITIALIZED; + if (!isInitialised) + return CKR_CRYPTOKI_NOT_INITIALIZED; // Get the session - Session* session = (Session*)handleManager->getSession(hSession); - if (session == NULL) return CKR_SESSION_HANDLE_INVALID; + Session *session = (Session *)handleManager->getSession(hSession); + if (session == NULL) + return CKR_SESSION_HANDLE_INVALID; if ((pEncryptedData == NULL_PTR) || (pulDataLen == NULL_PTR)) { @@ -3571,16 +3615,16 @@ CK_RV SoftHSM::C_Decrypt(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pEncryptedData, if (session->getSymmetricCryptoOp() != NULL) return SymDecrypt(session, pEncryptedData, ulEncryptedDataLen, - pData, pulDataLen); + pData, pulDataLen); else return AsymDecrypt(session, pEncryptedData, ulEncryptedDataLen, - pData, pulDataLen); + pData, pulDataLen); } // SymAlgorithm version of C_DecryptUpdate -static CK_RV SymDecryptUpdate(Session* session, CK_BYTE_PTR pEncryptedData, CK_ULONG ulEncryptedDataLen, CK_BYTE_PTR pData, CK_ULONG_PTR pDataLen) +static CK_RV SymDecryptUpdate(Session *session, CK_BYTE_PTR pEncryptedData, CK_ULONG ulEncryptedDataLen, CK_BYTE_PTR pData, CK_ULONG_PTR pDataLen) { - SymmetricAlgorithm* cipher = session->getSymmetricCryptoOp(); + SymmetricAlgorithm *cipher = session->getSymmetricCryptoOp(); if (cipher == NULL || !session->getAllowMultiPartOp()) { session->resetOp(); @@ -3616,7 +3660,7 @@ static CK_RV SymDecryptUpdate(Session* session, CK_BYTE_PTR pEncryptedData, CK_U if (*pDataLen < maxSize) { DEBUG_MSG("Output buffer too short ulEncryptedDataLen: %#5x output buffer size: %#5x blockSize: %#3x remainingSize: %#4x maxSize: %#5x", - ulEncryptedDataLen, *pDataLen, blockSize, remainingSize, maxSize); + ulEncryptedDataLen, *pDataLen, blockSize, remainingSize, maxSize); *pDataLen = maxSize; return CKR_BUFFER_TOO_SMALL; } @@ -3632,14 +3676,14 @@ static CK_RV SymDecryptUpdate(Session* session, CK_BYTE_PTR pEncryptedData, CK_U return CKR_ENCRYPTED_DATA_INVALID; } DEBUG_MSG("ulEncryptedDataLen: %#5x output buffer size: %#5x blockSize: %#3x remainingSize: %#4x maxSize: %#5x decryptedData.size(): %#5x", - ulEncryptedDataLen, *pDataLen, blockSize, remainingSize, maxSize, decryptedData.size()); + ulEncryptedDataLen, *pDataLen, blockSize, remainingSize, maxSize, decryptedData.size()); // Check output size from crypto. Unrecoverable error if too large. if (*pDataLen < decryptedData.size()) { session->resetOp(); ERROR_MSG("DecryptUpdate returning too much data. Length of output data buffer is %i but %i bytes was returned by the decrypt.", - *pDataLen, decryptedData.size()); + *pDataLen, decryptedData.size()); return CKR_ENCRYPTED_DATA_LEN_RANGE; } @@ -3652,15 +3696,16 @@ static CK_RV SymDecryptUpdate(Session* session, CK_BYTE_PTR pEncryptedData, CK_U return CKR_OK; } - // Feed data to the running decryption operation in a session CK_RV SoftHSM::C_DecryptUpdate(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pEncryptedData, CK_ULONG ulEncryptedDataLen, CK_BYTE_PTR pData, CK_ULONG_PTR pDataLen) { - if (!isInitialised) return CKR_CRYPTOKI_NOT_INITIALIZED; + if (!isInitialised) + return CKR_CRYPTOKI_NOT_INITIALIZED; // Get the session - Session* session = (Session*)handleManager->getSession(hSession); - if (session == NULL) return CKR_SESSION_HANDLE_INVALID; + Session *session = (Session *)handleManager->getSession(hSession); + if (session == NULL) + return CKR_SESSION_HANDLE_INVALID; if ((pEncryptedData == NULL_PTR) || (pDataLen == NULL_PTR)) { @@ -3675,14 +3720,14 @@ CK_RV SoftHSM::C_DecryptUpdate(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pEncrypte if (session->getSymmetricCryptoOp() != NULL) return SymDecryptUpdate(session, pEncryptedData, ulEncryptedDataLen, - pData, pDataLen); + pData, pDataLen); else return CKR_FUNCTION_NOT_SUPPORTED; } -static CK_RV SymDecryptFinal(Session* session, CK_BYTE_PTR pDecryptedData, CK_ULONG_PTR pulDecryptedDataLen) +static CK_RV SymDecryptFinal(Session *session, CK_BYTE_PTR pDecryptedData, CK_ULONG_PTR pulDecryptedDataLen) { - SymmetricAlgorithm* cipher = session->getSymmetricCryptoOp(); + SymmetricAlgorithm *cipher = session->getSymmetricCryptoOp(); if (cipher == NULL || !session->getAllowMultiPartOp()) { session->resetOp(); @@ -3699,7 +3744,7 @@ static CK_RV SymDecryptFinal(Session* session, CK_BYTE_PTR pDecryptedData, CK_UL { session->resetOp(); DEBUG_MSG("Remaining data length is not an integral of the block size. Block size: %#2x Remaining size: %#2x", - blockSize, remainingSize); + blockSize, remainingSize); return CKR_ENCRYPTED_DATA_LEN_RANGE; } // It is at least one padding byte. If no padding the all remains will be returned. @@ -3718,7 +3763,7 @@ static CK_RV SymDecryptFinal(Session* session, CK_BYTE_PTR pDecryptedData, CK_UL if (*pulDecryptedDataLen < size) { DEBUG_MSG("output buffer size: %#5x size: %#5x", - *pulDecryptedDataLen, size); + *pulDecryptedDataLen, size); *pulDecryptedDataLen = size; return CKR_BUFFER_TOO_SMALL; } @@ -3731,14 +3776,14 @@ static CK_RV SymDecryptFinal(Session* session, CK_BYTE_PTR pDecryptedData, CK_UL return CKR_ENCRYPTED_DATA_INVALID; } DEBUG_MSG("output buffer size: %#2x size: %#2x decryptedFinal.size(): %#2x", - *pulDecryptedDataLen, size, decryptedFinal.size()); + *pulDecryptedDataLen, size, decryptedFinal.size()); // Check output size from crypto. Unrecoverable error if to large. if (*pulDecryptedDataLen < decryptedFinal.size()) { session->resetOp(); ERROR_MSG("DecryptFinal returning too much data. Length of output data buffer is %i but %i bytes was returned by the encrypt.", - *pulDecryptedDataLen, decryptedFinal.size()); + *pulDecryptedDataLen, decryptedFinal.size()); return CKR_ENCRYPTED_DATA_LEN_RANGE; } @@ -3755,11 +3800,13 @@ static CK_RV SymDecryptFinal(Session* session, CK_BYTE_PTR pDecryptedData, CK_UL // Finalise the decryption operation CK_RV SoftHSM::C_DecryptFinal(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pData, CK_ULONG_PTR pDataLen) { - if (!isInitialised) return CKR_CRYPTOKI_NOT_INITIALIZED; + if (!isInitialised) + return CKR_CRYPTOKI_NOT_INITIALIZED; // Get the session - Session* session = (Session*)handleManager->getSession(hSession); - if (session == NULL) return CKR_SESSION_HANDLE_INVALID; + Session *session = (Session *)handleManager->getSession(hSession); + if (session == NULL) + return CKR_SESSION_HANDLE_INVALID; // Github issue #469, check NULL_PTR on pDataLen if (pDataLen == NULL) @@ -3769,7 +3816,8 @@ CK_RV SoftHSM::C_DecryptFinal(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pData, CK_ } // Check if we are doing the correct operation - if (session->getOpType() != SESSION_OP_DECRYPT) return CKR_OPERATION_NOT_INITIALIZED; + if (session->getOpType() != SESSION_OP_DECRYPT) + return CKR_OPERATION_NOT_INITIALIZED; if (session->getSymmetricCryptoOp() != NULL) return SymDecryptFinal(session, pData, pDataLen); @@ -3780,50 +3828,56 @@ CK_RV SoftHSM::C_DecryptFinal(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pData, CK_ // Initialise digesting using the specified mechanism in the specified session CK_RV SoftHSM::C_DigestInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechanism) { - if (!isInitialised) return CKR_CRYPTOKI_NOT_INITIALIZED; + if (!isInitialised) + return CKR_CRYPTOKI_NOT_INITIALIZED; - if (pMechanism == NULL_PTR) return CKR_ARGUMENTS_BAD; + if (pMechanism == NULL_PTR) + return CKR_ARGUMENTS_BAD; // Get the session - Session* session = (Session*)handleManager->getSession(hSession); - if (session == NULL) return CKR_SESSION_HANDLE_INVALID; + Session *session = (Session *)handleManager->getSession(hSession); + if (session == NULL) + return CKR_SESSION_HANDLE_INVALID; // Check if we have another operation - if (session->getOpType() != SESSION_OP_NONE) return CKR_OPERATION_ACTIVE; + if (session->getOpType() != SESSION_OP_NONE) + return CKR_OPERATION_ACTIVE; // Get the mechanism HashAlgo::Type algo = HashAlgo::Unknown; - switch(pMechanism->mechanism) { + switch (pMechanism->mechanism) + { #ifndef WITH_FIPS - case CKM_MD5: - algo = HashAlgo::MD5; - break; + case CKM_MD5: + algo = HashAlgo::MD5; + break; #endif - case CKM_SHA_1: - algo = HashAlgo::SHA1; - break; - case CKM_SHA224: - algo = HashAlgo::SHA224; - break; - case CKM_SHA256: - algo = HashAlgo::SHA256; - break; - case CKM_SHA384: - algo = HashAlgo::SHA384; - break; - case CKM_SHA512: - algo = HashAlgo::SHA512; - break; + case CKM_SHA_1: + algo = HashAlgo::SHA1; + break; + case CKM_SHA224: + algo = HashAlgo::SHA224; + break; + case CKM_SHA256: + algo = HashAlgo::SHA256; + break; + case CKM_SHA384: + algo = HashAlgo::SHA384; + break; + case CKM_SHA512: + algo = HashAlgo::SHA512; + break; #ifdef WITH_GOST - case CKM_GOSTR3411: - algo = HashAlgo::GOST; - break; + case CKM_GOSTR3411: + algo = HashAlgo::GOST; + break; #endif - default: - return CKR_MECHANISM_INVALID; + default: + return CKR_MECHANISM_INVALID; } - HashAlgorithm* hash = CryptoFactory::i()->getHashAlgorithm(algo); - if (hash == NULL) return CKR_MECHANISM_INVALID; + HashAlgorithm *hash = CryptoFactory::i()->getHashAlgorithm(algo); + if (hash == NULL) + return CKR_MECHANISM_INVALID; // Initialize hashing if (hash->hashInit() == false) @@ -3842,17 +3896,22 @@ CK_RV SoftHSM::C_DigestInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechan // Digest the specified data in a one-pass operation and return the resulting digest CK_RV SoftHSM::C_Digest(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pData, CK_ULONG ulDataLen, CK_BYTE_PTR pDigest, CK_ULONG_PTR pulDigestLen) { - if (!isInitialised) return CKR_CRYPTOKI_NOT_INITIALIZED; + if (!isInitialised) + return CKR_CRYPTOKI_NOT_INITIALIZED; - if (pulDigestLen == NULL_PTR) return CKR_ARGUMENTS_BAD; - if (pData == NULL_PTR) return CKR_ARGUMENTS_BAD; + if (pulDigestLen == NULL_PTR) + return CKR_ARGUMENTS_BAD; + if (pData == NULL_PTR) + return CKR_ARGUMENTS_BAD; // Get the session - Session* session = (Session*)handleManager->getSession(hSession); - if (session == NULL) return CKR_SESSION_HANDLE_INVALID; + Session *session = (Session *)handleManager->getSession(hSession); + if (session == NULL) + return CKR_SESSION_HANDLE_INVALID; // Check if we are doing the correct operation - if (session->getOpType() != SESSION_OP_DIGEST) return CKR_OPERATION_NOT_INITIALIZED; + if (session->getOpType() != SESSION_OP_DIGEST) + return CKR_OPERATION_NOT_INITIALIZED; // Return size CK_ULONG size = session->getDigestOp()->getHashSize(); @@ -3905,16 +3964,20 @@ CK_RV SoftHSM::C_Digest(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pData, CK_ULONG // Update a running digest operation CK_RV SoftHSM::C_DigestUpdate(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pPart, CK_ULONG ulPartLen) { - if (!isInitialised) return CKR_CRYPTOKI_NOT_INITIALIZED; + if (!isInitialised) + return CKR_CRYPTOKI_NOT_INITIALIZED; - if (pPart == NULL_PTR) return CKR_ARGUMENTS_BAD; + if (pPart == NULL_PTR) + return CKR_ARGUMENTS_BAD; // Get the session - Session* session = (Session*)handleManager->getSession(hSession); - if (session == NULL) return CKR_SESSION_HANDLE_INVALID; + Session *session = (Session *)handleManager->getSession(hSession); + if (session == NULL) + return CKR_SESSION_HANDLE_INVALID; // Check if we are doing the correct operation - if (session->getOpType() != SESSION_OP_DIGEST) return CKR_OPERATION_NOT_INITIALIZED; + if (session->getOpType() != SESSION_OP_DIGEST) + return CKR_OPERATION_NOT_INITIALIZED; // Get the data ByteString data(pPart, ulPartLen); @@ -3932,22 +3995,27 @@ CK_RV SoftHSM::C_DigestUpdate(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pPart, CK_ // Update a running digest operation by digesting a secret key with the specified handle CK_RV SoftHSM::C_DigestKey(CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE hObject) { - if (!isInitialised) return CKR_CRYPTOKI_NOT_INITIALIZED; + if (!isInitialised) + return CKR_CRYPTOKI_NOT_INITIALIZED; // Get the session - Session* session = (Session*)handleManager->getSession(hSession); - if (session == NULL) return CKR_SESSION_HANDLE_INVALID; + Session *session = (Session *)handleManager->getSession(hSession); + if (session == NULL) + return CKR_SESSION_HANDLE_INVALID; // Check if we are doing the correct operation - if (session->getOpType() != SESSION_OP_DIGEST) return CKR_OPERATION_NOT_INITIALIZED; + if (session->getOpType() != SESSION_OP_DIGEST) + return CKR_OPERATION_NOT_INITIALIZED; // Get the token - Token* token = session->getToken(); - if (token == NULL) return CKR_GENERAL_ERROR; + Token *token = session->getToken(); + if (token == NULL) + return CKR_GENERAL_ERROR; // Check the key handle. OSObject *key = (OSObject *)handleManager->getObject(hObject); - if (key == NULL_PTR || !key->isValid()) return CKR_KEY_HANDLE_INVALID; + if (key == NULL_PTR || !key->isValid()) + return CKR_KEY_HANDLE_INVALID; CK_BBOOL isOnToken = key->getBooleanValue(CKA_TOKEN, false); CK_BBOOL isPrivate = key->getBooleanValue(CKA_PRIVATE, true); @@ -3967,10 +4035,10 @@ CK_RV SoftHSM::C_DigestKey(CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE hObject) // Whitelist HashAlgo::Type algo = session->getHashAlgo(); if (algo != HashAlgo::SHA1 && - algo != HashAlgo::SHA224 && - algo != HashAlgo::SHA256 && - algo != HashAlgo::SHA384 && - algo != HashAlgo::SHA512) + algo != HashAlgo::SHA224 && + algo != HashAlgo::SHA256 && + algo != HashAlgo::SHA384 && + algo != HashAlgo::SHA512) { // Parano... if (!key->getBooleanValue(CKA_EXTRACTABLE, false)) @@ -4006,16 +4074,20 @@ CK_RV SoftHSM::C_DigestKey(CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE hObject) // Finalise the digest operation in the specified session and return the digest CK_RV SoftHSM::C_DigestFinal(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pDigest, CK_ULONG_PTR pulDigestLen) { - if (!isInitialised) return CKR_CRYPTOKI_NOT_INITIALIZED; + if (!isInitialised) + return CKR_CRYPTOKI_NOT_INITIALIZED; - if (pulDigestLen == NULL_PTR) return CKR_ARGUMENTS_BAD; + if (pulDigestLen == NULL_PTR) + return CKR_ARGUMENTS_BAD; // Get the session - Session* session = (Session*)handleManager->getSession(hSession); - if (session == NULL) return CKR_SESSION_HANDLE_INVALID; + Session *session = (Session *)handleManager->getSession(hSession); + if (session == NULL) + return CKR_SESSION_HANDLE_INVALID; // Check if we are doing the correct operation - if (session->getOpType() != SESSION_OP_DIGEST) return CKR_OPERATION_NOT_INITIALIZED; + if (session->getOpType() != SESSION_OP_DIGEST) + return CKR_OPERATION_NOT_INITIALIZED; // Return size CK_ULONG size = session->getDigestOp()->getHashSize(); @@ -4058,47 +4130,55 @@ CK_RV SoftHSM::C_DigestFinal(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pDigest, CK // Sign*/Verify*() is for MACs too static bool isMacMechanism(CK_MECHANISM_PTR pMechanism) { - if (pMechanism == NULL_PTR) return false; + if (pMechanism == NULL_PTR) + return false; - switch(pMechanism->mechanism) { - case CKM_MD5_HMAC: - case CKM_SHA_1_HMAC: - case CKM_SHA224_HMAC: - case CKM_SHA256_HMAC: - case CKM_SHA384_HMAC: - case CKM_SHA512_HMAC: + switch (pMechanism->mechanism) + { + case CKM_MD5_HMAC: + case CKM_SHA_1_HMAC: + case CKM_SHA224_HMAC: + case CKM_SHA256_HMAC: + case CKM_SHA384_HMAC: + case CKM_SHA512_HMAC: #ifdef WITH_GOST - case CKM_GOSTR3411_HMAC: + case CKM_GOSTR3411_HMAC: #endif - case CKM_DES3_CMAC: - case CKM_AES_CMAC: - return true; - default: - return false; + case CKM_DES3_CMAC: + case CKM_AES_CMAC: + return true; + default: + return false; } } // MacAlgorithm version of C_SignInit CK_RV SoftHSM::MacSignInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechanism, CK_OBJECT_HANDLE hKey) { - if (!isInitialised) return CKR_CRYPTOKI_NOT_INITIALIZED; + if (!isInitialised) + return CKR_CRYPTOKI_NOT_INITIALIZED; - if (pMechanism == NULL_PTR) return CKR_ARGUMENTS_BAD; + if (pMechanism == NULL_PTR) + return CKR_ARGUMENTS_BAD; // Get the session - Session* session = (Session*)handleManager->getSession(hSession); - if (session == NULL) return CKR_SESSION_HANDLE_INVALID; + Session *session = (Session *)handleManager->getSession(hSession); + if (session == NULL) + return CKR_SESSION_HANDLE_INVALID; // Check if we have another operation - if (session->getOpType() != SESSION_OP_NONE) return CKR_OPERATION_ACTIVE; + if (session->getOpType() != SESSION_OP_NONE) + return CKR_OPERATION_ACTIVE; // Get the token - Token* token = session->getToken(); - if (token == NULL) return CKR_GENERAL_ERROR; + Token *token = session->getToken(); + if (token == NULL) + return CKR_GENERAL_ERROR; // Check the key handle. OSObject *key = (OSObject *)handleManager->getObject(hKey); - if (key == NULL_PTR || !key->isValid()) return CKR_OBJECT_HANDLE_INVALID; + if (key == NULL_PTR || !key->isValid()) + return CKR_OBJECT_HANDLE_INVALID; CK_BBOOL isOnToken = key->getBooleanValue(CKA_TOKEN, false); CK_BBOOL isPrivate = key->getBooleanValue(CKA_PRIVATE, true); @@ -4129,71 +4209,73 @@ CK_RV SoftHSM::MacSignInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechani MacAlgo::Type algo = MacAlgo::Unknown; size_t bb = 8; size_t minSize = 0; - switch(pMechanism->mechanism) { + switch (pMechanism->mechanism) + { #ifndef WITH_FIPS - case CKM_MD5_HMAC: - if (keyType != CKK_GENERIC_SECRET && keyType != CKK_MD5_HMAC) - return CKR_KEY_TYPE_INCONSISTENT; - minSize = 16; - algo = MacAlgo::HMAC_MD5; - break; -#endif - case CKM_SHA_1_HMAC: - if (keyType != CKK_GENERIC_SECRET && keyType != CKK_SHA_1_HMAC) - return CKR_KEY_TYPE_INCONSISTENT; - minSize = 20; - algo = MacAlgo::HMAC_SHA1; - break; - case CKM_SHA224_HMAC: - if (keyType != CKK_GENERIC_SECRET && keyType != CKK_SHA224_HMAC) - return CKR_KEY_TYPE_INCONSISTENT; - minSize = 28; - algo = MacAlgo::HMAC_SHA224; - break; - case CKM_SHA256_HMAC: - if (keyType != CKK_GENERIC_SECRET && keyType != CKK_SHA256_HMAC) - return CKR_KEY_TYPE_INCONSISTENT; - minSize = 32; - algo = MacAlgo::HMAC_SHA256; - break; - case CKM_SHA384_HMAC: - if (keyType != CKK_GENERIC_SECRET && keyType != CKK_SHA384_HMAC) - return CKR_KEY_TYPE_INCONSISTENT; - minSize = 48; - algo = MacAlgo::HMAC_SHA384; - break; - case CKM_SHA512_HMAC: - if (keyType != CKK_GENERIC_SECRET && keyType != CKK_SHA512_HMAC) - return CKR_KEY_TYPE_INCONSISTENT; - minSize = 64; - algo = MacAlgo::HMAC_SHA512; - break; -#ifdef WITH_GOST - case CKM_GOSTR3411_HMAC: - if (keyType != CKK_GENERIC_SECRET && keyType != CKK_GOST28147) - return CKR_KEY_TYPE_INCONSISTENT; - minSize = 32; - algo = MacAlgo::HMAC_GOST; - break; + case CKM_MD5_HMAC: + if (keyType != CKK_GENERIC_SECRET && keyType != CKK_MD5_HMAC) + return CKR_KEY_TYPE_INCONSISTENT; + minSize = 16; + algo = MacAlgo::HMAC_MD5; + break; #endif - case CKM_DES3_CMAC: - if (keyType != CKK_DES2 && keyType != CKK_DES3) - return CKR_KEY_TYPE_INCONSISTENT; - algo = MacAlgo::CMAC_DES; - bb = 7; - break; - case CKM_AES_CMAC: - if (keyType != CKK_AES) - return CKR_KEY_TYPE_INCONSISTENT; - algo = MacAlgo::CMAC_AES; - break; - default: - return CKR_MECHANISM_INVALID; - } - MacAlgorithm* mac = CryptoFactory::i()->getMacAlgorithm(algo); - if (mac == NULL) return CKR_MECHANISM_INVALID; - - SymmetricKey* privkey = new SymmetricKey(); + case CKM_SHA_1_HMAC: + if (keyType != CKK_GENERIC_SECRET && keyType != CKK_SHA_1_HMAC) + return CKR_KEY_TYPE_INCONSISTENT; + minSize = 20; + algo = MacAlgo::HMAC_SHA1; + break; + case CKM_SHA224_HMAC: + if (keyType != CKK_GENERIC_SECRET && keyType != CKK_SHA224_HMAC) + return CKR_KEY_TYPE_INCONSISTENT; + minSize = 28; + algo = MacAlgo::HMAC_SHA224; + break; + case CKM_SHA256_HMAC: + if (keyType != CKK_GENERIC_SECRET && keyType != CKK_SHA256_HMAC) + return CKR_KEY_TYPE_INCONSISTENT; + minSize = 32; + algo = MacAlgo::HMAC_SHA256; + break; + case CKM_SHA384_HMAC: + if (keyType != CKK_GENERIC_SECRET && keyType != CKK_SHA384_HMAC) + return CKR_KEY_TYPE_INCONSISTENT; + minSize = 48; + algo = MacAlgo::HMAC_SHA384; + break; + case CKM_SHA512_HMAC: + if (keyType != CKK_GENERIC_SECRET && keyType != CKK_SHA512_HMAC) + return CKR_KEY_TYPE_INCONSISTENT; + minSize = 64; + algo = MacAlgo::HMAC_SHA512; + break; +#ifdef WITH_GOST + case CKM_GOSTR3411_HMAC: + if (keyType != CKK_GENERIC_SECRET && keyType != CKK_GOST28147) + return CKR_KEY_TYPE_INCONSISTENT; + minSize = 32; + algo = MacAlgo::HMAC_GOST; + break; +#endif + case CKM_DES3_CMAC: + if (keyType != CKK_DES2 && keyType != CKK_DES3) + return CKR_KEY_TYPE_INCONSISTENT; + algo = MacAlgo::CMAC_DES; + bb = 7; + break; + case CKM_AES_CMAC: + if (keyType != CKK_AES) + return CKR_KEY_TYPE_INCONSISTENT; + algo = MacAlgo::CMAC_AES; + break; + default: + return CKR_MECHANISM_INVALID; + } + MacAlgorithm *mac = CryptoFactory::i()->getMacAlgorithm(algo); + if (mac == NULL) + return CKR_MECHANISM_INVALID; + + SymmetricKey *privkey = new SymmetricKey(); if (getSymmetricKey(privkey, token, key) != CKR_OK) { @@ -4206,7 +4288,7 @@ CK_RV SoftHSM::MacSignInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechani privkey->setBitLen(privkey->getKeyBits().size() * bb); // Check key size - if (privkey->getBitLen() < (minSize*8)) + if (privkey->getBitLen() < (minSize * 8)) { mac->recycleKey(privkey); CryptoFactory::i()->recycleMacAlgorithm(mac); @@ -4233,24 +4315,30 @@ CK_RV SoftHSM::MacSignInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechani // AsymmetricAlgorithm version of C_SignInit CK_RV SoftHSM::AsymSignInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechanism, CK_OBJECT_HANDLE hKey) { - if (!isInitialised) return CKR_CRYPTOKI_NOT_INITIALIZED; + if (!isInitialised) + return CKR_CRYPTOKI_NOT_INITIALIZED; - if (pMechanism == NULL_PTR) return CKR_ARGUMENTS_BAD; + if (pMechanism == NULL_PTR) + return CKR_ARGUMENTS_BAD; // Get the session - Session* session = (Session*)handleManager->getSession(hSession); - if (session == NULL) return CKR_SESSION_HANDLE_INVALID; + Session *session = (Session *)handleManager->getSession(hSession); + if (session == NULL) + return CKR_SESSION_HANDLE_INVALID; // Check if we have another operation - if (session->getOpType() != SESSION_OP_NONE) return CKR_OPERATION_ACTIVE; + if (session->getOpType() != SESSION_OP_NONE) + return CKR_OPERATION_ACTIVE; // Get the token - Token* token = session->getToken(); - if (token == NULL) return CKR_GENERAL_ERROR; + Token *token = session->getToken(); + if (token == NULL) + return CKR_GENERAL_ERROR; // Check the key handle. OSObject *key = (OSObject *)handleManager->getObject(hKey); - if (key == NULL_PTR || !key->isValid()) return CKR_OBJECT_HANDLE_INVALID; + if (key == NULL_PTR || !key->isValid()) + return CKR_OBJECT_HANDLE_INVALID; CK_BBOOL isOnToken = key->getBooleanValue(CKA_TOKEN, false); CK_BBOOL isPrivate = key->getBooleanValue(CKA_PRIVATE, true); @@ -4275,7 +4363,7 @@ CK_RV SoftHSM::AsymSignInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechan // Get the asymmetric algorithm matching the mechanism AsymMech::Type mechanism = AsymMech::Unknown; - void* param = NULL; + void *param = NULL; size_t paramLen = 0; RSA_PKCS_PSS_PARAMS pssParam; bool bAllowMultiPartOp; @@ -4287,282 +4375,286 @@ CK_RV SoftHSM::AsymSignInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechan #ifdef WITH_EDDSA bool isEDDSA = false; #endif - switch(pMechanism->mechanism) { - case CKM_RSA_PKCS: - mechanism = AsymMech::RSA_PKCS; - bAllowMultiPartOp = false; - isRSA = true; - break; - case CKM_RSA_X_509: - mechanism = AsymMech::RSA; - bAllowMultiPartOp = false; - isRSA = true; - break; + switch (pMechanism->mechanism) + { + case CKM_RSA_PKCS: + mechanism = AsymMech::RSA_PKCS; + bAllowMultiPartOp = false; + isRSA = true; + break; + case CKM_RSA_X_509: + mechanism = AsymMech::RSA; + bAllowMultiPartOp = false; + isRSA = true; + break; #ifndef WITH_FIPS - case CKM_MD5_RSA_PKCS: - mechanism = AsymMech::RSA_MD5_PKCS; - bAllowMultiPartOp = true; - isRSA = true; - break; + case CKM_MD5_RSA_PKCS: + mechanism = AsymMech::RSA_MD5_PKCS; + bAllowMultiPartOp = true; + isRSA = true; + break; #endif - case CKM_SHA1_RSA_PKCS: - mechanism = AsymMech::RSA_SHA1_PKCS; - bAllowMultiPartOp = true; - isRSA = true; - break; - case CKM_SHA224_RSA_PKCS: - mechanism = AsymMech::RSA_SHA224_PKCS; - bAllowMultiPartOp = true; - isRSA = true; - break; - case CKM_SHA256_RSA_PKCS: - mechanism = AsymMech::RSA_SHA256_PKCS; - bAllowMultiPartOp = true; - isRSA = true; - break; - case CKM_SHA384_RSA_PKCS: - mechanism = AsymMech::RSA_SHA384_PKCS; - bAllowMultiPartOp = true; - isRSA = true; - break; - case CKM_SHA512_RSA_PKCS: - mechanism = AsymMech::RSA_SHA512_PKCS; - bAllowMultiPartOp = true; - isRSA = true; - break; + case CKM_SHA1_RSA_PKCS: + mechanism = AsymMech::RSA_SHA1_PKCS; + bAllowMultiPartOp = true; + isRSA = true; + break; + case CKM_SHA224_RSA_PKCS: + mechanism = AsymMech::RSA_SHA224_PKCS; + bAllowMultiPartOp = true; + isRSA = true; + break; + case CKM_SHA256_RSA_PKCS: + mechanism = AsymMech::RSA_SHA256_PKCS; + bAllowMultiPartOp = true; + isRSA = true; + break; + case CKM_SHA384_RSA_PKCS: + mechanism = AsymMech::RSA_SHA384_PKCS; + bAllowMultiPartOp = true; + isRSA = true; + break; + case CKM_SHA512_RSA_PKCS: + mechanism = AsymMech::RSA_SHA512_PKCS; + bAllowMultiPartOp = true; + isRSA = true; + break; #ifdef WITH_RAW_PSS - case CKM_RSA_PKCS_PSS: - if (pMechanism->pParameter == NULL_PTR || - pMechanism->ulParameterLen != sizeof(CK_RSA_PKCS_PSS_PARAMS)) - { - ERROR_MSG("Invalid RSA-PSS parameters"); - return CKR_ARGUMENTS_BAD; - } - mechanism = AsymMech::RSA_PKCS_PSS; - unsigned long allowedMgf; - - switch(CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->hashAlg) { - case CKM_SHA_1: - pssParam.hashAlg = HashAlgo::SHA1; - pssParam.mgf = AsymRSAMGF::MGF1_SHA1; - allowedMgf = CKG_MGF1_SHA1; - break; - case CKM_SHA224: - pssParam.hashAlg = HashAlgo::SHA224; - pssParam.mgf = AsymRSAMGF::MGF1_SHA224; - allowedMgf = CKG_MGF1_SHA224; - break; - case CKM_SHA256: - pssParam.hashAlg = HashAlgo::SHA256; - pssParam.mgf = AsymRSAMGF::MGF1_SHA256; - allowedMgf = CKG_MGF1_SHA256; - break; - case CKM_SHA384: - pssParam.hashAlg = HashAlgo::SHA384; - pssParam.mgf = AsymRSAMGF::MGF1_SHA384; - allowedMgf = CKG_MGF1_SHA384; - break; - case CKM_SHA512: - pssParam.hashAlg = HashAlgo::SHA512; - pssParam.mgf = AsymRSAMGF::MGF1_SHA512; - allowedMgf = CKG_MGF1_SHA512; - break; - default: - ERROR_MSG("Invalid RSA-PSS hash"); - return CKR_ARGUMENTS_BAD; - } - - if (CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->mgf != allowedMgf) { - ERROR_MSG("Hash and MGF don't match"); - return CKR_ARGUMENTS_BAD; - } + case CKM_RSA_PKCS_PSS: + if (pMechanism->pParameter == NULL_PTR || + pMechanism->ulParameterLen != sizeof(CK_RSA_PKCS_PSS_PARAMS)) + { + ERROR_MSG("Invalid RSA-PSS parameters"); + return CKR_ARGUMENTS_BAD; + } + mechanism = AsymMech::RSA_PKCS_PSS; + unsigned long allowedMgf; - pssParam.sLen = CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->sLen; - param = &pssParam; - paramLen = sizeof(pssParam); - bAllowMultiPartOp = false; - isRSA = true; - break; -#endif - case CKM_SHA1_RSA_PKCS_PSS: - if (pMechanism->pParameter == NULL_PTR || - pMechanism->ulParameterLen != sizeof(CK_RSA_PKCS_PSS_PARAMS) || - CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->hashAlg != CKM_SHA_1 || - CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->mgf != CKG_MGF1_SHA1) - { - ERROR_MSG("Invalid parameters"); - return CKR_ARGUMENTS_BAD; - } - mechanism = AsymMech::RSA_SHA1_PKCS_PSS; + switch (CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->hashAlg) + { + case CKM_SHA_1: 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); - bAllowMultiPartOp = true; - isRSA = true; + allowedMgf = CKG_MGF1_SHA1; break; - case CKM_SHA224_RSA_PKCS_PSS: - if (pMechanism->pParameter == NULL_PTR || - pMechanism->ulParameterLen != sizeof(CK_RSA_PKCS_PSS_PARAMS) || - CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->hashAlg != CKM_SHA224 || - CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->mgf != CKG_MGF1_SHA224) - { - ERROR_MSG("Invalid parameters"); - return CKR_ARGUMENTS_BAD; - } - mechanism = AsymMech::RSA_SHA224_PKCS_PSS; + case CKM_SHA224: 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); - bAllowMultiPartOp = true; - isRSA = true; + allowedMgf = CKG_MGF1_SHA224; break; - case CKM_SHA256_RSA_PKCS_PSS: - if (pMechanism->pParameter == NULL_PTR || - pMechanism->ulParameterLen != sizeof(CK_RSA_PKCS_PSS_PARAMS) || - CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->hashAlg != CKM_SHA256 || - CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->mgf != CKG_MGF1_SHA256) - { - ERROR_MSG("Invalid parameters"); - return CKR_ARGUMENTS_BAD; - } - mechanism = AsymMech::RSA_SHA256_PKCS_PSS; + case CKM_SHA256: 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); - bAllowMultiPartOp = true; - isRSA = true; + allowedMgf = CKG_MGF1_SHA256; break; - case CKM_SHA384_RSA_PKCS_PSS: - if (pMechanism->pParameter == NULL_PTR || - pMechanism->ulParameterLen != sizeof(CK_RSA_PKCS_PSS_PARAMS) || - CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->hashAlg != CKM_SHA384 || - CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->mgf != CKG_MGF1_SHA384) - { - ERROR_MSG("Invalid parameters"); - return CKR_ARGUMENTS_BAD; - } - mechanism = AsymMech::RSA_SHA384_PKCS_PSS; + case CKM_SHA384: 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); - bAllowMultiPartOp = true; - isRSA = true; + allowedMgf = CKG_MGF1_SHA384; break; - case CKM_SHA512_RSA_PKCS_PSS: - if (pMechanism->pParameter == NULL_PTR || - pMechanism->ulParameterLen != sizeof(CK_RSA_PKCS_PSS_PARAMS) || - CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->hashAlg != CKM_SHA512 || - CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->mgf != CKG_MGF1_SHA512) - { - ERROR_MSG("Invalid parameters"); - return CKR_ARGUMENTS_BAD; - } - mechanism = AsymMech::RSA_SHA512_PKCS_PSS; + case CKM_SHA512: 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); - bAllowMultiPartOp = true; - isRSA = true; - break; - case CKM_DSA: - mechanism = AsymMech::DSA; - bAllowMultiPartOp = false; - isDSA = true; - break; - case CKM_DSA_SHA1: - mechanism = AsymMech::DSA_SHA1; - bAllowMultiPartOp = true; - isDSA = true; - break; - case CKM_DSA_SHA224: - mechanism = AsymMech::DSA_SHA224; - bAllowMultiPartOp = true; - isDSA = true; - break; - case CKM_DSA_SHA256: - mechanism = AsymMech::DSA_SHA256; - bAllowMultiPartOp = true; - isDSA = true; - break; - case CKM_DSA_SHA384: - mechanism = AsymMech::DSA_SHA384; - bAllowMultiPartOp = true; - isDSA = true; - break; - case CKM_DSA_SHA512: - mechanism = AsymMech::DSA_SHA512; - bAllowMultiPartOp = true; - isDSA = true; + allowedMgf = CKG_MGF1_SHA512; break; + default: + ERROR_MSG("Invalid RSA-PSS hash"); + return CKR_ARGUMENTS_BAD; + } + + if (CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->mgf != allowedMgf) + { + ERROR_MSG("Hash and MGF don't match"); + return CKR_ARGUMENTS_BAD; + } + + pssParam.sLen = CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->sLen; + param = &pssParam; + paramLen = sizeof(pssParam); + bAllowMultiPartOp = false; + isRSA = true; + break; +#endif + case CKM_SHA1_RSA_PKCS_PSS: + if (pMechanism->pParameter == NULL_PTR || + pMechanism->ulParameterLen != sizeof(CK_RSA_PKCS_PSS_PARAMS) || + CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->hashAlg != CKM_SHA_1 || + CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->mgf != CKG_MGF1_SHA1) + { + ERROR_MSG("Invalid parameters"); + 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); + bAllowMultiPartOp = true; + isRSA = true; + break; + case CKM_SHA224_RSA_PKCS_PSS: + if (pMechanism->pParameter == NULL_PTR || + pMechanism->ulParameterLen != sizeof(CK_RSA_PKCS_PSS_PARAMS) || + CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->hashAlg != CKM_SHA224 || + CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->mgf != CKG_MGF1_SHA224) + { + ERROR_MSG("Invalid parameters"); + 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); + bAllowMultiPartOp = true; + isRSA = true; + break; + case CKM_SHA256_RSA_PKCS_PSS: + if (pMechanism->pParameter == NULL_PTR || + pMechanism->ulParameterLen != sizeof(CK_RSA_PKCS_PSS_PARAMS) || + CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->hashAlg != CKM_SHA256 || + CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->mgf != CKG_MGF1_SHA256) + { + ERROR_MSG("Invalid parameters"); + 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); + bAllowMultiPartOp = true; + isRSA = true; + break; + case CKM_SHA384_RSA_PKCS_PSS: + if (pMechanism->pParameter == NULL_PTR || + pMechanism->ulParameterLen != sizeof(CK_RSA_PKCS_PSS_PARAMS) || + CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->hashAlg != CKM_SHA384 || + CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->mgf != CKG_MGF1_SHA384) + { + ERROR_MSG("Invalid parameters"); + 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); + bAllowMultiPartOp = true; + isRSA = true; + break; + case CKM_SHA512_RSA_PKCS_PSS: + if (pMechanism->pParameter == NULL_PTR || + pMechanism->ulParameterLen != sizeof(CK_RSA_PKCS_PSS_PARAMS) || + CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->hashAlg != CKM_SHA512 || + CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->mgf != CKG_MGF1_SHA512) + { + ERROR_MSG("Invalid parameters"); + 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); + bAllowMultiPartOp = true; + isRSA = true; + break; + case CKM_DSA: + mechanism = AsymMech::DSA; + bAllowMultiPartOp = false; + isDSA = true; + break; + case CKM_DSA_SHA1: + mechanism = AsymMech::DSA_SHA1; + bAllowMultiPartOp = true; + isDSA = true; + break; + case CKM_DSA_SHA224: + mechanism = AsymMech::DSA_SHA224; + bAllowMultiPartOp = true; + isDSA = true; + break; + case CKM_DSA_SHA256: + mechanism = AsymMech::DSA_SHA256; + bAllowMultiPartOp = true; + isDSA = true; + break; + case CKM_DSA_SHA384: + mechanism = AsymMech::DSA_SHA384; + bAllowMultiPartOp = true; + isDSA = true; + break; + case CKM_DSA_SHA512: + mechanism = AsymMech::DSA_SHA512; + bAllowMultiPartOp = true; + isDSA = true; + break; #ifdef WITH_ECC - case CKM_ECDSA: - mechanism = AsymMech::ECDSA; - bAllowMultiPartOp = false; - isECDSA = true; - break; - case CKM_ECDSA_SHA1: - mechanism = AsymMech::ECDSA_SHA1; - bAllowMultiPartOp = false; - isECDSA = true; - break; - case CKM_ECDSA_SHA224: - mechanism = AsymMech::ECDSA_SHA224; - bAllowMultiPartOp = false; - isECDSA = true; - break; - case CKM_ECDSA_SHA256: - mechanism = AsymMech::ECDSA_SHA256; - bAllowMultiPartOp = false; - isECDSA = true; - break; - case CKM_ECDSA_SHA384: - mechanism = AsymMech::ECDSA_SHA384; - bAllowMultiPartOp = false; - isECDSA = true; - break; - case CKM_ECDSA_SHA512: - mechanism = AsymMech::ECDSA_SHA512; - bAllowMultiPartOp = false; - isECDSA = true; - break; + case CKM_ECDSA: + mechanism = AsymMech::ECDSA; + bAllowMultiPartOp = false; + isECDSA = true; + break; + case CKM_ECDSA_SHA1: + mechanism = AsymMech::ECDSA_SHA1; + bAllowMultiPartOp = false; + isECDSA = true; + break; + case CKM_ECDSA_SHA224: + mechanism = AsymMech::ECDSA_SHA224; + bAllowMultiPartOp = false; + isECDSA = true; + break; + case CKM_ECDSA_SHA256: + mechanism = AsymMech::ECDSA_SHA256; + bAllowMultiPartOp = false; + isECDSA = true; + break; + case CKM_ECDSA_SHA384: + mechanism = AsymMech::ECDSA_SHA384; + bAllowMultiPartOp = false; + isECDSA = true; + break; + case CKM_ECDSA_SHA512: + mechanism = AsymMech::ECDSA_SHA512; + bAllowMultiPartOp = false; + isECDSA = true; + break; #endif #ifdef WITH_GOST - case CKM_GOSTR3410: - mechanism = AsymMech::GOST; - bAllowMultiPartOp = false; - break; - case CKM_GOSTR3410_WITH_GOSTR3411: - mechanism = AsymMech::GOST_GOST; - bAllowMultiPartOp = true; - break; + case CKM_GOSTR3410: + mechanism = AsymMech::GOST; + bAllowMultiPartOp = false; + break; + case CKM_GOSTR3410_WITH_GOSTR3411: + mechanism = AsymMech::GOST_GOST; + bAllowMultiPartOp = true; + break; #endif #ifdef WITH_EDDSA - case CKM_EDDSA: - mechanism = AsymMech::EDDSA; - bAllowMultiPartOp = false; - isEDDSA = true; - break; + case CKM_EDDSA: + mechanism = AsymMech::EDDSA; + bAllowMultiPartOp = false; + isEDDSA = true; + break; #endif - default: - return CKR_MECHANISM_INVALID; + default: + return CKR_MECHANISM_INVALID; } - AsymmetricAlgorithm* asymCrypto = NULL; - PrivateKey* privateKey = NULL; + AsymmetricAlgorithm *asymCrypto = NULL; + PrivateKey *privateKey = NULL; if (isRSA) { asymCrypto = CryptoFactory::i()->getAsymmetricAlgorithm(AsymAlgo::RSA); - if (asymCrypto == NULL) return CKR_MECHANISM_INVALID; + if (asymCrypto == NULL) + return CKR_MECHANISM_INVALID; privateKey = asymCrypto->newPrivateKey(); if (privateKey == NULL) @@ -4571,7 +4663,7 @@ CK_RV SoftHSM::AsymSignInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechan return CKR_HOST_MEMORY; } - if (getRSAPrivateKey((RSAPrivateKey*)privateKey, token, key) != CKR_OK) + if (getRSAPrivateKey((RSAPrivateKey *)privateKey, token, key) != CKR_OK) { asymCrypto->recyclePrivateKey(privateKey); CryptoFactory::i()->recycleAsymmetricAlgorithm(asymCrypto); @@ -4581,7 +4673,8 @@ CK_RV SoftHSM::AsymSignInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechan else if (isDSA) { asymCrypto = CryptoFactory::i()->getAsymmetricAlgorithm(AsymAlgo::DSA); - if (asymCrypto == NULL) return CKR_MECHANISM_INVALID; + if (asymCrypto == NULL) + return CKR_MECHANISM_INVALID; privateKey = asymCrypto->newPrivateKey(); if (privateKey == NULL) @@ -4590,18 +4683,19 @@ CK_RV SoftHSM::AsymSignInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechan return CKR_HOST_MEMORY; } - if (getDSAPrivateKey((DSAPrivateKey*)privateKey, token, key) != CKR_OK) + if (getDSAPrivateKey((DSAPrivateKey *)privateKey, token, key) != CKR_OK) { asymCrypto->recyclePrivateKey(privateKey); CryptoFactory::i()->recycleAsymmetricAlgorithm(asymCrypto); return CKR_GENERAL_ERROR; } - } + } #ifdef WITH_ECC else if (isECDSA) { asymCrypto = CryptoFactory::i()->getAsymmetricAlgorithm(AsymAlgo::ECDSA); - if (asymCrypto == NULL) return CKR_MECHANISM_INVALID; + if (asymCrypto == NULL) + return CKR_MECHANISM_INVALID; privateKey = asymCrypto->newPrivateKey(); if (privateKey == NULL) @@ -4610,7 +4704,7 @@ CK_RV SoftHSM::AsymSignInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechan return CKR_HOST_MEMORY; } - if (getECPrivateKey((ECPrivateKey*)privateKey, token, key) != CKR_OK) + if (getECPrivateKey((ECPrivateKey *)privateKey, token, key) != CKR_OK) { asymCrypto->recyclePrivateKey(privateKey); CryptoFactory::i()->recycleAsymmetricAlgorithm(asymCrypto); @@ -4622,7 +4716,8 @@ CK_RV SoftHSM::AsymSignInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechan else if (isEDDSA) { asymCrypto = CryptoFactory::i()->getAsymmetricAlgorithm(AsymAlgo::EDDSA); - if (asymCrypto == NULL) return CKR_MECHANISM_INVALID; + if (asymCrypto == NULL) + return CKR_MECHANISM_INVALID; privateKey = asymCrypto->newPrivateKey(); if (privateKey == NULL) @@ -4631,7 +4726,7 @@ CK_RV SoftHSM::AsymSignInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechan return CKR_HOST_MEMORY; } - if (getEDPrivateKey((EDPrivateKey*)privateKey, token, key) != CKR_OK) + if (getEDPrivateKey((EDPrivateKey *)privateKey, token, key) != CKR_OK) { asymCrypto->recyclePrivateKey(privateKey); CryptoFactory::i()->recycleAsymmetricAlgorithm(asymCrypto); @@ -4643,7 +4738,8 @@ CK_RV SoftHSM::AsymSignInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechan { #ifdef WITH_GOST asymCrypto = CryptoFactory::i()->getAsymmetricAlgorithm(AsymAlgo::GOST); - if (asymCrypto == NULL) return CKR_MECHANISM_INVALID; + if (asymCrypto == NULL) + return CKR_MECHANISM_INVALID; privateKey = asymCrypto->newPrivateKey(); if (privateKey == NULL) @@ -4652,7 +4748,7 @@ CK_RV SoftHSM::AsymSignInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechan return CKR_HOST_MEMORY; } - if (getGOSTPrivateKey((GOSTPrivateKey*)privateKey, token, key) != CKR_OK) + if (getGOSTPrivateKey((GOSTPrivateKey *)privateKey, token, key) != CKR_OK) { asymCrypto->recyclePrivateKey(privateKey); CryptoFactory::i()->recycleAsymmetricAlgorithm(asymCrypto); @@ -4661,10 +4757,10 @@ CK_RV SoftHSM::AsymSignInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechan #else return CKR_MECHANISM_INVALID; #endif - } + } // Initialize signing - if (bAllowMultiPartOp && !asymCrypto->signInit(privateKey,mechanism,param,paramLen)) + if (bAllowMultiPartOp && !asymCrypto->signInit(privateKey, mechanism, param, paramLen)) { asymCrypto->recyclePrivateKey(privateKey); CryptoFactory::i()->recycleAsymmetricAlgorithm(asymCrypto); @@ -4698,9 +4794,9 @@ CK_RV SoftHSM::C_SignInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechanis } // MacAlgorithm version of C_Sign -static CK_RV MacSign(Session* session, CK_BYTE_PTR pData, CK_ULONG ulDataLen, CK_BYTE_PTR pSignature, CK_ULONG_PTR pulSignatureLen) +static CK_RV MacSign(Session *session, CK_BYTE_PTR pData, CK_ULONG ulDataLen, CK_BYTE_PTR pSignature, CK_ULONG_PTR pulSignatureLen) { - MacAlgorithm* mac = session->getMacOp(); + MacAlgorithm *mac = session->getMacOp(); if (mac == NULL || !session->getAllowSinglePartOp()) { session->resetOp(); @@ -4755,13 +4851,13 @@ static CK_RV MacSign(Session* session, CK_BYTE_PTR pData, CK_ULONG ulDataLen, CK } // AsymmetricAlgorithm version of C_Sign -static CK_RV AsymSign(Session* session, CK_BYTE_PTR pData, CK_ULONG ulDataLen, CK_BYTE_PTR pSignature, CK_ULONG_PTR pulSignatureLen) +static CK_RV AsymSign(Session *session, CK_BYTE_PTR pData, CK_ULONG ulDataLen, CK_BYTE_PTR pSignature, CK_ULONG_PTR pulSignatureLen) { - AsymmetricAlgorithm* asymCrypto = session->getAsymmetricCryptoOp(); + AsymmetricAlgorithm *asymCrypto = session->getAsymmetricCryptoOp(); AsymMech::Type mechanism = session->getMechanism(); - PrivateKey* privateKey = session->getPrivateKey(); + PrivateKey *privateKey = session->getPrivateKey(); size_t paramLen; - void* param = session->getParameters(paramLen); + void *param = session->getParameters(paramLen); if (asymCrypto == NULL || !session->getAllowSinglePartOp() || privateKey == NULL) { session->resetOp(); @@ -4794,8 +4890,9 @@ static CK_RV AsymSign(Session* session, CK_BYTE_PTR pData, CK_ULONG ulDataLen, C ByteString data; // We must allow input length <= k and therfore need to prepend the data with zeroes. - if (mechanism == AsymMech::RSA) { - data.wipe(size-ulDataLen); + if (mechanism == AsymMech::RSA) + { + data.wipe(size - ulDataLen); } data += ByteString(pData, ulDataLen); @@ -4805,13 +4902,13 @@ static CK_RV AsymSign(Session* session, CK_BYTE_PTR pData, CK_ULONG ulDataLen, C if (session->getAllowMultiPartOp()) { if (!asymCrypto->signUpdate(data) || - !asymCrypto->signFinal(signature)) + !asymCrypto->signFinal(signature)) { session->resetOp(); return CKR_GENERAL_ERROR; } } - else if (!asymCrypto->sign(privateKey,data,signature,mechanism,param,paramLen)) + else if (!asymCrypto->sign(privateKey, data, signature, mechanism, param, paramLen)) { session->resetOp(); return CKR_GENERAL_ERROR; @@ -4834,14 +4931,18 @@ static CK_RV AsymSign(Session* session, CK_BYTE_PTR pData, CK_ULONG ulDataLen, C // Sign the data in a single pass operation CK_RV SoftHSM::C_Sign(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pData, CK_ULONG ulDataLen, CK_BYTE_PTR pSignature, CK_ULONG_PTR pulSignatureLen) { - if (!isInitialised) return CKR_CRYPTOKI_NOT_INITIALIZED; + if (!isInitialised) + return CKR_CRYPTOKI_NOT_INITIALIZED; - if (pData == NULL_PTR) return CKR_ARGUMENTS_BAD; - if (pulSignatureLen == NULL_PTR) return CKR_ARGUMENTS_BAD; + if (pData == NULL_PTR) + return CKR_ARGUMENTS_BAD; + if (pulSignatureLen == NULL_PTR) + return CKR_ARGUMENTS_BAD; // Get the session - Session* session = (Session*)handleManager->getSession(hSession); - if (session == NULL) return CKR_SESSION_HANDLE_INVALID; + Session *session = (Session *)handleManager->getSession(hSession); + if (session == NULL) + return CKR_SESSION_HANDLE_INVALID; // Check if we are doing the correct operation if (session->getOpType() != SESSION_OP_SIGN) @@ -4849,16 +4950,16 @@ CK_RV SoftHSM::C_Sign(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pData, CK_ULONG ul if (session->getMacOp() != NULL) return MacSign(session, pData, ulDataLen, - pSignature, pulSignatureLen); + pSignature, pulSignatureLen); else return AsymSign(session, pData, ulDataLen, - pSignature, pulSignatureLen); + pSignature, pulSignatureLen); } // MacAlgorithm version of C_SignUpdate -static CK_RV MacSignUpdate(Session* session, CK_BYTE_PTR pPart, CK_ULONG ulPartLen) +static CK_RV MacSignUpdate(Session *session, CK_BYTE_PTR pPart, CK_ULONG ulPartLen) { - MacAlgorithm* mac = session->getMacOp(); + MacAlgorithm *mac = session->getMacOp(); if (mac == NULL || !session->getAllowMultiPartOp()) { session->resetOp(); @@ -4880,9 +4981,9 @@ static CK_RV MacSignUpdate(Session* session, CK_BYTE_PTR pPart, CK_ULONG ulPartL } // AsymmetricAlgorithm version of C_SignUpdate -static CK_RV AsymSignUpdate(Session* session, CK_BYTE_PTR pPart, CK_ULONG ulPartLen) +static CK_RV AsymSignUpdate(Session *session, CK_BYTE_PTR pPart, CK_ULONG ulPartLen) { - AsymmetricAlgorithm* asymCrypto = session->getAsymmetricCryptoOp(); + AsymmetricAlgorithm *asymCrypto = session->getAsymmetricCryptoOp(); if (asymCrypto == NULL || !session->getAllowMultiPartOp()) { session->resetOp(); @@ -4913,13 +5014,16 @@ static CK_RV AsymSignUpdate(Session* session, CK_BYTE_PTR pPart, CK_ULONG ulPart // Update a running signing operation with additional data CK_RV SoftHSM::C_SignUpdate(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pPart, CK_ULONG ulPartLen) { - if (!isInitialised) return CKR_CRYPTOKI_NOT_INITIALIZED; + if (!isInitialised) + return CKR_CRYPTOKI_NOT_INITIALIZED; - if (pPart == NULL_PTR) return CKR_ARGUMENTS_BAD; + if (pPart == NULL_PTR) + return CKR_ARGUMENTS_BAD; // Get the session - Session* session = (Session*)handleManager->getSession(hSession); - if (session == NULL) return CKR_SESSION_HANDLE_INVALID; + Session *session = (Session *)handleManager->getSession(hSession); + if (session == NULL) + return CKR_SESSION_HANDLE_INVALID; // Check if we are doing the correct operation if (session->getOpType() != SESSION_OP_SIGN) @@ -4932,9 +5036,9 @@ CK_RV SoftHSM::C_SignUpdate(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pPart, CK_UL } // MacAlgorithm version of C_SignFinal -static CK_RV MacSignFinal(Session* session, CK_BYTE_PTR pSignature, CK_ULONG_PTR pulSignatureLen) +static CK_RV MacSignFinal(Session *session, CK_BYTE_PTR pSignature, CK_ULONG_PTR pulSignatureLen) { - MacAlgorithm* mac = session->getMacOp(); + MacAlgorithm *mac = session->getMacOp(); if (mac == NULL) { session->resetOp(); @@ -4979,10 +5083,10 @@ static CK_RV MacSignFinal(Session* session, CK_BYTE_PTR pSignature, CK_ULONG_PTR } // AsymmetricAlgorithm version of C_SignFinal -static CK_RV AsymSignFinal(Session* session, CK_BYTE_PTR pSignature, CK_ULONG_PTR pulSignatureLen) +static CK_RV AsymSignFinal(Session *session, CK_BYTE_PTR pSignature, CK_ULONG_PTR pulSignatureLen) { - AsymmetricAlgorithm* asymCrypto = session->getAsymmetricCryptoOp(); - PrivateKey* privateKey = session->getPrivateKey(); + AsymmetricAlgorithm *asymCrypto = session->getAsymmetricCryptoOp(); + PrivateKey *privateKey = session->getPrivateKey(); if (asymCrypto == NULL || privateKey == NULL) { session->resetOp(); @@ -5036,13 +5140,16 @@ static CK_RV AsymSignFinal(Session* session, CK_BYTE_PTR pSignature, CK_ULONG_PT // Finalise a running signing operation and return the signature CK_RV SoftHSM::C_SignFinal(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pSignature, CK_ULONG_PTR pulSignatureLen) { - if (!isInitialised) return CKR_CRYPTOKI_NOT_INITIALIZED; + if (!isInitialised) + return CKR_CRYPTOKI_NOT_INITIALIZED; - if (pulSignatureLen == NULL_PTR) return CKR_ARGUMENTS_BAD; + if (pulSignatureLen == NULL_PTR) + return CKR_ARGUMENTS_BAD; // Get the session - Session* session = (Session*)handleManager->getSession(hSession); - if (session == NULL) return CKR_SESSION_HANDLE_INVALID; + Session *session = (Session *)handleManager->getSession(hSession); + if (session == NULL) + return CKR_SESSION_HANDLE_INVALID; // Check if we are doing the correct operation if (session->getOpType() != SESSION_OP_SIGN || !session->getAllowMultiPartOp()) @@ -5057,14 +5164,17 @@ CK_RV SoftHSM::C_SignFinal(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pSignature, C // Initialise a signing operation that allows recovery of the signed data CK_RV SoftHSM::C_SignRecoverInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR /*pMechanism*/, CK_OBJECT_HANDLE /*hKey*/) { - if (!isInitialised) return CKR_CRYPTOKI_NOT_INITIALIZED; + if (!isInitialised) + return CKR_CRYPTOKI_NOT_INITIALIZED; // Get the session - Session* session = (Session*)handleManager->getSession(hSession); - if (session == NULL) return CKR_SESSION_HANDLE_INVALID; + Session *session = (Session *)handleManager->getSession(hSession); + if (session == NULL) + return CKR_SESSION_HANDLE_INVALID; // Check if we have another operation - if (session->getOpType() != SESSION_OP_NONE) return CKR_OPERATION_ACTIVE; + if (session->getOpType() != SESSION_OP_NONE) + return CKR_OPERATION_ACTIVE; return CKR_FUNCTION_NOT_SUPPORTED; } @@ -5072,11 +5182,13 @@ CK_RV SoftHSM::C_SignRecoverInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR /* // Perform a single part signing operation that allows recovery of the signed data CK_RV SoftHSM::C_SignRecover(CK_SESSION_HANDLE hSession, CK_BYTE_PTR /*pData*/, CK_ULONG /*ulDataLen*/, CK_BYTE_PTR /*pSignature*/, CK_ULONG_PTR /*pulSignatureLen*/) { - if (!isInitialised) return CKR_CRYPTOKI_NOT_INITIALIZED; + if (!isInitialised) + return CKR_CRYPTOKI_NOT_INITIALIZED; // Get the session - Session* session = (Session*)handleManager->getSession(hSession); - if (session == NULL) return CKR_SESSION_HANDLE_INVALID; + Session *session = (Session *)handleManager->getSession(hSession); + if (session == NULL) + return CKR_SESSION_HANDLE_INVALID; return CKR_FUNCTION_NOT_SUPPORTED; } @@ -5084,24 +5196,30 @@ CK_RV SoftHSM::C_SignRecover(CK_SESSION_HANDLE hSession, CK_BYTE_PTR /*pData*/, // MacAlgorithm version of C_VerifyInit CK_RV SoftHSM::MacVerifyInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechanism, CK_OBJECT_HANDLE hKey) { - if (!isInitialised) return CKR_CRYPTOKI_NOT_INITIALIZED; + if (!isInitialised) + return CKR_CRYPTOKI_NOT_INITIALIZED; - if (pMechanism == NULL_PTR) return CKR_ARGUMENTS_BAD; + if (pMechanism == NULL_PTR) + return CKR_ARGUMENTS_BAD; // Get the session - Session* session = (Session*)handleManager->getSession(hSession); - if (session == NULL) return CKR_SESSION_HANDLE_INVALID; + Session *session = (Session *)handleManager->getSession(hSession); + if (session == NULL) + return CKR_SESSION_HANDLE_INVALID; // Check if we have another operation - if (session->getOpType() != SESSION_OP_NONE) return CKR_OPERATION_ACTIVE; + if (session->getOpType() != SESSION_OP_NONE) + return CKR_OPERATION_ACTIVE; // Get the token - Token* token = session->getToken(); - if (token == NULL) return CKR_GENERAL_ERROR; + Token *token = session->getToken(); + if (token == NULL) + return CKR_GENERAL_ERROR; // Check the key handle. OSObject *key = (OSObject *)handleManager->getObject(hKey); - if (key == NULL_PTR || !key->isValid()) return CKR_OBJECT_HANDLE_INVALID; + if (key == NULL_PTR || !key->isValid()) + return CKR_OBJECT_HANDLE_INVALID; CK_BBOOL isOnToken = key->getBooleanValue(CKA_TOKEN, false); CK_BBOOL isPrivate = key->getBooleanValue(CKA_PRIVATE, true); @@ -5132,71 +5250,73 @@ CK_RV SoftHSM::MacVerifyInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMecha MacAlgo::Type algo = MacAlgo::Unknown; size_t bb = 8; size_t minSize = 0; - switch(pMechanism->mechanism) { + switch (pMechanism->mechanism) + { #ifndef WITH_FIPS - case CKM_MD5_HMAC: - if (keyType != CKK_GENERIC_SECRET && keyType != CKK_MD5_HMAC) - return CKR_KEY_TYPE_INCONSISTENT; - minSize = 16; - algo = MacAlgo::HMAC_MD5; - break; + case CKM_MD5_HMAC: + if (keyType != CKK_GENERIC_SECRET && keyType != CKK_MD5_HMAC) + return CKR_KEY_TYPE_INCONSISTENT; + minSize = 16; + algo = MacAlgo::HMAC_MD5; + break; #endif - case CKM_SHA_1_HMAC: - if (keyType != CKK_GENERIC_SECRET && keyType != CKK_SHA_1_HMAC) - return CKR_KEY_TYPE_INCONSISTENT; - minSize = 20; - algo = MacAlgo::HMAC_SHA1; - break; - case CKM_SHA224_HMAC: - if (keyType != CKK_GENERIC_SECRET && keyType != CKK_SHA224_HMAC) - return CKR_KEY_TYPE_INCONSISTENT; - minSize = 28; - algo = MacAlgo::HMAC_SHA224; - break; - case CKM_SHA256_HMAC: - if (keyType != CKK_GENERIC_SECRET && keyType != CKK_SHA256_HMAC) - return CKR_KEY_TYPE_INCONSISTENT; - minSize = 32; - algo = MacAlgo::HMAC_SHA256; - break; - case CKM_SHA384_HMAC: - if (keyType != CKK_GENERIC_SECRET && keyType != CKK_SHA384_HMAC) - return CKR_KEY_TYPE_INCONSISTENT; - minSize = 48; - algo = MacAlgo::HMAC_SHA384; - break; - case CKM_SHA512_HMAC: - if (keyType != CKK_GENERIC_SECRET && keyType != CKK_SHA512_HMAC) - return CKR_KEY_TYPE_INCONSISTENT; - minSize = 64; - algo = MacAlgo::HMAC_SHA512; - break; + case CKM_SHA_1_HMAC: + if (keyType != CKK_GENERIC_SECRET && keyType != CKK_SHA_1_HMAC) + return CKR_KEY_TYPE_INCONSISTENT; + minSize = 20; + algo = MacAlgo::HMAC_SHA1; + break; + case CKM_SHA224_HMAC: + if (keyType != CKK_GENERIC_SECRET && keyType != CKK_SHA224_HMAC) + return CKR_KEY_TYPE_INCONSISTENT; + minSize = 28; + algo = MacAlgo::HMAC_SHA224; + break; + case CKM_SHA256_HMAC: + if (keyType != CKK_GENERIC_SECRET && keyType != CKK_SHA256_HMAC) + return CKR_KEY_TYPE_INCONSISTENT; + minSize = 32; + algo = MacAlgo::HMAC_SHA256; + break; + case CKM_SHA384_HMAC: + if (keyType != CKK_GENERIC_SECRET && keyType != CKK_SHA384_HMAC) + return CKR_KEY_TYPE_INCONSISTENT; + minSize = 48; + algo = MacAlgo::HMAC_SHA384; + break; + case CKM_SHA512_HMAC: + if (keyType != CKK_GENERIC_SECRET && keyType != CKK_SHA512_HMAC) + return CKR_KEY_TYPE_INCONSISTENT; + minSize = 64; + algo = MacAlgo::HMAC_SHA512; + break; #ifdef WITH_GOST - case CKM_GOSTR3411_HMAC: - if (keyType != CKK_GENERIC_SECRET && keyType != CKK_GOST28147) - return CKR_KEY_TYPE_INCONSISTENT; - minSize = 32; - algo = MacAlgo::HMAC_GOST; - break; + case CKM_GOSTR3411_HMAC: + if (keyType != CKK_GENERIC_SECRET && keyType != CKK_GOST28147) + return CKR_KEY_TYPE_INCONSISTENT; + minSize = 32; + algo = MacAlgo::HMAC_GOST; + break; #endif - case CKM_DES3_CMAC: - if (keyType != CKK_DES2 && keyType != CKK_DES3) - return CKR_KEY_TYPE_INCONSISTENT; - algo = MacAlgo::CMAC_DES; - bb = 7; - break; - case CKM_AES_CMAC: - if (keyType != CKK_AES) - return CKR_KEY_TYPE_INCONSISTENT; - algo = MacAlgo::CMAC_AES; - break; - default: - return CKR_MECHANISM_INVALID; + case CKM_DES3_CMAC: + if (keyType != CKK_DES2 && keyType != CKK_DES3) + return CKR_KEY_TYPE_INCONSISTENT; + algo = MacAlgo::CMAC_DES; + bb = 7; + break; + case CKM_AES_CMAC: + if (keyType != CKK_AES) + return CKR_KEY_TYPE_INCONSISTENT; + algo = MacAlgo::CMAC_AES; + break; + default: + return CKR_MECHANISM_INVALID; } - MacAlgorithm* mac = CryptoFactory::i()->getMacAlgorithm(algo); - if (mac == NULL) return CKR_MECHANISM_INVALID; + MacAlgorithm *mac = CryptoFactory::i()->getMacAlgorithm(algo); + if (mac == NULL) + return CKR_MECHANISM_INVALID; - SymmetricKey* pubkey = new SymmetricKey(); + SymmetricKey *pubkey = new SymmetricKey(); if (getSymmetricKey(pubkey, token, key) != CKR_OK) { @@ -5209,7 +5329,7 @@ CK_RV SoftHSM::MacVerifyInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMecha pubkey->setBitLen(pubkey->getKeyBits().size() * bb); // Check key size - if (pubkey->getBitLen() < (minSize*8)) + if (pubkey->getBitLen() < (minSize * 8)) { mac->recycleKey(pubkey); CryptoFactory::i()->recycleMacAlgorithm(mac); @@ -5236,24 +5356,30 @@ CK_RV SoftHSM::MacVerifyInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMecha // AsymmetricAlgorithm version of C_VerifyInit CK_RV SoftHSM::AsymVerifyInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechanism, CK_OBJECT_HANDLE hKey) { - if (!isInitialised) return CKR_CRYPTOKI_NOT_INITIALIZED; + if (!isInitialised) + return CKR_CRYPTOKI_NOT_INITIALIZED; - if (pMechanism == NULL_PTR) return CKR_ARGUMENTS_BAD; + if (pMechanism == NULL_PTR) + return CKR_ARGUMENTS_BAD; // Get the session - Session* session = (Session*)handleManager->getSession(hSession); - if (session == NULL) return CKR_SESSION_HANDLE_INVALID; + Session *session = (Session *)handleManager->getSession(hSession); + if (session == NULL) + return CKR_SESSION_HANDLE_INVALID; // Check if we have another operation - if (session->getOpType() != SESSION_OP_NONE) return CKR_OPERATION_ACTIVE; + if (session->getOpType() != SESSION_OP_NONE) + return CKR_OPERATION_ACTIVE; // Get the token - Token* token = session->getToken(); - if (token == NULL) return CKR_GENERAL_ERROR; + Token *token = session->getToken(); + if (token == NULL) + return CKR_GENERAL_ERROR; // Check the key handle. OSObject *key = (OSObject *)handleManager->getObject(hKey); - if (key == NULL_PTR || !key->isValid()) return CKR_OBJECT_HANDLE_INVALID; + if (key == NULL_PTR || !key->isValid()) + return CKR_OBJECT_HANDLE_INVALID; CK_BBOOL isOnToken = key->getBooleanValue(CKA_TOKEN, false); CK_BBOOL isPrivate = key->getBooleanValue(CKA_PRIVATE, true); @@ -5278,7 +5404,7 @@ CK_RV SoftHSM::AsymVerifyInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMech // Get the asymmetric algorithm matching the mechanism AsymMech::Type mechanism = AsymMech::Unknown; - void* param = NULL; + void *param = NULL; size_t paramLen = 0; RSA_PKCS_PSS_PARAMS pssParam; bool bAllowMultiPartOp; @@ -5290,280 +5416,284 @@ CK_RV SoftHSM::AsymVerifyInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMech #ifdef WITH_EDDSA bool isEDDSA = false; #endif - switch(pMechanism->mechanism) { - case CKM_RSA_PKCS: - mechanism = AsymMech::RSA_PKCS; - bAllowMultiPartOp = false; - isRSA = true; - break; - case CKM_RSA_X_509: - mechanism = AsymMech::RSA; - bAllowMultiPartOp = false; - isRSA = true; - break; + switch (pMechanism->mechanism) + { + case CKM_RSA_PKCS: + mechanism = AsymMech::RSA_PKCS; + bAllowMultiPartOp = false; + isRSA = true; + break; + case CKM_RSA_X_509: + mechanism = AsymMech::RSA; + bAllowMultiPartOp = false; + isRSA = true; + break; #ifndef WITH_FIPS - case CKM_MD5_RSA_PKCS: - mechanism = AsymMech::RSA_MD5_PKCS; - bAllowMultiPartOp = true; - isRSA = true; - break; + case CKM_MD5_RSA_PKCS: + mechanism = AsymMech::RSA_MD5_PKCS; + bAllowMultiPartOp = true; + isRSA = true; + break; #endif - case CKM_SHA1_RSA_PKCS: - mechanism = AsymMech::RSA_SHA1_PKCS; - bAllowMultiPartOp = true; - isRSA = true; - break; - case CKM_SHA224_RSA_PKCS: - mechanism = AsymMech::RSA_SHA224_PKCS; - bAllowMultiPartOp = true; - isRSA = true; + case CKM_SHA1_RSA_PKCS: + mechanism = AsymMech::RSA_SHA1_PKCS; + bAllowMultiPartOp = true; + isRSA = true; + break; + case CKM_SHA224_RSA_PKCS: + mechanism = AsymMech::RSA_SHA224_PKCS; + bAllowMultiPartOp = true; + isRSA = true; + break; + case CKM_SHA256_RSA_PKCS: + mechanism = AsymMech::RSA_SHA256_PKCS; + bAllowMultiPartOp = true; + isRSA = true; + break; + case CKM_SHA384_RSA_PKCS: + mechanism = AsymMech::RSA_SHA384_PKCS; + bAllowMultiPartOp = true; + isRSA = true; + break; + case CKM_SHA512_RSA_PKCS: + mechanism = AsymMech::RSA_SHA512_PKCS; + bAllowMultiPartOp = true; + isRSA = true; + break; +#ifdef WITH_RAW_PSS + case CKM_RSA_PKCS_PSS: + if (pMechanism->pParameter == NULL_PTR || + pMechanism->ulParameterLen != sizeof(CK_RSA_PKCS_PSS_PARAMS)) + { + ERROR_MSG("Invalid parameters"); + return CKR_ARGUMENTS_BAD; + } + mechanism = AsymMech::RSA_PKCS_PSS; + + 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; + expectedMgf = CKG_MGF1_SHA1; break; - case CKM_SHA256_RSA_PKCS: - mechanism = AsymMech::RSA_SHA256_PKCS; - bAllowMultiPartOp = true; - isRSA = true; + case CKM_SHA224: + pssParam.hashAlg = HashAlgo::SHA224; + pssParam.mgf = AsymRSAMGF::MGF1_SHA224; + expectedMgf = CKG_MGF1_SHA224; break; - case CKM_SHA384_RSA_PKCS: - mechanism = AsymMech::RSA_SHA384_PKCS; - bAllowMultiPartOp = true; - isRSA = true; + case CKM_SHA256: + pssParam.hashAlg = HashAlgo::SHA256; + pssParam.mgf = AsymRSAMGF::MGF1_SHA256; + expectedMgf = CKG_MGF1_SHA256; break; - case CKM_SHA512_RSA_PKCS: - mechanism = AsymMech::RSA_SHA512_PKCS; - bAllowMultiPartOp = true; - isRSA = true; + case CKM_SHA384: + pssParam.hashAlg = HashAlgo::SHA384; + pssParam.mgf = AsymRSAMGF::MGF1_SHA384; + expectedMgf = CKG_MGF1_SHA384; break; -#ifdef WITH_RAW_PSS - case CKM_RSA_PKCS_PSS: - if (pMechanism->pParameter == NULL_PTR || - pMechanism->ulParameterLen != sizeof(CK_RSA_PKCS_PSS_PARAMS)) - { - ERROR_MSG("Invalid parameters"); - return CKR_ARGUMENTS_BAD; - } - mechanism = AsymMech::RSA_PKCS_PSS; - - 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; - expectedMgf = CKG_MGF1_SHA1; - break; - case CKM_SHA224: - pssParam.hashAlg = HashAlgo::SHA224; - pssParam.mgf = AsymRSAMGF::MGF1_SHA224; - expectedMgf = CKG_MGF1_SHA224; - break; - case CKM_SHA256: - pssParam.hashAlg = HashAlgo::SHA256; - pssParam.mgf = AsymRSAMGF::MGF1_SHA256; - expectedMgf = CKG_MGF1_SHA256; - break; - case CKM_SHA384: - pssParam.hashAlg = HashAlgo::SHA384; - pssParam.mgf = AsymRSAMGF::MGF1_SHA384; - expectedMgf = CKG_MGF1_SHA384; - break; - case CKM_SHA512: - pssParam.hashAlg = HashAlgo::SHA512; - pssParam.mgf = AsymRSAMGF::MGF1_SHA512; - expectedMgf = CKG_MGF1_SHA512; - break; - default: - return CKR_ARGUMENTS_BAD; - } - - if (CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->mgf != expectedMgf) { - return CKR_ARGUMENTS_BAD; - } - - pssParam.sLen = CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->sLen; - param = &pssParam; - paramLen = sizeof(pssParam); - bAllowMultiPartOp = false; - isRSA = true; - break; -#endif - case CKM_SHA1_RSA_PKCS_PSS: - if (pMechanism->pParameter == NULL_PTR || - pMechanism->ulParameterLen != sizeof(CK_RSA_PKCS_PSS_PARAMS) || - CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->hashAlg != CKM_SHA_1 || - CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->mgf != CKG_MGF1_SHA1) - { - ERROR_MSG("Invalid parameters"); - 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); - bAllowMultiPartOp = true; - isRSA = true; - break; - case CKM_SHA224_RSA_PKCS_PSS: - if (pMechanism->pParameter == NULL_PTR || - pMechanism->ulParameterLen != sizeof(CK_RSA_PKCS_PSS_PARAMS) || - CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->hashAlg != CKM_SHA224 || - CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->mgf != CKG_MGF1_SHA224) - { - ERROR_MSG("Invalid parameters"); - 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); - bAllowMultiPartOp = true; - isRSA = true; - break; - case CKM_SHA256_RSA_PKCS_PSS: - if (pMechanism->pParameter == NULL_PTR || - pMechanism->ulParameterLen != sizeof(CK_RSA_PKCS_PSS_PARAMS) || - CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->hashAlg != CKM_SHA256 || - CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->mgf != CKG_MGF1_SHA256) - { - ERROR_MSG("Invalid parameters"); - 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); - bAllowMultiPartOp = true; - isRSA = true; - break; - case CKM_SHA384_RSA_PKCS_PSS: - if (pMechanism->pParameter == NULL_PTR || - pMechanism->ulParameterLen != sizeof(CK_RSA_PKCS_PSS_PARAMS) || - CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->hashAlg != CKM_SHA384 || - CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->mgf != CKG_MGF1_SHA384) - { - ERROR_MSG("Invalid parameters"); - 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); - bAllowMultiPartOp = true; - isRSA = true; - break; - case CKM_SHA512_RSA_PKCS_PSS: - if (pMechanism->pParameter == NULL_PTR || - pMechanism->ulParameterLen != sizeof(CK_RSA_PKCS_PSS_PARAMS) || - CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->hashAlg != CKM_SHA512 || - CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->mgf != CKG_MGF1_SHA512) - { - ERROR_MSG("Invalid parameters"); - return CKR_ARGUMENTS_BAD; - } - mechanism = AsymMech::RSA_SHA512_PKCS_PSS; + case CKM_SHA512: 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); - bAllowMultiPartOp = true; - isRSA = true; - break; - case CKM_DSA: - mechanism = AsymMech::DSA; - bAllowMultiPartOp = false; - isDSA = true; - break; - case CKM_DSA_SHA1: - mechanism = AsymMech::DSA_SHA1; - bAllowMultiPartOp = true; - isDSA = true; - break; - case CKM_DSA_SHA224: - mechanism = AsymMech::DSA_SHA224; - bAllowMultiPartOp = true; - isDSA = true; - break; - case CKM_DSA_SHA256: - mechanism = AsymMech::DSA_SHA256; - bAllowMultiPartOp = true; - isDSA = true; - break; - case CKM_DSA_SHA384: - mechanism = AsymMech::DSA_SHA384; - bAllowMultiPartOp = true; - isDSA = true; - break; - case CKM_DSA_SHA512: - mechanism = AsymMech::DSA_SHA512; - bAllowMultiPartOp = true; - isDSA = true; + expectedMgf = CKG_MGF1_SHA512; break; + default: + return CKR_ARGUMENTS_BAD; + } + + if (CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->mgf != expectedMgf) + { + return CKR_ARGUMENTS_BAD; + } + + pssParam.sLen = CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->sLen; + param = &pssParam; + paramLen = sizeof(pssParam); + bAllowMultiPartOp = false; + isRSA = true; + break; +#endif + case CKM_SHA1_RSA_PKCS_PSS: + if (pMechanism->pParameter == NULL_PTR || + pMechanism->ulParameterLen != sizeof(CK_RSA_PKCS_PSS_PARAMS) || + CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->hashAlg != CKM_SHA_1 || + CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->mgf != CKG_MGF1_SHA1) + { + ERROR_MSG("Invalid parameters"); + 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); + bAllowMultiPartOp = true; + isRSA = true; + break; + case CKM_SHA224_RSA_PKCS_PSS: + if (pMechanism->pParameter == NULL_PTR || + pMechanism->ulParameterLen != sizeof(CK_RSA_PKCS_PSS_PARAMS) || + CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->hashAlg != CKM_SHA224 || + CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->mgf != CKG_MGF1_SHA224) + { + ERROR_MSG("Invalid parameters"); + 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); + bAllowMultiPartOp = true; + isRSA = true; + break; + case CKM_SHA256_RSA_PKCS_PSS: + if (pMechanism->pParameter == NULL_PTR || + pMechanism->ulParameterLen != sizeof(CK_RSA_PKCS_PSS_PARAMS) || + CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->hashAlg != CKM_SHA256 || + CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->mgf != CKG_MGF1_SHA256) + { + ERROR_MSG("Invalid parameters"); + 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); + bAllowMultiPartOp = true; + isRSA = true; + break; + case CKM_SHA384_RSA_PKCS_PSS: + if (pMechanism->pParameter == NULL_PTR || + pMechanism->ulParameterLen != sizeof(CK_RSA_PKCS_PSS_PARAMS) || + CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->hashAlg != CKM_SHA384 || + CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->mgf != CKG_MGF1_SHA384) + { + ERROR_MSG("Invalid parameters"); + 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); + bAllowMultiPartOp = true; + isRSA = true; + break; + case CKM_SHA512_RSA_PKCS_PSS: + if (pMechanism->pParameter == NULL_PTR || + pMechanism->ulParameterLen != sizeof(CK_RSA_PKCS_PSS_PARAMS) || + CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->hashAlg != CKM_SHA512 || + CK_RSA_PKCS_PSS_PARAMS_PTR(pMechanism->pParameter)->mgf != CKG_MGF1_SHA512) + { + ERROR_MSG("Invalid parameters"); + 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); + bAllowMultiPartOp = true; + isRSA = true; + break; + case CKM_DSA: + mechanism = AsymMech::DSA; + bAllowMultiPartOp = false; + isDSA = true; + break; + case CKM_DSA_SHA1: + mechanism = AsymMech::DSA_SHA1; + bAllowMultiPartOp = true; + isDSA = true; + break; + case CKM_DSA_SHA224: + mechanism = AsymMech::DSA_SHA224; + bAllowMultiPartOp = true; + isDSA = true; + break; + case CKM_DSA_SHA256: + mechanism = AsymMech::DSA_SHA256; + bAllowMultiPartOp = true; + isDSA = true; + break; + case CKM_DSA_SHA384: + mechanism = AsymMech::DSA_SHA384; + bAllowMultiPartOp = true; + isDSA = true; + break; + case CKM_DSA_SHA512: + mechanism = AsymMech::DSA_SHA512; + bAllowMultiPartOp = true; + isDSA = true; + break; #ifdef WITH_ECC - case CKM_ECDSA: - mechanism = AsymMech::ECDSA; - bAllowMultiPartOp = false; - isECDSA = true; - break; - case CKM_ECDSA_SHA1: - mechanism = AsymMech::ECDSA_SHA1; - bAllowMultiPartOp = false; - isECDSA = true; - break; - case CKM_ECDSA_SHA224: - mechanism = AsymMech::ECDSA_SHA224; - bAllowMultiPartOp = false; - isECDSA = true; - break; - case CKM_ECDSA_SHA256: - mechanism = AsymMech::ECDSA_SHA256; - bAllowMultiPartOp = false; - isECDSA = true; - break; - case CKM_ECDSA_SHA384: - mechanism = AsymMech::ECDSA_SHA384; - bAllowMultiPartOp = false; - isECDSA = true; - break; - case CKM_ECDSA_SHA512: - mechanism = AsymMech::ECDSA_SHA512; - bAllowMultiPartOp = false; - isECDSA = true; - break; + case CKM_ECDSA: + mechanism = AsymMech::ECDSA; + bAllowMultiPartOp = false; + isECDSA = true; + break; + case CKM_ECDSA_SHA1: + mechanism = AsymMech::ECDSA_SHA1; + bAllowMultiPartOp = false; + isECDSA = true; + break; + case CKM_ECDSA_SHA224: + mechanism = AsymMech::ECDSA_SHA224; + bAllowMultiPartOp = false; + isECDSA = true; + break; + case CKM_ECDSA_SHA256: + mechanism = AsymMech::ECDSA_SHA256; + bAllowMultiPartOp = false; + isECDSA = true; + break; + case CKM_ECDSA_SHA384: + mechanism = AsymMech::ECDSA_SHA384; + bAllowMultiPartOp = false; + isECDSA = true; + break; + case CKM_ECDSA_SHA512: + mechanism = AsymMech::ECDSA_SHA512; + bAllowMultiPartOp = false; + isECDSA = true; + break; #endif #ifdef WITH_GOST - case CKM_GOSTR3410: - mechanism = AsymMech::GOST; - bAllowMultiPartOp = false; - break; - case CKM_GOSTR3410_WITH_GOSTR3411: - mechanism = AsymMech::GOST_GOST; - bAllowMultiPartOp = true; - break; + case CKM_GOSTR3410: + mechanism = AsymMech::GOST; + bAllowMultiPartOp = false; + break; + case CKM_GOSTR3410_WITH_GOSTR3411: + mechanism = AsymMech::GOST_GOST; + bAllowMultiPartOp = true; + break; #endif #ifdef WITH_EDDSA - case CKM_EDDSA: - mechanism = AsymMech::EDDSA; - bAllowMultiPartOp = false; - isEDDSA = true; - break; + case CKM_EDDSA: + mechanism = AsymMech::EDDSA; + bAllowMultiPartOp = false; + isEDDSA = true; + break; #endif - default: - return CKR_MECHANISM_INVALID; + default: + return CKR_MECHANISM_INVALID; } - AsymmetricAlgorithm* asymCrypto = NULL; - PublicKey* publicKey = NULL; + AsymmetricAlgorithm *asymCrypto = NULL; + PublicKey *publicKey = NULL; if (isRSA) { asymCrypto = CryptoFactory::i()->getAsymmetricAlgorithm(AsymAlgo::RSA); - if (asymCrypto == NULL) return CKR_MECHANISM_INVALID; + if (asymCrypto == NULL) + return CKR_MECHANISM_INVALID; publicKey = asymCrypto->newPublicKey(); if (publicKey == NULL) @@ -5572,7 +5702,7 @@ CK_RV SoftHSM::AsymVerifyInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMech return CKR_HOST_MEMORY; } - if (getRSAPublicKey((RSAPublicKey*)publicKey, token, key) != CKR_OK) + if (getRSAPublicKey((RSAPublicKey *)publicKey, token, key) != CKR_OK) { asymCrypto->recyclePublicKey(publicKey); CryptoFactory::i()->recycleAsymmetricAlgorithm(asymCrypto); @@ -5582,7 +5712,8 @@ CK_RV SoftHSM::AsymVerifyInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMech else if (isDSA) { asymCrypto = CryptoFactory::i()->getAsymmetricAlgorithm(AsymAlgo::DSA); - if (asymCrypto == NULL) return CKR_MECHANISM_INVALID; + if (asymCrypto == NULL) + return CKR_MECHANISM_INVALID; publicKey = asymCrypto->newPublicKey(); if (publicKey == NULL) @@ -5591,18 +5722,19 @@ CK_RV SoftHSM::AsymVerifyInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMech return CKR_HOST_MEMORY; } - if (getDSAPublicKey((DSAPublicKey*)publicKey, token, key) != CKR_OK) + if (getDSAPublicKey((DSAPublicKey *)publicKey, token, key) != CKR_OK) { asymCrypto->recyclePublicKey(publicKey); CryptoFactory::i()->recycleAsymmetricAlgorithm(asymCrypto); return CKR_GENERAL_ERROR; } - } + } #ifdef WITH_ECC else if (isECDSA) { asymCrypto = CryptoFactory::i()->getAsymmetricAlgorithm(AsymAlgo::ECDSA); - if (asymCrypto == NULL) return CKR_MECHANISM_INVALID; + if (asymCrypto == NULL) + return CKR_MECHANISM_INVALID; publicKey = asymCrypto->newPublicKey(); if (publicKey == NULL) @@ -5611,7 +5743,7 @@ CK_RV SoftHSM::AsymVerifyInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMech return CKR_HOST_MEMORY; } - if (getECPublicKey((ECPublicKey*)publicKey, token, key) != CKR_OK) + if (getECPublicKey((ECPublicKey *)publicKey, token, key) != CKR_OK) { asymCrypto->recyclePublicKey(publicKey); CryptoFactory::i()->recycleAsymmetricAlgorithm(asymCrypto); @@ -5623,7 +5755,8 @@ CK_RV SoftHSM::AsymVerifyInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMech else if (isEDDSA) { asymCrypto = CryptoFactory::i()->getAsymmetricAlgorithm(AsymAlgo::EDDSA); - if (asymCrypto == NULL) return CKR_MECHANISM_INVALID; + if (asymCrypto == NULL) + return CKR_MECHANISM_INVALID; publicKey = asymCrypto->newPublicKey(); if (publicKey == NULL) @@ -5632,7 +5765,7 @@ CK_RV SoftHSM::AsymVerifyInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMech return CKR_HOST_MEMORY; } - if (getEDPublicKey((EDPublicKey*)publicKey, token, key) != CKR_OK) + if (getEDPublicKey((EDPublicKey *)publicKey, token, key) != CKR_OK) { asymCrypto->recyclePublicKey(publicKey); CryptoFactory::i()->recycleAsymmetricAlgorithm(asymCrypto); @@ -5644,7 +5777,8 @@ CK_RV SoftHSM::AsymVerifyInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMech { #ifdef WITH_GOST asymCrypto = CryptoFactory::i()->getAsymmetricAlgorithm(AsymAlgo::GOST); - if (asymCrypto == NULL) return CKR_MECHANISM_INVALID; + if (asymCrypto == NULL) + return CKR_MECHANISM_INVALID; publicKey = asymCrypto->newPublicKey(); if (publicKey == NULL) @@ -5653,7 +5787,7 @@ CK_RV SoftHSM::AsymVerifyInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMech return CKR_HOST_MEMORY; } - if (getGOSTPublicKey((GOSTPublicKey*)publicKey, token, key) != CKR_OK) + if (getGOSTPublicKey((GOSTPublicKey *)publicKey, token, key) != CKR_OK) { asymCrypto->recyclePublicKey(publicKey); CryptoFactory::i()->recycleAsymmetricAlgorithm(asymCrypto); @@ -5662,10 +5796,10 @@ CK_RV SoftHSM::AsymVerifyInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMech #else return CKR_MECHANISM_INVALID; #endif - } + } // Initialize verifying - if (bAllowMultiPartOp && !asymCrypto->verifyInit(publicKey,mechanism,param,paramLen)) + if (bAllowMultiPartOp && !asymCrypto->verifyInit(publicKey, mechanism, param, paramLen)) { asymCrypto->recyclePublicKey(publicKey); CryptoFactory::i()->recycleAsymmetricAlgorithm(asymCrypto); @@ -5693,9 +5827,9 @@ CK_RV SoftHSM::C_VerifyInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechan } // MacAlgorithm version of C_Verify -static CK_RV MacVerify(Session* session, CK_BYTE_PTR pData, CK_ULONG ulDataLen, CK_BYTE_PTR pSignature, CK_ULONG ulSignatureLen) +static CK_RV MacVerify(Session *session, CK_BYTE_PTR pData, CK_ULONG ulDataLen, CK_BYTE_PTR pSignature, CK_ULONG ulSignatureLen) { - MacAlgorithm* mac = session->getMacOp(); + MacAlgorithm *mac = session->getMacOp(); if (mac == NULL || !session->getAllowSinglePartOp()) { session->resetOp(); @@ -5738,13 +5872,13 @@ static CK_RV MacVerify(Session* session, CK_BYTE_PTR pData, CK_ULONG ulDataLen, } // AsymmetricAlgorithm version of C_Verify -static CK_RV AsymVerify(Session* session, CK_BYTE_PTR pData, CK_ULONG ulDataLen, CK_BYTE_PTR pSignature, CK_ULONG ulSignatureLen) +static CK_RV AsymVerify(Session *session, CK_BYTE_PTR pData, CK_ULONG ulDataLen, CK_BYTE_PTR pSignature, CK_ULONG ulSignatureLen) { - AsymmetricAlgorithm* asymCrypto = session->getAsymmetricCryptoOp(); + AsymmetricAlgorithm *asymCrypto = session->getAsymmetricCryptoOp(); AsymMech::Type mechanism = session->getMechanism(); - PublicKey* publicKey = session->getPublicKey(); + PublicKey *publicKey = session->getPublicKey(); size_t paramLen; - void* param = session->getParameters(paramLen); + void *param = session->getParameters(paramLen); if (asymCrypto == NULL || !session->getAllowSinglePartOp() || publicKey == NULL) { session->resetOp(); @@ -5766,8 +5900,9 @@ static CK_RV AsymVerify(Session* session, CK_BYTE_PTR pData, CK_ULONG ulDataLen, ByteString data; // We must allow input length <= k and therfore need to prepend the data with zeroes. - if (mechanism == AsymMech::RSA) { - data.wipe(size-ulDataLen); + if (mechanism == AsymMech::RSA) + { + data.wipe(size - ulDataLen); } data += ByteString(pData, ulDataLen); @@ -5777,13 +5912,13 @@ static CK_RV AsymVerify(Session* session, CK_BYTE_PTR pData, CK_ULONG ulDataLen, if (session->getAllowMultiPartOp()) { if (!asymCrypto->verifyUpdate(data) || - !asymCrypto->verifyFinal(signature)) + !asymCrypto->verifyFinal(signature)) { session->resetOp(); return CKR_SIGNATURE_INVALID; } } - else if (!asymCrypto->verify(publicKey,data,signature,mechanism,param,paramLen)) + else if (!asymCrypto->verify(publicKey, data, signature, mechanism, param, paramLen)) { session->resetOp(); return CKR_SIGNATURE_INVALID; @@ -5796,14 +5931,18 @@ static CK_RV AsymVerify(Session* session, CK_BYTE_PTR pData, CK_ULONG ulDataLen, // Perform a single pass verification operation CK_RV SoftHSM::C_Verify(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pData, CK_ULONG ulDataLen, CK_BYTE_PTR pSignature, CK_ULONG ulSignatureLen) { - if (!isInitialised) return CKR_CRYPTOKI_NOT_INITIALIZED; + if (!isInitialised) + return CKR_CRYPTOKI_NOT_INITIALIZED; - if (pData == NULL_PTR) return CKR_ARGUMENTS_BAD; - if (pSignature == NULL_PTR) return CKR_ARGUMENTS_BAD; + if (pData == NULL_PTR) + return CKR_ARGUMENTS_BAD; + if (pSignature == NULL_PTR) + return CKR_ARGUMENTS_BAD; // Get the session - Session* session = (Session*)handleManager->getSession(hSession); - if (session == NULL) return CKR_SESSION_HANDLE_INVALID; + Session *session = (Session *)handleManager->getSession(hSession); + if (session == NULL) + return CKR_SESSION_HANDLE_INVALID; // Check if we are doing the correct operation if (session->getOpType() != SESSION_OP_VERIFY) @@ -5811,16 +5950,16 @@ CK_RV SoftHSM::C_Verify(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pData, CK_ULONG if (session->getMacOp() != NULL) return MacVerify(session, pData, ulDataLen, - pSignature, ulSignatureLen); + pSignature, ulSignatureLen); else return AsymVerify(session, pData, ulDataLen, - pSignature, ulSignatureLen); + pSignature, ulSignatureLen); } // MacAlgorithm version of C_VerifyUpdate -static CK_RV MacVerifyUpdate(Session* session, CK_BYTE_PTR pPart, CK_ULONG ulPartLen) +static CK_RV MacVerifyUpdate(Session *session, CK_BYTE_PTR pPart, CK_ULONG ulPartLen) { - MacAlgorithm* mac = session->getMacOp(); + MacAlgorithm *mac = session->getMacOp(); if (mac == NULL || !session->getAllowMultiPartOp()) { session->resetOp(); @@ -5843,9 +5982,9 @@ static CK_RV MacVerifyUpdate(Session* session, CK_BYTE_PTR pPart, CK_ULONG ulPar } // AsymmetricAlgorithm version of C_VerifyUpdate -static CK_RV AsymVerifyUpdate(Session* session, CK_BYTE_PTR pPart, CK_ULONG ulPartLen) +static CK_RV AsymVerifyUpdate(Session *session, CK_BYTE_PTR pPart, CK_ULONG ulPartLen) { - AsymmetricAlgorithm* asymCrypto = session->getAsymmetricCryptoOp(); + AsymmetricAlgorithm *asymCrypto = session->getAsymmetricCryptoOp(); if (asymCrypto == NULL || !session->getAllowMultiPartOp()) { session->resetOp(); @@ -5870,13 +6009,16 @@ static CK_RV AsymVerifyUpdate(Session* session, CK_BYTE_PTR pPart, CK_ULONG ulPa // Update a running verification operation with additional data CK_RV SoftHSM::C_VerifyUpdate(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pPart, CK_ULONG ulPartLen) { - if (!isInitialised) return CKR_CRYPTOKI_NOT_INITIALIZED; + if (!isInitialised) + return CKR_CRYPTOKI_NOT_INITIALIZED; - if (pPart == NULL_PTR) return CKR_ARGUMENTS_BAD; + if (pPart == NULL_PTR) + return CKR_ARGUMENTS_BAD; // Get the session - Session* session = (Session*)handleManager->getSession(hSession); - if (session == NULL) return CKR_SESSION_HANDLE_INVALID; + Session *session = (Session *)handleManager->getSession(hSession); + if (session == NULL) + return CKR_SESSION_HANDLE_INVALID; // Check if we are doing the correct operation if (session->getOpType() != SESSION_OP_VERIFY) @@ -5889,9 +6031,9 @@ CK_RV SoftHSM::C_VerifyUpdate(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pPart, CK_ } // MacAlgorithm version of C_SignFinal -static CK_RV MacVerifyFinal(Session* session, CK_BYTE_PTR pSignature, CK_ULONG ulSignatureLen) +static CK_RV MacVerifyFinal(Session *session, CK_BYTE_PTR pSignature, CK_ULONG ulSignatureLen) { - MacAlgorithm* mac = session->getMacOp(); + MacAlgorithm *mac = session->getMacOp(); if (mac == NULL) { session->resetOp(); @@ -5924,10 +6066,10 @@ static CK_RV MacVerifyFinal(Session* session, CK_BYTE_PTR pSignature, CK_ULONG u } // AsymmetricAlgorithm version of C_VerifyFinal -static CK_RV AsymVerifyFinal(Session* session, CK_BYTE_PTR pSignature, CK_ULONG ulSignatureLen) +static CK_RV AsymVerifyFinal(Session *session, CK_BYTE_PTR pSignature, CK_ULONG ulSignatureLen) { - AsymmetricAlgorithm* asymCrypto = session->getAsymmetricCryptoOp(); - PublicKey* publicKey = session->getPublicKey(); + AsymmetricAlgorithm *asymCrypto = session->getAsymmetricCryptoOp(); + PublicKey *publicKey = session->getPublicKey(); if (asymCrypto == NULL || publicKey == NULL) { session->resetOp(); @@ -5962,13 +6104,16 @@ static CK_RV AsymVerifyFinal(Session* session, CK_BYTE_PTR pSignature, CK_ULONG // Finalise the verification operation and check the signature CK_RV SoftHSM::C_VerifyFinal(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pSignature, CK_ULONG ulSignatureLen) { - if (!isInitialised) return CKR_CRYPTOKI_NOT_INITIALIZED; + if (!isInitialised) + return CKR_CRYPTOKI_NOT_INITIALIZED; - if (pSignature == NULL_PTR) return CKR_ARGUMENTS_BAD; + if (pSignature == NULL_PTR) + return CKR_ARGUMENTS_BAD; // Get the session - Session* session = (Session*)handleManager->getSession(hSession); - if (session == NULL) return CKR_SESSION_HANDLE_INVALID; + Session *session = (Session *)handleManager->getSession(hSession); + if (session == NULL) + return CKR_SESSION_HANDLE_INVALID; // Check if we are doing the correct operation if (session->getOpType() != SESSION_OP_VERIFY || !session->getAllowMultiPartOp()) @@ -5983,14 +6128,17 @@ CK_RV SoftHSM::C_VerifyFinal(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pSignature, // Initialise a verification operation the allows recovery of the signed data from the signature CK_RV SoftHSM::C_VerifyRecoverInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR /*pMechanism*/, CK_OBJECT_HANDLE /*hKey*/) { - if (!isInitialised) return CKR_CRYPTOKI_NOT_INITIALIZED; + if (!isInitialised) + return CKR_CRYPTOKI_NOT_INITIALIZED; // Get the session - Session* session = (Session*)handleManager->getSession(hSession); - if (session == NULL) return CKR_SESSION_HANDLE_INVALID; + Session *session = (Session *)handleManager->getSession(hSession); + if (session == NULL) + return CKR_SESSION_HANDLE_INVALID; // Check if we have another operation - if (session->getOpType() != SESSION_OP_NONE) return CKR_OPERATION_ACTIVE; + if (session->getOpType() != SESSION_OP_NONE) + return CKR_OPERATION_ACTIVE; return CKR_FUNCTION_NOT_SUPPORTED; } @@ -5998,11 +6146,13 @@ CK_RV SoftHSM::C_VerifyRecoverInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR // Perform a single part verification operation and recover the signed data CK_RV SoftHSM::C_VerifyRecover(CK_SESSION_HANDLE hSession, CK_BYTE_PTR /*pSignature*/, CK_ULONG /*ulSignatureLen*/, CK_BYTE_PTR /*pData*/, CK_ULONG_PTR /*pulDataLen*/) { - if (!isInitialised) return CKR_CRYPTOKI_NOT_INITIALIZED; + if (!isInitialised) + return CKR_CRYPTOKI_NOT_INITIALIZED; // Get the session - Session* session = (Session*)handleManager->getSession(hSession); - if (session == NULL) return CKR_SESSION_HANDLE_INVALID; + Session *session = (Session *)handleManager->getSession(hSession); + if (session == NULL) + return CKR_SESSION_HANDLE_INVALID; return CKR_FUNCTION_NOT_SUPPORTED; } @@ -6010,11 +6160,13 @@ CK_RV SoftHSM::C_VerifyRecover(CK_SESSION_HANDLE hSession, CK_BYTE_PTR /*pSignat // Update a running multi-part encryption and digesting operation CK_RV SoftHSM::C_DigestEncryptUpdate(CK_SESSION_HANDLE hSession, CK_BYTE_PTR /*pPart*/, CK_ULONG /*ulPartLen*/, CK_BYTE_PTR /*pEncryptedPart*/, CK_ULONG_PTR /*pulEncryptedPartLen*/) { - if (!isInitialised) return CKR_CRYPTOKI_NOT_INITIALIZED; + if (!isInitialised) + return CKR_CRYPTOKI_NOT_INITIALIZED; // Get the session - Session* session = (Session*)handleManager->getSession(hSession); - if (session == NULL) return CKR_SESSION_HANDLE_INVALID; + Session *session = (Session *)handleManager->getSession(hSession); + if (session == NULL) + return CKR_SESSION_HANDLE_INVALID; return CKR_FUNCTION_NOT_SUPPORTED; } @@ -6022,11 +6174,13 @@ CK_RV SoftHSM::C_DigestEncryptUpdate(CK_SESSION_HANDLE hSession, CK_BYTE_PTR /*p // Update a running multi-part decryption and digesting operation CK_RV SoftHSM::C_DecryptDigestUpdate(CK_SESSION_HANDLE hSession, CK_BYTE_PTR /*pPart*/, CK_ULONG /*ulPartLen*/, CK_BYTE_PTR /*pDecryptedPart*/, CK_ULONG_PTR /*pulDecryptedPartLen*/) { - if (!isInitialised) return CKR_CRYPTOKI_NOT_INITIALIZED; + if (!isInitialised) + return CKR_CRYPTOKI_NOT_INITIALIZED; // Get the session - Session* session = (Session*)handleManager->getSession(hSession); - if (session == NULL) return CKR_SESSION_HANDLE_INVALID; + Session *session = (Session *)handleManager->getSession(hSession); + if (session == NULL) + return CKR_SESSION_HANDLE_INVALID; return CKR_FUNCTION_NOT_SUPPORTED; } @@ -6034,11 +6188,13 @@ CK_RV SoftHSM::C_DecryptDigestUpdate(CK_SESSION_HANDLE hSession, CK_BYTE_PTR /*p // Update a running multi-part signing and encryption operation CK_RV SoftHSM::C_SignEncryptUpdate(CK_SESSION_HANDLE hSession, CK_BYTE_PTR /*pPart*/, CK_ULONG /*ulPartLen*/, CK_BYTE_PTR /*pEncryptedPart*/, CK_ULONG_PTR /*pulEncryptedPartLen*/) { - if (!isInitialised) return CKR_CRYPTOKI_NOT_INITIALIZED; + if (!isInitialised) + return CKR_CRYPTOKI_NOT_INITIALIZED; // Get the session - Session* session = (Session*)handleManager->getSession(hSession); - if (session == NULL) return CKR_SESSION_HANDLE_INVALID; + Session *session = (Session *)handleManager->getSession(hSession); + if (session == NULL) + return CKR_SESSION_HANDLE_INVALID; return CKR_FUNCTION_NOT_SUPPORTED; } @@ -6046,11 +6202,13 @@ CK_RV SoftHSM::C_SignEncryptUpdate(CK_SESSION_HANDLE hSession, CK_BYTE_PTR /*pPa // Update a running multi-part decryption and verification operation CK_RV SoftHSM::C_DecryptVerifyUpdate(CK_SESSION_HANDLE hSession, CK_BYTE_PTR /*pEncryptedPart*/, CK_ULONG /*ulEncryptedPartLen*/, CK_BYTE_PTR /*pPart*/, CK_ULONG_PTR /*pulPartLen*/) { - if (!isInitialised) return CKR_CRYPTOKI_NOT_INITIALIZED; + if (!isInitialised) + return CKR_CRYPTOKI_NOT_INITIALIZED; // Get the session - Session* session = (Session*)handleManager->getSession(hSession); - if (session == NULL) return CKR_SESSION_HANDLE_INVALID; + Session *session = (Session *)handleManager->getSession(hSession); + if (session == NULL) + return CKR_SESSION_HANDLE_INVALID; return CKR_FUNCTION_NOT_SUPPORTED; } @@ -6058,15 +6216,20 @@ CK_RV SoftHSM::C_DecryptVerifyUpdate(CK_SESSION_HANDLE hSession, CK_BYTE_PTR /*p // Generate a secret key or a domain parameter set using the specified mechanism CK_RV SoftHSM::C_GenerateKey(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechanism, CK_ATTRIBUTE_PTR pTemplate, CK_ULONG ulCount, CK_OBJECT_HANDLE_PTR phKey) { - if (!isInitialised) return CKR_CRYPTOKI_NOT_INITIALIZED; + if (!isInitialised) + return CKR_CRYPTOKI_NOT_INITIALIZED; - if (pMechanism == NULL_PTR) return CKR_ARGUMENTS_BAD; - if (pTemplate == NULL_PTR && ulCount != 0) return CKR_ARGUMENTS_BAD; - if (phKey == NULL_PTR) return CKR_ARGUMENTS_BAD; + if (pMechanism == NULL_PTR) + return CKR_ARGUMENTS_BAD; + if (pTemplate == NULL_PTR && ulCount != 0) + return CKR_ARGUMENTS_BAD; + if (phKey == NULL_PTR) + return CKR_ARGUMENTS_BAD; // Get the session - Session* session = (Session*)handleManager->getSession(hSession); - if (session == NULL) return CKR_SESSION_HANDLE_INVALID; + Session *session = (Session *)handleManager->getSession(hSession); + if (session == NULL) + return CKR_SESSION_HANDLE_INVALID; // Check the mechanism, only accept DSA and DH parameters // and symmetric ciphers @@ -6074,38 +6237,38 @@ CK_RV SoftHSM::C_GenerateKey(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMecha CK_KEY_TYPE keyType; switch (pMechanism->mechanism) { - case CKM_DSA_PARAMETER_GEN: - objClass = CKO_DOMAIN_PARAMETERS; - keyType = CKK_DSA; - break; - case CKM_DH_PKCS_PARAMETER_GEN: - objClass = CKO_DOMAIN_PARAMETERS; - keyType = CKK_DH; - break; + case CKM_DSA_PARAMETER_GEN: + objClass = CKO_DOMAIN_PARAMETERS; + keyType = CKK_DSA; + break; + case CKM_DH_PKCS_PARAMETER_GEN: + objClass = CKO_DOMAIN_PARAMETERS; + keyType = CKK_DH; + break; #ifndef WITH_FIPS - case CKM_DES_KEY_GEN: - objClass = CKO_SECRET_KEY; - keyType = CKK_DES; - break; + case CKM_DES_KEY_GEN: + objClass = CKO_SECRET_KEY; + keyType = CKK_DES; + break; #endif - case CKM_DES2_KEY_GEN: - objClass = CKO_SECRET_KEY; - keyType = CKK_DES2; - break; - case CKM_DES3_KEY_GEN: - objClass = CKO_SECRET_KEY; - keyType = CKK_DES3; - break; - case CKM_AES_KEY_GEN: - objClass = CKO_SECRET_KEY; - keyType = CKK_AES; - break; - case CKM_GENERIC_SECRET_KEY_GEN: - objClass = CKO_SECRET_KEY; - keyType = CKK_GENERIC_SECRET; - break; - default: - return CKR_MECHANISM_INVALID; + case CKM_DES2_KEY_GEN: + objClass = CKO_SECRET_KEY; + keyType = CKK_DES2; + break; + case CKM_DES3_KEY_GEN: + objClass = CKO_SECRET_KEY; + keyType = CKK_DES3; + break; + case CKM_AES_KEY_GEN: + objClass = CKO_SECRET_KEY; + keyType = CKK_AES; + break; + case CKM_GENERIC_SECRET_KEY_GEN: + objClass = CKO_SECRET_KEY; + keyType = CKK_GENERIC_SECRET; + break; + default: + return CKR_MECHANISM_INVALID; } // Extract information from the template that is needed to create the object. @@ -6119,25 +6282,25 @@ CK_RV SoftHSM::C_GenerateKey(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMecha if (objClass != CKO_SECRET_KEY && objClass != CKO_DOMAIN_PARAMETERS) return CKR_ATTRIBUTE_VALUE_INVALID; if (pMechanism->mechanism == CKM_DSA_PARAMETER_GEN && - (objClass != CKO_DOMAIN_PARAMETERS || keyType != CKK_DSA)) + (objClass != CKO_DOMAIN_PARAMETERS || keyType != CKK_DSA)) return CKR_TEMPLATE_INCONSISTENT; if (pMechanism->mechanism == CKM_DH_PKCS_PARAMETER_GEN && - (objClass != CKO_DOMAIN_PARAMETERS || keyType != CKK_DH)) + (objClass != CKO_DOMAIN_PARAMETERS || keyType != CKK_DH)) return CKR_TEMPLATE_INCONSISTENT; if (pMechanism->mechanism == CKM_DES_KEY_GEN && - (objClass != CKO_SECRET_KEY || keyType != CKK_DES)) + (objClass != CKO_SECRET_KEY || keyType != CKK_DES)) return CKR_TEMPLATE_INCONSISTENT; if (pMechanism->mechanism == CKM_DES2_KEY_GEN && - (objClass != CKO_SECRET_KEY || keyType != CKK_DES2)) + (objClass != CKO_SECRET_KEY || keyType != CKK_DES2)) return CKR_TEMPLATE_INCONSISTENT; if (pMechanism->mechanism == CKM_DES3_KEY_GEN && - (objClass != CKO_SECRET_KEY || keyType != CKK_DES3)) + (objClass != CKO_SECRET_KEY || keyType != CKK_DES3)) return CKR_TEMPLATE_INCONSISTENT; if (pMechanism->mechanism == CKM_AES_KEY_GEN && - (objClass != CKO_SECRET_KEY || keyType != CKK_AES)) + (objClass != CKO_SECRET_KEY || keyType != CKK_AES)) return CKR_TEMPLATE_INCONSISTENT; if (pMechanism->mechanism == CKM_GENERIC_SECRET_KEY_GEN && - (objClass != CKO_SECRET_KEY || keyType != CKK_GENERIC_SECRET)) + (objClass != CKO_SECRET_KEY || keyType != CKK_GENERIC_SECRET)) return CKR_TEMPLATE_INCONSISTENT; // Check authorization @@ -6198,8 +6361,7 @@ CK_RV SoftHSM::C_GenerateKey(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMecha } // Generate a key-pair using the specified mechanism -CK_RV SoftHSM::C_GenerateKeyPair -( +CK_RV SoftHSM::C_GenerateKeyPair( CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechanism, CK_ATTRIBUTE_PTR pPublicKeyTemplate, @@ -6207,51 +6369,57 @@ CK_RV SoftHSM::C_GenerateKeyPair CK_ATTRIBUTE_PTR pPrivateKeyTemplate, CK_ULONG ulPrivateKeyAttributeCount, CK_OBJECT_HANDLE_PTR phPublicKey, - CK_OBJECT_HANDLE_PTR phPrivateKey -) + CK_OBJECT_HANDLE_PTR phPrivateKey) { - if (!isInitialised) return CKR_CRYPTOKI_NOT_INITIALIZED; + if (!isInitialised) + return CKR_CRYPTOKI_NOT_INITIALIZED; - if (pMechanism == NULL_PTR) return CKR_ARGUMENTS_BAD; - if (pPublicKeyTemplate == NULL_PTR && ulPublicKeyAttributeCount != 0) return CKR_ARGUMENTS_BAD; - if (pPrivateKeyTemplate == NULL_PTR && ulPrivateKeyAttributeCount != 0) return CKR_ARGUMENTS_BAD; - if (phPublicKey == NULL_PTR) return CKR_ARGUMENTS_BAD; - if (phPrivateKey == NULL_PTR) return CKR_ARGUMENTS_BAD; + if (pMechanism == NULL_PTR) + return CKR_ARGUMENTS_BAD; + if (pPublicKeyTemplate == NULL_PTR && ulPublicKeyAttributeCount != 0) + return CKR_ARGUMENTS_BAD; + if (pPrivateKeyTemplate == NULL_PTR && ulPrivateKeyAttributeCount != 0) + return CKR_ARGUMENTS_BAD; + if (phPublicKey == NULL_PTR) + return CKR_ARGUMENTS_BAD; + if (phPrivateKey == NULL_PTR) + return CKR_ARGUMENTS_BAD; // Get the session - Session* session = (Session*)handleManager->getSession(hSession); - if (session == NULL) return CKR_SESSION_HANDLE_INVALID; + Session *session = (Session *)handleManager->getSession(hSession); + if (session == NULL) + return CKR_SESSION_HANDLE_INVALID; // Check the mechanism, only accept RSA, DSA, EC and DH key pair generation. CK_KEY_TYPE keyType; switch (pMechanism->mechanism) { - case CKM_RSA_PKCS_KEY_PAIR_GEN: - keyType = CKK_RSA; - break; - case CKM_DSA_KEY_PAIR_GEN: - keyType = CKK_DSA; - break; - case CKM_DH_PKCS_KEY_PAIR_GEN: - keyType = CKK_DH; - break; + case CKM_RSA_PKCS_KEY_PAIR_GEN: + keyType = CKK_RSA; + break; + case CKM_DSA_KEY_PAIR_GEN: + keyType = CKK_DSA; + break; + case CKM_DH_PKCS_KEY_PAIR_GEN: + keyType = CKK_DH; + break; #ifdef WITH_ECC - case CKM_EC_KEY_PAIR_GEN: - keyType = CKK_EC; - break; + case CKM_EC_KEY_PAIR_GEN: + keyType = CKK_EC; + break; #endif #ifdef WITH_GOST - case CKM_GOSTR3410_KEY_PAIR_GEN: - keyType = CKK_GOSTR3410; - break; + case CKM_GOSTR3410_KEY_PAIR_GEN: + keyType = CKK_GOSTR3410; + break; #endif #ifdef WITH_EDDSA - case CKM_EC_EDWARDS_KEY_PAIR_GEN: - keyType = CKK_EC_EDWARDS; - break; + case CKM_EC_EDWARDS_KEY_PAIR_GEN: + keyType = CKK_EC_EDWARDS; + break; #endif - default: - return CKR_MECHANISM_INVALID; + default: + return CKR_MECHANISM_INVALID; } CK_CERTIFICATE_TYPE dummy; @@ -6316,73 +6484,72 @@ CK_RV SoftHSM::C_GenerateKeyPair // Generate RSA keys if (pMechanism->mechanism == CKM_RSA_PKCS_KEY_PAIR_GEN) { - return this->generateRSA(hSession, - pPublicKeyTemplate, ulPublicKeyAttributeCount, - pPrivateKeyTemplate, ulPrivateKeyAttributeCount, - phPublicKey, phPrivateKey, - ispublicKeyToken, ispublicKeyPrivate, isprivateKeyToken, isprivateKeyPrivate); + return this->generateRSA(hSession, + pPublicKeyTemplate, ulPublicKeyAttributeCount, + pPrivateKeyTemplate, ulPrivateKeyAttributeCount, + phPublicKey, phPrivateKey, + ispublicKeyToken, ispublicKeyPrivate, isprivateKeyToken, isprivateKeyPrivate); } // Generate DSA keys if (pMechanism->mechanism == CKM_DSA_KEY_PAIR_GEN) { - return this->generateDSA(hSession, - pPublicKeyTemplate, ulPublicKeyAttributeCount, - pPrivateKeyTemplate, ulPrivateKeyAttributeCount, - phPublicKey, phPrivateKey, - ispublicKeyToken, ispublicKeyPrivate, isprivateKeyToken, isprivateKeyPrivate); + return this->generateDSA(hSession, + pPublicKeyTemplate, ulPublicKeyAttributeCount, + pPrivateKeyTemplate, ulPrivateKeyAttributeCount, + phPublicKey, phPrivateKey, + ispublicKeyToken, ispublicKeyPrivate, isprivateKeyToken, isprivateKeyPrivate); } // Generate EC keys if (pMechanism->mechanism == CKM_EC_KEY_PAIR_GEN) { - return this->generateEC(hSession, - pPublicKeyTemplate, ulPublicKeyAttributeCount, - pPrivateKeyTemplate, ulPrivateKeyAttributeCount, - phPublicKey, phPrivateKey, - ispublicKeyToken, ispublicKeyPrivate, isprivateKeyToken, isprivateKeyPrivate); + return this->generateEC(hSession, + pPublicKeyTemplate, ulPublicKeyAttributeCount, + pPrivateKeyTemplate, ulPrivateKeyAttributeCount, + phPublicKey, phPrivateKey, + ispublicKeyToken, ispublicKeyPrivate, isprivateKeyToken, isprivateKeyPrivate); } // Generate DH keys if (pMechanism->mechanism == CKM_DH_PKCS_KEY_PAIR_GEN) { - return this->generateDH(hSession, - pPublicKeyTemplate, ulPublicKeyAttributeCount, - pPrivateKeyTemplate, ulPrivateKeyAttributeCount, - phPublicKey, phPrivateKey, - ispublicKeyToken, ispublicKeyPrivate, isprivateKeyToken, isprivateKeyPrivate); + return this->generateDH(hSession, + pPublicKeyTemplate, ulPublicKeyAttributeCount, + pPrivateKeyTemplate, ulPrivateKeyAttributeCount, + phPublicKey, phPrivateKey, + ispublicKeyToken, ispublicKeyPrivate, isprivateKeyToken, isprivateKeyPrivate); } // Generate GOST keys if (pMechanism->mechanism == CKM_GOSTR3410_KEY_PAIR_GEN) { - return this->generateGOST(hSession, - pPublicKeyTemplate, ulPublicKeyAttributeCount, - pPrivateKeyTemplate, ulPrivateKeyAttributeCount, - phPublicKey, phPrivateKey, - ispublicKeyToken, ispublicKeyPrivate, isprivateKeyToken, isprivateKeyPrivate); + return this->generateGOST(hSession, + pPublicKeyTemplate, ulPublicKeyAttributeCount, + pPrivateKeyTemplate, ulPrivateKeyAttributeCount, + phPublicKey, phPrivateKey, + ispublicKeyToken, ispublicKeyPrivate, isprivateKeyToken, isprivateKeyPrivate); } // Generate EDDSA keys if (pMechanism->mechanism == CKM_EC_EDWARDS_KEY_PAIR_GEN) { - return this->generateED(hSession, - pPublicKeyTemplate, ulPublicKeyAttributeCount, - pPrivateKeyTemplate, ulPrivateKeyAttributeCount, - phPublicKey, phPrivateKey, - ispublicKeyToken, ispublicKeyPrivate, isprivateKeyToken, isprivateKeyPrivate); + return this->generateED(hSession, + pPublicKeyTemplate, ulPublicKeyAttributeCount, + pPrivateKeyTemplate, ulPrivateKeyAttributeCount, + phPublicKey, phPrivateKey, + ispublicKeyToken, ispublicKeyPrivate, isprivateKeyToken, isprivateKeyPrivate); } return CKR_GENERAL_ERROR; } - // PKCS#7 padding size_t SoftHSM::RFC5652Pad(ByteString &keydata, size_t blocksize) { size_t wrappedlen = keydata.size(); auto padbytes = blocksize - (wrappedlen % blocksize); - if(padbytes == 0) + if (padbytes == 0) padbytes += blocksize; keydata.resize(wrappedlen + padbytes); @@ -6390,7 +6557,6 @@ size_t SoftHSM::RFC5652Pad(ByteString &keydata, size_t blocksize) return keydata.size(); } - // CKM_AES_KEY_WRAP unpadding size_t SoftHSM::RFC3394Pad(ByteString &keydata) { @@ -6413,23 +6579,23 @@ bool SoftHSM::RFC5652Unpad(ByteString &padded, size_t blocksize) { auto wrappedlen = padded.size(); - if( wrappedlen % blocksize != 0) + if (wrappedlen % blocksize != 0) { DEBUG_MSG("padded buffer length %d is not a multiple of %d", wrappedlen, blocksize); return false; } - auto padbyte = padded[wrappedlen-1]; + auto padbyte = padded[wrappedlen - 1]; - if( padbyte == 0 || padbyte > blocksize ) + if (padbyte == 0 || padbyte > blocksize) { DEBUG_MSG("invalid padbyte value %d, larger than blocksize %d", padbyte, blocksize); return false; } - for(auto i = wrappedlen-padbyte; imechanism) { + switch (pMechanism->mechanism) + { #ifdef HAVE_AES_KEY_WRAP - case CKM_AES_KEY_WRAP: - wrappedlen = RFC3394Pad(keydata); - if ((wrappedlen < 16) || ((wrappedlen % 8) != 0)) - return CKR_KEY_SIZE_RANGE; - algo = SymAlgo::AES; - mode = SymWrap::AES_KEYWRAP; - break; + case CKM_AES_KEY_WRAP: + wrappedlen = RFC3394Pad(keydata); + if ((wrappedlen < 16) || ((wrappedlen % 8) != 0)) + return CKR_KEY_SIZE_RANGE; + algo = SymAlgo::AES; + mode = SymWrap::AES_KEYWRAP; + break; #endif #ifdef HAVE_AES_KEY_WRAP_PAD - case CKM_AES_KEY_WRAP_PAD: - algo = SymAlgo::AES; - mode = SymWrap::AES_KEYWRAP_PAD; - break; + case CKM_AES_KEY_WRAP_PAD: + algo = SymAlgo::AES; + mode = SymWrap::AES_KEYWRAP_PAD; + break; #endif - case CKM_AES_CBC: - algo = SymAlgo::AES; - break; - - case CKM_AES_CBC_PAD: - blocksize = 16; - wrappedlen = RFC5652Pad(keydata, blocksize); - algo = SymAlgo::AES; - break; - - case CKM_DES3_CBC: - algo = SymAlgo::DES3; - break; - - case CKM_DES3_CBC_PAD: - blocksize = 8; - wrappedlen = RFC5652Pad(keydata, blocksize); - algo = SymAlgo::DES3; - break; - - default: - return CKR_MECHANISM_INVALID; + case CKM_AES_CBC: + algo = SymAlgo::AES; + break; + + case CKM_AES_CBC_PAD: + blocksize = 16; + wrappedlen = RFC5652Pad(keydata, blocksize); + algo = SymAlgo::AES; + break; + + case CKM_DES3_CBC: + algo = SymAlgo::DES3; + break; + + case CKM_DES3_CBC_PAD: + blocksize = 8; + wrappedlen = RFC5652Pad(keydata, blocksize); + algo = SymAlgo::DES3; + break; + + default: + return CKR_MECHANISM_INVALID; } - SymmetricAlgorithm* cipher = CryptoFactory::i()->getSymmetricAlgorithm(algo); - if (cipher == NULL) return CKR_MECHANISM_INVALID; + SymmetricAlgorithm *cipher = CryptoFactory::i()->getSymmetricAlgorithm(algo); + if (cipher == NULL) + return CKR_MECHANISM_INVALID; - SymmetricKey* wrappingkey = new SymmetricKey(); + SymmetricKey *wrappingkey = new SymmetricKey(); if (getSymmetricKey(wrappingkey, token, wrapKey) != CKR_OK) { @@ -6523,185 +6688,143 @@ CK_RV SoftHSM::WrapKeySym ByteString iv; ByteString encryptedFinal; - switch(pMechanism->mechanism) { - - case CKM_AES_CBC: - case CKM_AES_CBC_PAD: - case CKM_DES3_CBC: - case CKM_DES3_CBC_PAD: - iv.resize(blocksize); - memcpy(&iv[0], pMechanism->pParameter, blocksize); - - if (!cipher->encryptInit(wrappingkey, SymMode::CBC, iv, false)) - { - cipher->recycleKey(wrappingkey); - CryptoFactory::i()->recycleSymmetricAlgorithm(cipher); - return CKR_MECHANISM_INVALID; - } - if (!cipher->encryptUpdate(keydata, wrapped)) - { - cipher->recycleKey(wrappingkey); - CryptoFactory::i()->recycleSymmetricAlgorithm(cipher); - return CKR_GENERAL_ERROR; - } - // Finalize encryption - if (!cipher->encryptFinal(encryptedFinal)) - { - cipher->recycleKey(wrappingkey); - CryptoFactory::i()->recycleSymmetricAlgorithm(cipher); - return CKR_GENERAL_ERROR; - } - wrapped += encryptedFinal; - break; - default: - // Wrap the key - if (!cipher->wrapKey(wrappingkey, mode, keydata, wrapped)) - { - cipher->recycleKey(wrappingkey); - CryptoFactory::i()->recycleSymmetricAlgorithm(cipher); - return CKR_GENERAL_ERROR; - } - } + switch (pMechanism->mechanism) + { - cipher->recycleKey(wrappingkey); - CryptoFactory::i()->recycleSymmetricAlgorithm(cipher); - return CKR_OK; -} + case CKM_AES_CBC: + case CKM_AES_CBC_PAD: + case CKM_DES3_CBC: + case CKM_DES3_CBC_PAD: + iv.resize(blocksize); + memcpy(&iv[0], pMechanism->pParameter, blocksize); -// Internal: Wrap blob using asymmetric key -CK_RV SoftHSM::WrapKeyAsym -( - CK_MECHANISM_PTR pMechanism, - Token* token, - OSObject* wrapKey, - ByteString& keydata, - ByteString& wrapped -) -{ - const size_t bb = 8; - AsymAlgo::Type algo = AsymAlgo::Unknown; - AsymMech::Type mech = AsymMech::Unknown; - void *parameters = NULL; - size_t paramLen = 0; + if (!cipher->encryptInit(wrappingkey, SymMode::CBC, iv, false)) + { + cipher->recycleKey(wrappingkey); + CryptoFactory::i()->recycleSymmetricAlgorithm(cipher); + return CKR_MECHANISM_INVALID; + } + if (!cipher->encryptUpdate(keydata, wrapped)) + { + cipher->recycleKey(wrappingkey); + CryptoFactory::i()->recycleSymmetricAlgorithm(cipher); + return CKR_GENERAL_ERROR; + } + // Finalize encryption + if (!cipher->encryptFinal(encryptedFinal)) + { + cipher->recycleKey(wrappingkey); + CryptoFactory::i()->recycleSymmetricAlgorithm(cipher); + return CKR_GENERAL_ERROR; + } + wrapped += encryptedFinal; + break; + default: + // Wrap the key + if (!cipher->wrapKey(wrappingkey, mode, keydata, wrapped)) + { + cipher->recycleKey(wrappingkey); + CryptoFactory::i()->recycleSymmetricAlgorithm(cipher); + return CKR_GENERAL_ERROR; + } + } + + cipher->recycleKey(wrappingkey); + CryptoFactory::i()->recycleSymmetricAlgorithm(cipher); + return CKR_OK; +} + +// Internal: Wrap blob using asymmetric key +CK_RV SoftHSM::WrapKeyAsym( + CK_MECHANISM_PTR pMechanism, + Token *token, + OSObject *wrapKey, + ByteString &keydata, + ByteString &wrapped) +{ + CK_RV rv = CKR_OK; + const size_t bb = 8; + AsymAlgo::Type algo = AsymAlgo::Unknown; + AsymMech::Type mech = AsymMech::Unknown; + void *parameters = NULL; + size_t paramLen = 0; size_t hashLen = 0; - RSA_PKCS_OAEP_PARAMS oaep_parameters; if (pMechanism->mechanism == CKM_RSA_PKCS_OAEP) { - CK_RSA_PKCS_OAEP_PARAMS* par1 = (CK_RSA_PKCS_OAEP_PARAMS*) pMechanism->pParameter; - switch (par1->hashAlg) - { - case CKM_SHA_1: - oaep_parameters.hashAlg = HashAlgo::SHA1; - hashLen = 20; - break; - case CKM_SHA224: - oaep_parameters.hashAlg = HashAlgo::SHA224; - hashLen = 28; - break; - case CKM_SHA256: - oaep_parameters.hashAlg = HashAlgo::SHA256; - hashLen = 32; - break; - case CKM_SHA384: - oaep_parameters.hashAlg = HashAlgo::SHA384; - hashLen = 48; - break; - case CKM_SHA512: - oaep_parameters.hashAlg = HashAlgo::SHA512; - hashLen = 64; - break; - default: - return CKR_ARGUMENTS_BAD; - } - switch (par1->mgf) + rv = BuildRSAOAEPParam((CK_RSA_PKCS_OAEP_PARAMS *)pMechanism->pParameter, + ¶meters,¶mLen,&hashLen); + if (rv != CKR_OK) { - case CKG_MGF1_SHA1: - oaep_parameters.mgf = AsymRSAMGF::MGF1_SHA1; - break; - case CKG_MGF1_SHA224: - oaep_parameters.mgf = AsymRSAMGF::MGF1_SHA224; - break; - case CKG_MGF1_SHA256: - oaep_parameters.mgf = AsymRSAMGF::MGF1_SHA256; - break; - case CKG_MGF1_SHA384: - oaep_parameters.mgf = AsymRSAMGF::MGF1_SHA384; - break; - case CKG_MGF1_SHA512: - oaep_parameters.mgf = AsymRSAMGF::MGF1_SHA512; - break; - default: - return CKR_ARGUMENTS_BAD; - } - oaep_parameters.sourceData = par1->pSourceData; - oaep_parameters.sourceDataLen = par1->ulSourceDataLen; - parameters = &oaep_parameters; - paramLen = sizeof(RSA_PKCS_OAEP_PARAMS); + return rv; + } } CK_ULONG modulus_length; - switch(pMechanism->mechanism) { - case CKM_RSA_PKCS: - case CKM_RSA_PKCS_OAEP: - algo = AsymAlgo::RSA; - if (!wrapKey->attributeExists(CKA_MODULUS_BITS)) - return CKR_GENERAL_ERROR; - modulus_length = wrapKey->getUnsignedLongValue(CKA_MODULUS_BITS, 0); - // adjust key bit length - modulus_length /= bb; - break; + switch (pMechanism->mechanism) + { + case CKM_RSA_PKCS: + case CKM_RSA_PKCS_OAEP: + algo = AsymAlgo::RSA; + if (!wrapKey->attributeExists(CKA_MODULUS_BITS)) + return CKR_GENERAL_ERROR; + modulus_length = wrapKey->getUnsignedLongValue(CKA_MODULUS_BITS, 0); + // adjust key bit length + modulus_length /= bb; + break; - default: - return CKR_MECHANISM_INVALID; + default: + return CKR_MECHANISM_INVALID; } - switch(pMechanism->mechanism) { - case CKM_RSA_PKCS: - mech = AsymMech::RSA_PKCS; - // RFC 3447 section 7.2.1 - if (keydata.size() > modulus_length - 11) - return CKR_KEY_SIZE_RANGE; - break; + switch (pMechanism->mechanism) + { + case CKM_RSA_PKCS: + mech = AsymMech::RSA_PKCS; + // RFC 3447 section 7.2.1 + if (keydata.size() > modulus_length - 11) + return CKR_KEY_SIZE_RANGE; + break; - 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 * hashLen)) - return CKR_KEY_SIZE_RANGE; - break; + case CKM_RSA_PKCS_OAEP: + mech = AsymMech::RSA_PKCS_OAEP; + // PKCS#11 2.40 draft 2 section 2.1.8: input length <= k-2-2hashLen + if (keydata.size() > modulus_length - 2 - (2 * hashLen)) + return CKR_KEY_SIZE_RANGE; + break; - default: - return CKR_MECHANISM_INVALID; + default: + return CKR_MECHANISM_INVALID; } - AsymmetricAlgorithm* cipher = CryptoFactory::i()->getAsymmetricAlgorithm(algo); - if (cipher == NULL) return CKR_MECHANISM_INVALID; + AsymmetricAlgorithm *cipher = CryptoFactory::i()->getAsymmetricAlgorithm(algo); + if (cipher == NULL) + return CKR_MECHANISM_INVALID; - PublicKey* publicKey = cipher->newPublicKey(); + PublicKey *publicKey = cipher->newPublicKey(); if (publicKey == NULL) { CryptoFactory::i()->recycleAsymmetricAlgorithm(cipher); return CKR_HOST_MEMORY; } - switch(pMechanism->mechanism) { - case CKM_RSA_PKCS: - case CKM_RSA_PKCS_OAEP: - if (getRSAPublicKey((RSAPublicKey*)publicKey, token, wrapKey) != CKR_OK) - { - cipher->recyclePublicKey(publicKey); - CryptoFactory::i()->recycleAsymmetricAlgorithm(cipher); - return CKR_GENERAL_ERROR; - } - break; + switch (pMechanism->mechanism) + { + case CKM_RSA_PKCS: + case CKM_RSA_PKCS_OAEP: + if (getRSAPublicKey((RSAPublicKey *)publicKey, token, wrapKey) != CKR_OK) + { + cipher->recyclePublicKey(publicKey); + CryptoFactory::i()->recycleAsymmetricAlgorithm(cipher); + return CKR_GENERAL_ERROR; + } + break; - default: - return CKR_MECHANISM_INVALID; + default: + return CKR_MECHANISM_INVALID; } // Wrap the key - if (!cipher->wrapKey(publicKey, keydata, wrapped, mech,parameters,paramLen)) + if (!cipher->wrapKey(publicKey, keydata, wrapped, mech, parameters, paramLen)) { cipher->recyclePublicKey(publicKey); CryptoFactory::i()->recycleAsymmetricAlgorithm(cipher); @@ -6715,15 +6838,13 @@ CK_RV SoftHSM::WrapKeyAsym } // Internal: Wrap with mechanism RSA_AES_KEY_WRAP -CK_RV SoftHSM::WrapMechRsaAesKw -( +CK_RV SoftHSM::WrapMechRsaAesKw( CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechanism, Token *token, OSObject *wrapKey, ByteString &keydata, - ByteString &wrapped -) + ByteString &wrapped) { CK_RV rv = CKR_OK; ByteString wrapped_1; // buffer for the wrapped AES key; @@ -6742,20 +6863,20 @@ CK_RV SoftHSM::WrapMechRsaAesKw {CKA_PRIVATE, &bTrue, sizeof(CK_BBOOL)}, {CKA_WRAP, &bTrue, sizeof(CK_BBOOL)}, {CKA_EXTRACTABLE, &bTrue, sizeof(CK_BBOOL)}, - {CKA_VALUE_LEN, &emphKeyLen, sizeof(CK_ULONG)} - }; + {CKA_VALUE_LEN, &emphKeyLen, sizeof(CK_ULONG)}}; // Generates temporary random AES key of ulAESKeyBits length. - rv = this->generateAES(hSession, emph_temp, sizeof(emph_temp)/sizeof(CK_ATTRIBUTE), &hEmphKey, bFalse, bTrue); + rv = this->generateAES(hSession, emph_temp, sizeof(emph_temp) / sizeof(CK_ATTRIBUTE), &hEmphKey, bFalse, bTrue); if (rv != CKR_OK) { // Remove secret that may have been created already when the function fails. if (hEmphKey != CK_INVALID_HANDLE) { - OSObject *emphKey = (OSObject *)handleManager->getObject(hEmphKey); - handleManager->destroyObject(hEmphKey); - if(emphKey) emphKey->destroyObject(); - hEmphKey = CK_INVALID_HANDLE; + OSObject *emphKey = (OSObject *)handleManager->getObject(hEmphKey); + handleManager->destroyObject(hEmphKey); + if (emphKey) + emphKey->destroyObject(); + hEmphKey = CK_INVALID_HANDLE; } return rv; } @@ -6765,7 +6886,8 @@ CK_RV SoftHSM::WrapMechRsaAesKw { rv = CKR_FUNCTION_FAILED; handleManager->destroyObject(hEmphKey); - if(emphKey) emphKey->destroyObject(); + if (emphKey) + emphKey->destroyObject(); hEmphKey = CK_INVALID_HANDLE; return rv; } @@ -6810,70 +6932,73 @@ CK_RV SoftHSM::WrapMechRsaAesKw return rv; } - // Wrap the specified key using the specified wrapping key and mechanism -CK_RV SoftHSM::C_WrapKey -( +CK_RV SoftHSM::C_WrapKey( CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechanism, CK_OBJECT_HANDLE hWrappingKey, CK_OBJECT_HANDLE hKey, CK_BYTE_PTR pWrappedKey, - CK_ULONG_PTR pulWrappedKeyLen -) + CK_ULONG_PTR pulWrappedKeyLen) { - if (!isInitialised) return CKR_CRYPTOKI_NOT_INITIALIZED; + if (!isInitialised) + return CKR_CRYPTOKI_NOT_INITIALIZED; - if (pMechanism == NULL_PTR) return CKR_ARGUMENTS_BAD; - if (pulWrappedKeyLen == NULL_PTR) return CKR_ARGUMENTS_BAD; + if (pMechanism == NULL_PTR) + return CKR_ARGUMENTS_BAD; + if (pulWrappedKeyLen == NULL_PTR) + return CKR_ARGUMENTS_BAD; // Get the session - Session* session = (Session*)handleManager->getSession(hSession); - if (session == NULL) return CKR_SESSION_HANDLE_INVALID; + Session *session = (Session *)handleManager->getSession(hSession); + if (session == NULL) + return CKR_SESSION_HANDLE_INVALID; CK_RV rv; // Check the mechanism, only accept advanced AES key wrapping and RSA - switch(pMechanism->mechanism) + switch (pMechanism->mechanism) { #ifdef HAVE_AES_KEY_WRAP - case CKM_AES_KEY_WRAP: + case CKM_AES_KEY_WRAP: #endif #ifdef HAVE_AES_KEY_WRAP_PAD - case CKM_AES_KEY_WRAP_PAD: + case CKM_AES_KEY_WRAP_PAD: #endif - case CKM_RSA_PKCS: - // Does not handle optional init vector - if (pMechanism->pParameter != NULL_PTR || - pMechanism->ulParameterLen != 0) - return CKR_ARGUMENTS_BAD; - break; - case CKM_RSA_PKCS_OAEP: - rv = MechParamCheckRSAPKCSOAEP(pMechanism); - if (rv != CKR_OK) - return rv; - break; - case CKM_RSA_AES_KEY_WRAP: - rv = MechParamCheckRSAAESKEYWRAP(pMechanism); - if (rv != CKR_OK) - return rv; - break; - case CKM_AES_CBC: - case CKM_AES_CBC_PAD: - if (pMechanism->pParameter == NULL_PTR || - pMechanism->ulParameterLen != 16) - return CKR_ARGUMENTS_BAD; - break; - default: - return CKR_MECHANISM_INVALID; + case CKM_RSA_PKCS: + // Does not handle optional init vector + if (pMechanism->pParameter != NULL_PTR || + pMechanism->ulParameterLen != 0) + return CKR_ARGUMENTS_BAD; + break; + case CKM_RSA_PKCS_OAEP: + rv = MechParamCheckRSAPKCSOAEP(pMechanism); + if (rv != CKR_OK) + return rv; + break; + case CKM_RSA_AES_KEY_WRAP: + rv = MechParamCheckRSAAESKEYWRAP(pMechanism); + if (rv != CKR_OK) + return rv; + break; + case CKM_AES_CBC: + case CKM_AES_CBC_PAD: + if (pMechanism->pParameter == NULL_PTR || + pMechanism->ulParameterLen != 16) + return CKR_ARGUMENTS_BAD; + break; + default: + return CKR_MECHANISM_INVALID; } // Get the token - Token* token = session->getToken(); - if (token == NULL) return CKR_GENERAL_ERROR; + Token *token = session->getToken(); + if (token == NULL) + return CKR_GENERAL_ERROR; // Check the wrapping key handle. OSObject *wrapKey = (OSObject *)handleManager->getObject(hWrappingKey); - if (wrapKey == NULL_PTR || !wrapKey->isValid()) return CKR_WRAPPING_KEY_HANDLE_INVALID; + if (wrapKey == NULL_PTR || !wrapKey->isValid()) + return CKR_WRAPPING_KEY_HANDLE_INVALID; CK_BBOOL isWrapKeyOnToken = wrapKey->getBooleanValue(CKA_TOKEN, false); CK_BBOOL isWrapKeyPrivate = wrapKey->getBooleanValue(CKA_PRIVATE, true); @@ -6904,7 +7029,7 @@ CK_RV SoftHSM::C_WrapKey if ((pMechanism->mechanism == CKM_AES_CBC || pMechanism->mechanism == CKM_AES_CBC_PAD) && wrapKey->getUnsignedLongValue(CKA_KEY_TYPE, CKK_VENDOR_DEFINED) != CKK_AES) return CKR_WRAPPING_KEY_TYPE_INCONSISTENT; if (pMechanism->mechanism == CKM_DES3_CBC && (wrapKey->getUnsignedLongValue(CKA_KEY_TYPE, CKK_VENDOR_DEFINED) != CKK_DES2 || - wrapKey->getUnsignedLongValue(CKA_KEY_TYPE, CKK_VENDOR_DEFINED) != CKK_DES3)) + wrapKey->getUnsignedLongValue(CKA_KEY_TYPE, CKK_VENDOR_DEFINED) != CKK_DES3)) return CKR_WRAPPING_KEY_TYPE_INCONSISTENT; // Check if the wrapping key can be used for wrapping @@ -6917,7 +7042,8 @@ CK_RV SoftHSM::C_WrapKey // Check the to be wrapped key handle. OSObject *key = (OSObject *)handleManager->getObject(hKey); - if (key == NULL_PTR || !key->isValid()) return CKR_KEY_HANDLE_INVALID; + if (key == NULL_PTR || !key->isValid()) + return CKR_KEY_HANDLE_INVALID; CK_BBOOL isKeyOnToken = key->getBooleanValue(CKA_TOKEN, false); CK_BBOOL isKeyPrivate = key->getBooleanValue(CKA_PRIVATE, true); @@ -6953,9 +7079,9 @@ CK_RV SoftHSM::C_WrapKey if (attr.isAttributeMapAttribute()) { - typedef std::map attrmap_type; + typedef std::map attrmap_type; - const attrmap_type& map = attr.getAttributeMapValue(); + const attrmap_type &map = attr.getAttributeMapValue(); for (attrmap_type::const_iterator it = map.begin(); it != map.end(); ++it) { @@ -6981,7 +7107,8 @@ CK_RV SoftHSM::C_WrapKey if (isKeyPrivate) { bool bOK = token->decrypt(key->getByteStringValue(CKA_VALUE), keydata); - if (!bOK) return CKR_GENERAL_ERROR; + if (!bOK) + return CKR_GENERAL_ERROR; } else { @@ -6992,37 +7119,38 @@ CK_RV SoftHSM::C_WrapKey { CK_KEY_TYPE keyType = key->getUnsignedLongValue(CKA_KEY_TYPE, CKK_VENDOR_DEFINED); AsymAlgo::Type alg = AsymAlgo::Unknown; - switch (keyType) { - case CKK_RSA: - alg = AsymAlgo::RSA; - break; - case CKK_DSA: - alg = AsymAlgo::DSA; - break; - case CKK_DH: - alg = AsymAlgo::DH; - break; + switch (keyType) + { + case CKK_RSA: + alg = AsymAlgo::RSA; + break; + case CKK_DSA: + alg = AsymAlgo::DSA; + break; + case CKK_DH: + alg = AsymAlgo::DH; + break; #ifdef WITH_ECC - case CKK_EC: - // can be ecdh too but it doesn't matter - alg = AsymAlgo::ECDSA; - break; + case CKK_EC: + // can be ecdh too but it doesn't matter + alg = AsymAlgo::ECDSA; + break; #endif #ifdef WITH_EDDSA - case CKK_EC_EDWARDS: - alg = AsymAlgo::EDDSA; - break; + case CKK_EC_EDWARDS: + alg = AsymAlgo::EDDSA; + break; #endif #ifdef WITH_GOST - case CKK_GOSTR3410: - alg = AsymAlgo::GOST; - break; + case CKK_GOSTR3410: + alg = AsymAlgo::GOST; + break; #endif - default: - return CKR_KEY_NOT_WRAPPABLE; + default: + return CKR_KEY_NOT_WRAPPABLE; } - AsymmetricAlgorithm* asymCrypto = NULL; - PrivateKey* privateKey = NULL; + AsymmetricAlgorithm *asymCrypto = NULL; + PrivateKey *privateKey = NULL; asymCrypto = CryptoFactory::i()->getAsymmetricAlgorithm(alg); if (asymCrypto == NULL) return CKR_GENERAL_ERROR; @@ -7032,30 +7160,31 @@ CK_RV SoftHSM::C_WrapKey CryptoFactory::i()->recycleAsymmetricAlgorithm(asymCrypto); return CKR_HOST_MEMORY; } - switch (keyType) { - case CKK_RSA: - rv = getRSAPrivateKey((RSAPrivateKey*)privateKey, token, key); - break; - case CKK_DSA: - rv = getDSAPrivateKey((DSAPrivateKey*)privateKey, token, key); - break; - case CKK_DH: - rv = getDHPrivateKey((DHPrivateKey*)privateKey, token, key); - break; + switch (keyType) + { + case CKK_RSA: + rv = getRSAPrivateKey((RSAPrivateKey *)privateKey, token, key); + break; + case CKK_DSA: + rv = getDSAPrivateKey((DSAPrivateKey *)privateKey, token, key); + break; + case CKK_DH: + rv = getDHPrivateKey((DHPrivateKey *)privateKey, token, key); + break; #ifdef WITH_ECC - case CKK_EC: - rv = getECPrivateKey((ECPrivateKey*)privateKey, token, key); - break; + case CKK_EC: + rv = getECPrivateKey((ECPrivateKey *)privateKey, token, key); + break; #endif #ifdef WITH_EDDSA - case CKK_EC_EDWARDS: - rv = getEDPrivateKey((EDPrivateKey*)privateKey, token, key); - break; + case CKK_EC_EDWARDS: + rv = getEDPrivateKey((EDPrivateKey *)privateKey, token, key); + break; #endif #ifdef WITH_GOST - case CKK_GOSTR3410: - rv = getGOSTPrivateKey((GOSTPrivateKey*)privateKey, token, key); - break; + case CKK_GOSTR3410: + rv = getGOSTPrivateKey((GOSTPrivateKey *)privateKey, token, key); + break; #endif } if (rv != CKR_OK) @@ -7092,7 +7221,8 @@ CK_RV SoftHSM::C_WrapKey return rv; } - if (pWrappedKey != NULL) { + if (pWrappedKey != NULL) + { if (*pulWrappedKeyLen >= wrapped.size()) memcpy(pWrappedKey, wrapped.byte_str(), wrapped.size()); else @@ -7104,52 +7234,52 @@ CK_RV SoftHSM::C_WrapKey } // Internal: Unwrap blob using symmetric key -CK_RV SoftHSM::UnwrapKeySym -( +CK_RV SoftHSM::UnwrapKeySym( CK_MECHANISM_PTR pMechanism, - ByteString& wrapped, - Token* token, - OSObject* unwrapKey, - ByteString& keydata -) + ByteString &wrapped, + Token *token, + OSObject *unwrapKey, + ByteString &keydata) { // Get the symmetric algorithm matching the mechanism SymAlgo::Type algo = SymAlgo::Unknown; SymWrap::Type mode = SymWrap::Unknown; size_t bb = 8; size_t blocksize = 0; - - switch(pMechanism->mechanism) { + + switch (pMechanism->mechanism) + { #ifdef HAVE_AES_KEY_WRAP - case CKM_AES_KEY_WRAP: - algo = SymAlgo::AES; - mode = SymWrap::AES_KEYWRAP; - break; + case CKM_AES_KEY_WRAP: + algo = SymAlgo::AES; + mode = SymWrap::AES_KEYWRAP; + break; #endif #ifdef HAVE_AES_KEY_WRAP_PAD - case CKM_AES_KEY_WRAP_PAD: - algo = SymAlgo::AES; - mode = SymWrap::AES_KEYWRAP_PAD; - break; + case CKM_AES_KEY_WRAP_PAD: + algo = SymAlgo::AES; + mode = SymWrap::AES_KEYWRAP_PAD; + break; #endif - case CKM_AES_CBC_PAD: - algo = SymAlgo::AES; - blocksize = 16; - break; - - case CKM_DES3_CBC_PAD: - algo = SymAlgo::DES3; - blocksize = 8; - break; - - default: - return CKR_MECHANISM_INVALID; + case CKM_AES_CBC_PAD: + algo = SymAlgo::AES; + blocksize = 16; + break; + + case CKM_DES3_CBC_PAD: + algo = SymAlgo::DES3; + blocksize = 8; + break; + + default: + return CKR_MECHANISM_INVALID; } - SymmetricAlgorithm* cipher = CryptoFactory::i()->getSymmetricAlgorithm(algo); - if (cipher == NULL) return CKR_MECHANISM_INVALID; + SymmetricAlgorithm *cipher = CryptoFactory::i()->getSymmetricAlgorithm(algo); + if (cipher == NULL) + return CKR_MECHANISM_INVALID; - SymmetricKey* unwrappingkey = new SymmetricKey(); + SymmetricKey *unwrappingkey = new SymmetricKey(); if (getSymmetricKey(unwrappingkey, token, unwrapKey) != CKR_OK) { @@ -7164,14 +7294,15 @@ CK_RV SoftHSM::UnwrapKeySym ByteString iv; ByteString decryptedFinal; CK_RV rv = CKR_OK; - - switch(pMechanism->mechanism) { + + switch (pMechanism->mechanism) + { case CKM_AES_CBC_PAD: case CKM_DES3_CBC_PAD: iv.resize(blocksize); memcpy(&iv[0], pMechanism->pParameter, blocksize); - + if (!cipher->decryptInit(unwrappingkey, SymMode::CBC, iv, false)) { cipher->recycleKey(unwrappingkey); @@ -7193,14 +7324,14 @@ CK_RV SoftHSM::UnwrapKeySym } keydata += decryptedFinal; - if(!RFC5652Unpad(keydata,blocksize)) + if (!RFC5652Unpad(keydata, blocksize)) { cipher->recycleKey(unwrappingkey); CryptoFactory::i()->recycleSymmetricAlgorithm(cipher); return CKR_GENERAL_ERROR; // TODO should be another error } break; - + default: // Unwrap the key rv = CKR_OK; @@ -7214,128 +7345,88 @@ CK_RV SoftHSM::UnwrapKeySym } // Internal: Unwrap blob using asymmetric key -CK_RV SoftHSM::UnwrapKeyAsym -( +CK_RV SoftHSM::UnwrapKeyAsym( CK_MECHANISM_PTR pMechanism, - ByteString& wrapped, - Token* token, - OSObject* unwrapKey, - ByteString& keydata -) + ByteString &wrapped, + Token *token, + OSObject *unwrapKey, + ByteString &keydata) { CK_RV rv = CKR_OK; // Get the symmetric algorithm matching the mechanism AsymAlgo::Type algo = AsymAlgo::Unknown; AsymMech::Type mode = AsymMech::Unknown; - switch(pMechanism->mechanism) { - case CKM_RSA_PKCS: - algo = AsymAlgo::RSA; - mode = AsymMech::RSA_PKCS; - break; + switch (pMechanism->mechanism) + { + case CKM_RSA_PKCS: + algo = AsymAlgo::RSA; + mode = AsymMech::RSA_PKCS; + break; - case CKM_RSA_PKCS_OAEP: - algo = AsymAlgo::RSA; - mode = AsymMech::RSA_PKCS_OAEP; - break; + case CKM_RSA_PKCS_OAEP: + algo = AsymAlgo::RSA; + mode = AsymMech::RSA_PKCS_OAEP; + break; - default: - return CKR_MECHANISM_INVALID; + default: + return CKR_MECHANISM_INVALID; } - AsymmetricAlgorithm* cipher = CryptoFactory::i()->getAsymmetricAlgorithm(algo); - if (cipher == NULL) return CKR_MECHANISM_INVALID; + AsymmetricAlgorithm *cipher = CryptoFactory::i()->getAsymmetricAlgorithm(algo); + if (cipher == NULL) + return CKR_MECHANISM_INVALID; - PrivateKey* unwrappingkey = cipher->newPrivateKey(); + PrivateKey *unwrappingkey = cipher->newPrivateKey(); if (unwrappingkey == NULL) { CryptoFactory::i()->recycleAsymmetricAlgorithm(cipher); return CKR_HOST_MEMORY; } - switch(pMechanism->mechanism) { - case CKM_RSA_PKCS: - case CKM_RSA_PKCS_OAEP: - if (getRSAPrivateKey((RSAPrivateKey*)unwrappingkey, token, unwrapKey) != CKR_OK) - { - cipher->recyclePrivateKey(unwrappingkey); - CryptoFactory::i()->recycleAsymmetricAlgorithm(cipher); - return CKR_GENERAL_ERROR; - } - break; + switch (pMechanism->mechanism) + { + case CKM_RSA_PKCS: + case CKM_RSA_PKCS_OAEP: + if (getRSAPrivateKey((RSAPrivateKey *)unwrappingkey, token, unwrapKey) != CKR_OK) + { + cipher->recyclePrivateKey(unwrappingkey); + CryptoFactory::i()->recycleAsymmetricAlgorithm(cipher); + return CKR_GENERAL_ERROR; + } + break; - default: - return CKR_MECHANISM_INVALID; + default: + return CKR_MECHANISM_INVALID; } void *parameters = NULL; size_t paramLen = 0; - RSA_PKCS_OAEP_PARAMS oaep_parameters; if (pMechanism->mechanism == CKM_RSA_PKCS_OAEP) { - CK_RSA_PKCS_OAEP_PARAMS* par1 = (CK_RSA_PKCS_OAEP_PARAMS*) pMechanism->pParameter; - switch (par1->hashAlg) - { - case CKM_SHA_1: - oaep_parameters.hashAlg = HashAlgo::SHA1; - break; - case CKM_SHA224: - oaep_parameters.hashAlg = HashAlgo::SHA224; - break; - case CKM_SHA256: - oaep_parameters.hashAlg = HashAlgo::SHA256; - break; - case CKM_SHA384: - oaep_parameters.hashAlg = HashAlgo::SHA384; - break; - case CKM_SHA512: - oaep_parameters.hashAlg = HashAlgo::SHA512; - break; - default: - return CKR_ARGUMENTS_BAD; - } - switch (par1->mgf) + rv = BuildRSAOAEPParam((CK_RSA_PKCS_OAEP_PARAMS *)pMechanism->pParameter, + ¶meters,¶mLen); + if (rv != CKR_OK) { - case CKG_MGF1_SHA1: - oaep_parameters.mgf = AsymRSAMGF::MGF1_SHA1; - break; - case CKG_MGF1_SHA224: - oaep_parameters.mgf = AsymRSAMGF::MGF1_SHA224; - break; - case CKG_MGF1_SHA256: - oaep_parameters.mgf = AsymRSAMGF::MGF1_SHA256; - break; - case CKG_MGF1_SHA384: - oaep_parameters.mgf = AsymRSAMGF::MGF1_SHA384; - break; - case CKG_MGF1_SHA512: - oaep_parameters.mgf = AsymRSAMGF::MGF1_SHA512; - break; - default: - return CKR_ARGUMENTS_BAD; + return rv; } - oaep_parameters.sourceData = par1->pSourceData; - oaep_parameters.sourceDataLen = par1->ulSourceDataLen; - parameters = &oaep_parameters; - paramLen = sizeof(RSA_PKCS_OAEP_PARAMS); } // Unwrap the key - if (!cipher->unwrapKey(unwrappingkey, wrapped, keydata, mode, parameters, paramLen )) + if (!cipher->unwrapKey(unwrappingkey, wrapped, keydata, mode, parameters, paramLen)) rv = CKR_GENERAL_ERROR; + free(parameters); cipher->recyclePrivateKey(unwrappingkey); CryptoFactory::i()->recycleAsymmetricAlgorithm(cipher); return rv; } // Internal: Unwrap with mechanism RSA_AES_KEY_WRAP -CK_RV SoftHSM::UnwrapMechRsaAesKw -( +CK_RV SoftHSM::UnwrapMechRsaAesKw( CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechanism, Token *token, OSObject *unwrapKey, ByteString &wrapped, - ByteString &keydata -) + ByteString &keydata) { CK_RV rv = CKR_OK; CK_OBJECT_HANDLE hEmphKey = CK_INVALID_HANDLE; @@ -7345,7 +7436,7 @@ CK_RV SoftHSM::UnwrapMechRsaAesKw ByteString modulusValue = unwrapKey->getByteStringValue(CKA_MODULUS); CK_BBOOL isUnwrapKeyPrivate = unwrapKey->getBooleanValue(CKA_PRIVATE, true); - if(isUnwrapKeyPrivate) + if (isUnwrapKeyPrivate) { token->decrypt(modulusValue, modulus); } @@ -7378,8 +7469,7 @@ CK_RV SoftHSM::UnwrapMechRsaAesKw {CKA_KEY_TYPE, &emphKeyType, sizeof(CK_KEY_TYPE)}, {CKA_TOKEN, &bFalse, sizeof(CK_BBOOL)}, {CKA_PRIVATE, &bTrue, sizeof(CK_BBOOL)}, - {CKA_UNWRAP, &bTrue, sizeof(CK_BBOOL)} - }; + {CKA_UNWRAP, &bTrue, sizeof(CK_BBOOL)}}; // Create the temporary AES object using C_CreateObject rv = this->CreateObject(hSession, emph_temp, sizeof(emph_temp) / sizeof(CK_ATTRIBUTE), &hEmphKey, OBJECT_OP_UNWRAP); @@ -7390,7 +7480,8 @@ CK_RV SoftHSM::UnwrapMechRsaAesKw { OSObject *emphKey = (OSObject *)handleManager->getObject(hEmphKey); handleManager->destroyObject(hEmphKey); - if(emphKey) emphKey->destroyObject(); + if (emphKey) + emphKey->destroyObject(); hEmphKey = CK_INVALID_HANDLE; } emphkeydata.wipe(); @@ -7403,7 +7494,8 @@ CK_RV SoftHSM::UnwrapMechRsaAesKw { rv = CKR_FUNCTION_FAILED; handleManager->destroyObject(hEmphKey); - if(emphKey) emphKey->destroyObject(); + if (emphKey) + emphKey->destroyObject(); hEmphKey = CK_INVALID_HANDLE; emphkeydata.wipe(); return rv; @@ -7469,8 +7561,7 @@ CK_RV SoftHSM::UnwrapMechRsaAesKw } // Unwrap the specified key using the specified unwrapping key -CK_RV SoftHSM::C_UnwrapKey -( +CK_RV SoftHSM::C_UnwrapKey( CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechanism, CK_OBJECT_HANDLE hUnwrappingKey, @@ -7478,83 +7569,90 @@ CK_RV SoftHSM::C_UnwrapKey CK_ULONG ulWrappedKeyLen, CK_ATTRIBUTE_PTR pTemplate, CK_ULONG ulCount, - CK_OBJECT_HANDLE_PTR hKey -) + CK_OBJECT_HANDLE_PTR hKey) { - if (!isInitialised) return CKR_CRYPTOKI_NOT_INITIALIZED; + if (!isInitialised) + return CKR_CRYPTOKI_NOT_INITIALIZED; - if (pMechanism == NULL_PTR) return CKR_ARGUMENTS_BAD; - if (pWrappedKey == NULL_PTR) return CKR_ARGUMENTS_BAD; - if (pTemplate == NULL_PTR) return CKR_ARGUMENTS_BAD; - if (hKey == NULL_PTR) return CKR_ARGUMENTS_BAD; + if (pMechanism == NULL_PTR) + return CKR_ARGUMENTS_BAD; + if (pWrappedKey == NULL_PTR) + return CKR_ARGUMENTS_BAD; + if (pTemplate == NULL_PTR) + return CKR_ARGUMENTS_BAD; + if (hKey == NULL_PTR) + return CKR_ARGUMENTS_BAD; // Get the session - Session* session = (Session*)handleManager->getSession(hSession); - if (session == NULL) return CKR_SESSION_HANDLE_INVALID; + Session *session = (Session *)handleManager->getSession(hSession); + if (session == NULL) + return CKR_SESSION_HANDLE_INVALID; CK_RV rv; // Check the mechanism - switch(pMechanism->mechanism) + switch (pMechanism->mechanism) { #ifdef HAVE_AES_KEY_WRAP - case CKM_AES_KEY_WRAP: - if ((ulWrappedKeyLen < 24) || ((ulWrappedKeyLen % 8) != 0)) - return CKR_WRAPPED_KEY_LEN_RANGE; - // Does not handle optional init vector - if (pMechanism->pParameter != NULL_PTR || - pMechanism->ulParameterLen != 0) - return CKR_ARGUMENTS_BAD; - break; + case CKM_AES_KEY_WRAP: + if ((ulWrappedKeyLen < 24) || ((ulWrappedKeyLen % 8) != 0)) + return CKR_WRAPPED_KEY_LEN_RANGE; + // Does not handle optional init vector + if (pMechanism->pParameter != NULL_PTR || + pMechanism->ulParameterLen != 0) + return CKR_ARGUMENTS_BAD; + break; #endif #ifdef HAVE_AES_KEY_WRAP_PAD - case CKM_AES_KEY_WRAP_PAD: - if ((ulWrappedKeyLen < 16) || ((ulWrappedKeyLen % 8) != 0)) - return CKR_WRAPPED_KEY_LEN_RANGE; - // Does not handle optional init vector - if (pMechanism->pParameter != NULL_PTR || - pMechanism->ulParameterLen != 0) - return CKR_ARGUMENTS_BAD; - break; + case CKM_AES_KEY_WRAP_PAD: + if ((ulWrappedKeyLen < 16) || ((ulWrappedKeyLen % 8) != 0)) + return CKR_WRAPPED_KEY_LEN_RANGE; + // Does not handle optional init vector + if (pMechanism->pParameter != NULL_PTR || + pMechanism->ulParameterLen != 0) + return CKR_ARGUMENTS_BAD; + break; #endif - case CKM_RSA_PKCS: - // Input length checks needs to be done later when unwrapping key is known - break; - case CKM_RSA_PKCS_OAEP: - rv = MechParamCheckRSAPKCSOAEP(pMechanism); - if (rv != CKR_OK) - return rv; - break; - case CKM_RSA_AES_KEY_WRAP: - rv = MechParamCheckRSAAESKEYWRAP(pMechanism); - if (rv != CKR_OK) - return rv; - break; - - case CKM_AES_CBC_PAD: - // TODO check block length - if (pMechanism->pParameter == NULL_PTR || - pMechanism->ulParameterLen != 16) - return CKR_ARGUMENTS_BAD; - break; + case CKM_RSA_PKCS: + // Input length checks needs to be done later when unwrapping key is known + break; + case CKM_RSA_PKCS_OAEP: + rv = MechParamCheckRSAPKCSOAEP(pMechanism); + if (rv != CKR_OK) + return rv; + break; + case CKM_RSA_AES_KEY_WRAP: + rv = MechParamCheckRSAAESKEYWRAP(pMechanism); + if (rv != CKR_OK) + return rv; + break; - case CKM_DES3_CBC_PAD: - // TODO check block length - if (pMechanism->pParameter == NULL_PTR || - pMechanism->ulParameterLen != 8) - return CKR_ARGUMENTS_BAD; - break; - - default: - return CKR_MECHANISM_INVALID; + case CKM_AES_CBC_PAD: + // TODO check block length + if (pMechanism->pParameter == NULL_PTR || + pMechanism->ulParameterLen != 16) + return CKR_ARGUMENTS_BAD; + break; + + case CKM_DES3_CBC_PAD: + // TODO check block length + if (pMechanism->pParameter == NULL_PTR || + pMechanism->ulParameterLen != 8) + return CKR_ARGUMENTS_BAD; + break; + + default: + return CKR_MECHANISM_INVALID; } // Get the token - Token* token = session->getToken(); - if (token == NULL) return CKR_GENERAL_ERROR; + Token *token = session->getToken(); + if (token == NULL) + return CKR_GENERAL_ERROR; // Check the unwrapping key handle. OSObject *unwrapKey = (OSObject *)handleManager->getObject(hUnwrappingKey); - if (unwrapKey == NULL_PTR || !unwrapKey->isValid()) return CKR_UNWRAPPING_KEY_HANDLE_INVALID; + if (unwrapKey == NULL_PTR || !unwrapKey->isValid()) + return CKR_UNWRAPPING_KEY_HANDLE_INVALID; CK_BBOOL isUnwrapKeyOnToken = unwrapKey->getBooleanValue(CKA_TOKEN, false); CK_BBOOL isUnwrapKeyPrivate = unwrapKey->getBooleanValue(CKA_PRIVATE, true); @@ -7585,9 +7683,9 @@ CK_RV SoftHSM::C_UnwrapKey if ((pMechanism->mechanism == CKM_AES_CBC || pMechanism->mechanism == CKM_AES_CBC_PAD) && unwrapKey->getUnsignedLongValue(CKA_KEY_TYPE, CKK_VENDOR_DEFINED) != CKK_AES) return CKR_WRAPPING_KEY_TYPE_INCONSISTENT; if (pMechanism->mechanism == CKM_DES3_CBC && (unwrapKey->getUnsignedLongValue(CKA_KEY_TYPE, CKK_VENDOR_DEFINED) != CKK_DES2 || - unwrapKey->getUnsignedLongValue(CKA_KEY_TYPE, CKK_VENDOR_DEFINED) != CKK_DES3)) + unwrapKey->getUnsignedLongValue(CKA_KEY_TYPE, CKK_VENDOR_DEFINED) != CKK_DES3)) return CKR_WRAPPING_KEY_TYPE_INCONSISTENT; - + // Check if the unwrapping key can be used for unwrapping if (unwrapKey->getBooleanValue(CKA_UNWRAP, false) == false) return CKR_KEY_FUNCTION_NOT_PERMITTED; @@ -7630,11 +7728,10 @@ CK_RV SoftHSM::C_UnwrapKey // Build unwrapped key template const CK_ULONG maxAttribs = 32; CK_ATTRIBUTE secretAttribs[maxAttribs] = { - { CKA_CLASS, &objClass, sizeof(objClass) }, - { CKA_TOKEN, &isOnToken, sizeof(isOnToken) }, - { CKA_PRIVATE, &isPrivate, sizeof(isPrivate) }, - { CKA_KEY_TYPE, &keyType, sizeof(keyType) } - }; + {CKA_CLASS, &objClass, sizeof(objClass)}, + {CKA_TOKEN, &isOnToken, sizeof(isOnToken)}, + {CKA_PRIVATE, &isPrivate, sizeof(isPrivate)}, + {CKA_KEY_TYPE, &keyType, sizeof(keyType)}}; CK_ULONG secretAttribsCount = 4; // Add the additional @@ -7644,13 +7741,13 @@ CK_RV SoftHSM::C_UnwrapKey { switch (pTemplate[i].type) { - case CKA_CLASS: - case CKA_TOKEN: - case CKA_PRIVATE: - case CKA_KEY_TYPE: - continue; - default: - secretAttribs[secretAttribsCount++] = pTemplate[i]; + case CKA_CLASS: + case CKA_TOKEN: + case CKA_PRIVATE: + case CKA_KEY_TYPE: + continue; + default: + secretAttribs[secretAttribsCount++] = pTemplate[i]; } } @@ -7661,13 +7758,13 @@ CK_RV SoftHSM::C_UnwrapKey if (unwrapAttr.isAttributeMapAttribute()) { - typedef std::map attrmap_type; + typedef std::map attrmap_type; - const attrmap_type& map = unwrapAttr.getAttributeMapValue(); + const attrmap_type &map = unwrapAttr.getAttributeMapValue(); for (attrmap_type::const_iterator it = map.begin(); it != map.end(); ++it) { - CK_ATTRIBUTE* attr = NULL; + CK_ATTRIBUTE *attr = NULL; for (CK_ULONG i = 0; i < secretAttribsCount; ++i) { if (it->first == secretAttribs[i].type) @@ -7729,11 +7826,11 @@ CK_RV SoftHSM::C_UnwrapKey // Store the attributes that are being supplied if (rv == CKR_OK) { - OSObject* osobject = (OSObject*)handleManager->getObject(*hKey); + OSObject *osobject = (OSObject *)handleManager->getObject(*hKey); if (osobject == NULL_PTR || !osobject->isValid()) - { + { rv = CKR_FUNCTION_FAILED; - } + } else if (osobject->startTransaction()) { bool bOK = true; @@ -7805,70 +7902,75 @@ CK_RV SoftHSM::C_UnwrapKey { if (*hKey != CK_INVALID_HANDLE) { - OSObject* obj = (OSObject*)handleManager->getObject(*hKey); + OSObject *obj = (OSObject *)handleManager->getObject(*hKey); handleManager->destroyObject(*hKey); - if (obj) obj->destroyObject(); + if (obj) + obj->destroyObject(); *hKey = CK_INVALID_HANDLE; } - } return rv; } // Derive a key from the specified base key -CK_RV SoftHSM::C_DeriveKey -( +CK_RV SoftHSM::C_DeriveKey( CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechanism, CK_OBJECT_HANDLE hBaseKey, CK_ATTRIBUTE_PTR pTemplate, CK_ULONG ulCount, - CK_OBJECT_HANDLE_PTR phKey -) + CK_OBJECT_HANDLE_PTR phKey) { - if (!isInitialised) return CKR_CRYPTOKI_NOT_INITIALIZED; + if (!isInitialised) + return CKR_CRYPTOKI_NOT_INITIALIZED; - if (pMechanism == NULL_PTR) return CKR_ARGUMENTS_BAD; - if (pTemplate == NULL_PTR) return CKR_ARGUMENTS_BAD; - if (phKey == NULL_PTR) return CKR_ARGUMENTS_BAD; + if (pMechanism == NULL_PTR) + return CKR_ARGUMENTS_BAD; + if (pTemplate == NULL_PTR) + return CKR_ARGUMENTS_BAD; + if (phKey == NULL_PTR) + return CKR_ARGUMENTS_BAD; // Get the session - Session* session = (Session*)handleManager->getSession(hSession); - if (session == NULL) return CKR_SESSION_HANDLE_INVALID; + Session *session = (Session *)handleManager->getSession(hSession); + if (session == NULL) + return CKR_SESSION_HANDLE_INVALID; // Check the mechanism, only accept DH and ECDH derive switch (pMechanism->mechanism) { - case CKM_DH_PKCS_DERIVE: + case CKM_DH_PKCS_DERIVE: #if defined(WITH_ECC) || defined(WITH_EDDSA) - case CKM_ECDH1_DERIVE: + case CKM_ECDH1_DERIVE: #endif #ifndef WITH_FIPS - case CKM_DES_ECB_ENCRYPT_DATA: - case CKM_DES_CBC_ENCRYPT_DATA: + case CKM_DES_ECB_ENCRYPT_DATA: + case CKM_DES_CBC_ENCRYPT_DATA: #endif - case CKM_DES3_ECB_ENCRYPT_DATA: - case CKM_DES3_CBC_ENCRYPT_DATA: - case CKM_AES_ECB_ENCRYPT_DATA: - case CKM_AES_CBC_ENCRYPT_DATA: - case CKM_CONCATENATE_DATA_AND_BASE: - case CKM_CONCATENATE_BASE_AND_DATA: - case CKM_CONCATENATE_BASE_AND_KEY: - break; + case CKM_DES3_ECB_ENCRYPT_DATA: + case CKM_DES3_CBC_ENCRYPT_DATA: + case CKM_AES_ECB_ENCRYPT_DATA: + case CKM_AES_CBC_ENCRYPT_DATA: + case CKM_CONCATENATE_DATA_AND_BASE: + case CKM_CONCATENATE_BASE_AND_DATA: + case CKM_CONCATENATE_BASE_AND_KEY: + break; - default: - ERROR_MSG("Invalid mechanism"); - return CKR_MECHANISM_INVALID; + default: + ERROR_MSG("Invalid mechanism"); + return CKR_MECHANISM_INVALID; } // Get the token - Token* token = session->getToken(); - if (token == NULL) return CKR_GENERAL_ERROR; + Token *token = session->getToken(); + if (token == NULL) + return CKR_GENERAL_ERROR; // Check the key handle. OSObject *key = (OSObject *)handleManager->getObject(hBaseKey); - if (key == NULL_PTR || !key->isValid()) return CKR_OBJECT_HANDLE_INVALID; + if (key == NULL_PTR || !key->isValid()) + return CKR_OBJECT_HANDLE_INVALID; CK_BBOOL isKeyOnToken = key->getBooleanValue(CKA_TOKEN, false); CK_BBOOL isKeyPrivate = key->getBooleanValue(CKA_PRIVATE, true); @@ -7897,29 +7999,31 @@ CK_RV SoftHSM::C_DeriveKey CK_BBOOL isOnToken = CK_FALSE; CK_BBOOL isPrivate = CK_TRUE; CK_CERTIFICATE_TYPE dummy; - bool isImplicit = pMechanism->mechanism == CKM_CONCATENATE_DATA_AND_BASE || - pMechanism->mechanism == CKM_CONCATENATE_BASE_AND_DATA || - pMechanism->mechanism == CKM_CONCATENATE_BASE_AND_KEY; - if (isImplicit) { - // PKCS#11 2.40 section 2.31.5: if no key type is provided then the key produced by this mechanism will - // be a generic secret key - objClass = CKO_SECRET_KEY; - keyType = CKK_GENERIC_SECRET; - } - rv = extractObjectInformation(pTemplate, ulCount, objClass, keyType, dummy, isOnToken, isPrivate, isImplicit); - if (rv != CKR_OK) { - ERROR_MSG("Mandatory attribute not present in template"); - return rv; - } + bool isImplicit = pMechanism->mechanism == CKM_CONCATENATE_DATA_AND_BASE || + pMechanism->mechanism == CKM_CONCATENATE_BASE_AND_DATA || + pMechanism->mechanism == CKM_CONCATENATE_BASE_AND_KEY; + if (isImplicit) + { + // PKCS#11 2.40 section 2.31.5: if no key type is provided then the key produced by this mechanism will + // be a generic secret key + objClass = CKO_SECRET_KEY; + keyType = CKK_GENERIC_SECRET; + } + rv = extractObjectInformation(pTemplate, ulCount, objClass, keyType, dummy, isOnToken, isPrivate, isImplicit); + if (rv != CKR_OK) + { + ERROR_MSG("Mandatory attribute not present in template"); + return rv; + } // Report errors and/or unexpected usage. if (objClass != CKO_SECRET_KEY) return CKR_ATTRIBUTE_VALUE_INVALID; if (keyType != CKK_GENERIC_SECRET && - keyType != CKK_DES && - keyType != CKK_DES2 && - keyType != CKK_DES3 && - keyType != CKK_AES) + keyType != CKK_DES && + keyType != CKK_DES2 && + keyType != CKK_DES3 && + keyType != CKK_AES) return CKR_TEMPLATE_INCONSISTENT; // Check authorization @@ -7968,36 +8072,36 @@ CK_RV SoftHSM::C_DeriveKey // Derive symmetric secret if (pMechanism->mechanism == CKM_DES_ECB_ENCRYPT_DATA || - pMechanism->mechanism == CKM_DES_CBC_ENCRYPT_DATA || - pMechanism->mechanism == CKM_DES3_ECB_ENCRYPT_DATA || - pMechanism->mechanism == CKM_DES3_CBC_ENCRYPT_DATA || - pMechanism->mechanism == CKM_AES_ECB_ENCRYPT_DATA || - pMechanism->mechanism == CKM_AES_CBC_ENCRYPT_DATA || - pMechanism->mechanism == CKM_CONCATENATE_DATA_AND_BASE || - pMechanism->mechanism == CKM_CONCATENATE_BASE_AND_DATA || - pMechanism->mechanism == CKM_CONCATENATE_BASE_AND_KEY) + pMechanism->mechanism == CKM_DES_CBC_ENCRYPT_DATA || + pMechanism->mechanism == CKM_DES3_ECB_ENCRYPT_DATA || + pMechanism->mechanism == CKM_DES3_CBC_ENCRYPT_DATA || + pMechanism->mechanism == CKM_AES_ECB_ENCRYPT_DATA || + pMechanism->mechanism == CKM_AES_CBC_ENCRYPT_DATA || + pMechanism->mechanism == CKM_CONCATENATE_DATA_AND_BASE || + pMechanism->mechanism == CKM_CONCATENATE_BASE_AND_DATA || + pMechanism->mechanism == CKM_CONCATENATE_BASE_AND_KEY) { // Check key class and type CK_KEY_TYPE baseKeyType = key->getUnsignedLongValue(CKA_KEY_TYPE, CKK_VENDOR_DEFINED); if (key->getUnsignedLongValue(CKA_CLASS, CKO_VENDOR_DEFINED) != CKO_SECRET_KEY) return CKR_KEY_TYPE_INCONSISTENT; if (pMechanism->mechanism == CKM_DES_ECB_ENCRYPT_DATA && - baseKeyType != CKK_DES) + baseKeyType != CKK_DES) return CKR_KEY_TYPE_INCONSISTENT; if (pMechanism->mechanism == CKM_DES_CBC_ENCRYPT_DATA && - baseKeyType != CKK_DES) + baseKeyType != CKK_DES) return CKR_KEY_TYPE_INCONSISTENT; if (pMechanism->mechanism == CKM_DES3_ECB_ENCRYPT_DATA && - baseKeyType != CKK_DES2 && baseKeyType != CKK_DES3) + baseKeyType != CKK_DES2 && baseKeyType != CKK_DES3) return CKR_KEY_TYPE_INCONSISTENT; if (pMechanism->mechanism == CKM_DES3_CBC_ENCRYPT_DATA && - baseKeyType != CKK_DES2 && baseKeyType != CKK_DES3) + baseKeyType != CKK_DES2 && baseKeyType != CKK_DES3) return CKR_KEY_TYPE_INCONSISTENT; if (pMechanism->mechanism == CKM_AES_ECB_ENCRYPT_DATA && - baseKeyType != CKK_AES) + baseKeyType != CKK_AES) return CKR_KEY_TYPE_INCONSISTENT; if (pMechanism->mechanism == CKM_AES_CBC_ENCRYPT_DATA && - baseKeyType != CKK_AES) + baseKeyType != CKK_AES) return CKR_KEY_TYPE_INCONSISTENT; return this->deriveSymmetric(hSession, pMechanism, hBaseKey, pTemplate, ulCount, phKey, keyType, isOnToken, isPrivate); @@ -8009,17 +8113,21 @@ CK_RV SoftHSM::C_DeriveKey // Seed the random number generator with new data CK_RV SoftHSM::C_SeedRandom(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pSeed, CK_ULONG ulSeedLen) { - if (!isInitialised) return CKR_CRYPTOKI_NOT_INITIALIZED; + if (!isInitialised) + return CKR_CRYPTOKI_NOT_INITIALIZED; - if (pSeed == NULL_PTR) return CKR_ARGUMENTS_BAD; + if (pSeed == NULL_PTR) + return CKR_ARGUMENTS_BAD; // Get the session - Session* session = (Session*)handleManager->getSession(hSession); - if (session == NULL) return CKR_SESSION_HANDLE_INVALID; + Session *session = (Session *)handleManager->getSession(hSession); + if (session == NULL) + return CKR_SESSION_HANDLE_INVALID; // Get the RNG - RNG* rng = CryptoFactory::i()->getRNG(); - if (rng == NULL) return CKR_GENERAL_ERROR; + RNG *rng = CryptoFactory::i()->getRNG(); + if (rng == NULL) + return CKR_GENERAL_ERROR; // Seed the RNG ByteString seed(pSeed, ulSeedLen); @@ -8031,21 +8139,26 @@ CK_RV SoftHSM::C_SeedRandom(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pSeed, CK_UL // Generate the specified amount of random data CK_RV SoftHSM::C_GenerateRandom(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pRandomData, CK_ULONG ulRandomLen) { - if (!isInitialised) return CKR_CRYPTOKI_NOT_INITIALIZED; + if (!isInitialised) + return CKR_CRYPTOKI_NOT_INITIALIZED; - if (pRandomData == NULL_PTR) return CKR_ARGUMENTS_BAD; + if (pRandomData == NULL_PTR) + return CKR_ARGUMENTS_BAD; // Get the session - Session* session = (Session*)handleManager->getSession(hSession); - if (session == NULL) return CKR_SESSION_HANDLE_INVALID; + Session *session = (Session *)handleManager->getSession(hSession); + if (session == NULL) + return CKR_SESSION_HANDLE_INVALID; // Get the RNG - RNG* rng = CryptoFactory::i()->getRNG(); - if (rng == NULL) return CKR_GENERAL_ERROR; + RNG *rng = CryptoFactory::i()->getRNG(); + if (rng == NULL) + return CKR_GENERAL_ERROR; // Generate random data ByteString randomData; - if (!rng->generateRandom(randomData, ulRandomLen)) return CKR_GENERAL_ERROR; + if (!rng->generateRandom(randomData, ulRandomLen)) + return CKR_GENERAL_ERROR; // Return random data if (ulRandomLen != 0) @@ -8059,11 +8172,13 @@ CK_RV SoftHSM::C_GenerateRandom(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pRandomD // Legacy function CK_RV SoftHSM::C_GetFunctionStatus(CK_SESSION_HANDLE hSession) { - if (!isInitialised) return CKR_CRYPTOKI_NOT_INITIALIZED; + if (!isInitialised) + return CKR_CRYPTOKI_NOT_INITIALIZED; // Get the session - Session* session = (Session*)handleManager->getSession(hSession); - if (session == NULL) return CKR_SESSION_HANDLE_INVALID; + Session *session = (Session *)handleManager->getSession(hSession); + if (session == NULL) + return CKR_SESSION_HANDLE_INVALID; return CKR_FUNCTION_NOT_PARALLEL; } @@ -8071,11 +8186,13 @@ CK_RV SoftHSM::C_GetFunctionStatus(CK_SESSION_HANDLE hSession) // Legacy function CK_RV SoftHSM::C_CancelFunction(CK_SESSION_HANDLE hSession) { - if (!isInitialised) return CKR_CRYPTOKI_NOT_INITIALIZED; + if (!isInitialised) + return CKR_CRYPTOKI_NOT_INITIALIZED; // Get the session - Session* session = (Session*)handleManager->getSession(hSession); - if (session == NULL) return CKR_SESSION_HANDLE_INVALID; + Session *session = (Session *)handleManager->getSession(hSession); + if (session == NULL) + return CKR_SESSION_HANDLE_INVALID; return CKR_FUNCTION_NOT_PARALLEL; } @@ -8083,9 +8200,11 @@ CK_RV SoftHSM::C_CancelFunction(CK_SESSION_HANDLE hSession) // Wait or poll for a slot event on the specified slot CK_RV SoftHSM::C_WaitForSlotEvent(CK_FLAGS flags, CK_SLOT_ID_PTR /*pSlot*/, CK_VOID_PTR /*pReserved*/) { - if (!(flags & CKF_DONT_BLOCK)) return CKR_FUNCTION_NOT_SUPPORTED; + if (!(flags & CKF_DONT_BLOCK)) + return CKR_FUNCTION_NOT_SUPPORTED; - if (!isInitialised) return CKR_CRYPTOKI_NOT_INITIALIZED; + if (!isInitialised) + return CKR_CRYPTOKI_NOT_INITIALIZED; // SoftHSM slots don't change after it's initialised. With the // exception of when a slot is initialised and then getSlotList() is @@ -8094,23 +8213,22 @@ CK_RV SoftHSM::C_WaitForSlotEvent(CK_FLAGS flags, CK_SLOT_ID_PTR /*pSlot*/, CK_V return CKR_NO_EVENT; } -CK_RV SoftHSM::generateGeneric -(CK_SESSION_HANDLE hSession, - CK_ATTRIBUTE_PTR pTemplate, - CK_ULONG ulCount, - CK_OBJECT_HANDLE_PTR phKey, - CK_BBOOL isOnToken, - CK_BBOOL isPrivate) +CK_RV SoftHSM::generateGeneric(CK_SESSION_HANDLE hSession, + CK_ATTRIBUTE_PTR pTemplate, + CK_ULONG ulCount, + CK_OBJECT_HANDLE_PTR phKey, + CK_BBOOL isOnToken, + CK_BBOOL isPrivate) { *phKey = CK_INVALID_HANDLE; // Get the session - Session* session = (Session*)handleManager->getSession(hSession); + Session *session = (Session *)handleManager->getSession(hSession); if (session == NULL) return CKR_SESSION_HANDLE_INVALID; // Get the token - Token* token = session->getToken(); + Token *token = session->getToken(); if (token == NULL) return CKR_GENERAL_ERROR; @@ -8121,24 +8239,24 @@ CK_RV SoftHSM::generateGeneric { switch (pTemplate[i].type) { - case CKA_VALUE_LEN: - if (pTemplate[i].ulValueLen != sizeof(CK_ULONG)) - { - INFO_MSG("CKA_VALUE_LEN does not have the size of CK_ULONG"); - return CKR_ATTRIBUTE_VALUE_INVALID; - } - keyLen = *(CK_ULONG*)pTemplate[i].pValue; - break; - case CKA_CHECK_VALUE: - if (pTemplate[i].ulValueLen > 0) - { - INFO_MSG("CKA_CHECK_VALUE must be a no-value (0 length) entry"); - return CKR_ATTRIBUTE_VALUE_INVALID; - } - checkValue = false; - break; - default: - break; + case CKA_VALUE_LEN: + if (pTemplate[i].ulValueLen != sizeof(CK_ULONG)) + { + INFO_MSG("CKA_VALUE_LEN does not have the size of CK_ULONG"); + return CKR_ATTRIBUTE_VALUE_INVALID; + } + keyLen = *(CK_ULONG *)pTemplate[i].pValue; + break; + case CKA_CHECK_VALUE: + if (pTemplate[i].ulValueLen > 0) + { + INFO_MSG("CKA_CHECK_VALUE must be a no-value (0 length) entry"); + return CKR_ATTRIBUTE_VALUE_INVALID; + } + checkValue = false; + break; + default: + break; } } @@ -8157,41 +8275,43 @@ CK_RV SoftHSM::generateGeneric } // Generate the secret key - RNG* rng = CryptoFactory::i()->getRNG(); - if (rng == NULL) return CKR_GENERAL_ERROR; + RNG *rng = CryptoFactory::i()->getRNG(); + if (rng == NULL) + return CKR_GENERAL_ERROR; ByteString key; - if (!rng->generateRandom(key, keyLen)) return CKR_GENERAL_ERROR; + if (!rng->generateRandom(key, keyLen)) + return CKR_GENERAL_ERROR; - CK_RV rv = CKR_OK; + CK_RV rv = CKR_OK; // Create the secret key object using C_CreateObject const CK_ULONG maxAttribs = 32; CK_OBJECT_CLASS objClass = CKO_SECRET_KEY; CK_KEY_TYPE keyType = CKK_GENERIC_SECRET; CK_ATTRIBUTE keyAttribs[maxAttribs] = { - { CKA_CLASS, &objClass, sizeof(objClass) }, - { CKA_TOKEN, &isOnToken, sizeof(isOnToken) }, - { CKA_PRIVATE, &isPrivate, sizeof(isPrivate) }, - { CKA_KEY_TYPE, &keyType, sizeof(keyType) }, + {CKA_CLASS, &objClass, sizeof(objClass)}, + {CKA_TOKEN, &isOnToken, sizeof(isOnToken)}, + {CKA_PRIVATE, &isPrivate, sizeof(isPrivate)}, + {CKA_KEY_TYPE, &keyType, sizeof(keyType)}, }; CK_ULONG keyAttribsCount = 4; // Add the additional if (ulCount > (maxAttribs - keyAttribsCount)) rv = CKR_TEMPLATE_INCONSISTENT; - for (CK_ULONG i=0; i < ulCount && rv == CKR_OK; ++i) + for (CK_ULONG i = 0; i < ulCount && rv == CKR_OK; ++i) { switch (pTemplate[i].type) { - case CKA_CLASS: - case CKA_TOKEN: - case CKA_PRIVATE: - case CKA_KEY_TYPE: - case CKA_CHECK_VALUE: - continue; - default: - keyAttribs[keyAttribsCount++] = pTemplate[i]; - break; + case CKA_CLASS: + case CKA_TOKEN: + case CKA_PRIVATE: + case CKA_KEY_TYPE: + case CKA_CHECK_VALUE: + continue; + default: + keyAttribs[keyAttribsCount++] = pTemplate[i]; + break; } } @@ -8201,20 +8321,23 @@ CK_RV SoftHSM::generateGeneric // Store the attributes that are being supplied if (rv == CKR_OK) { - OSObject* osobject = (OSObject*)handleManager->getObject(*phKey); - if (osobject == NULL_PTR || !osobject->isValid()) { + OSObject *osobject = (OSObject *)handleManager->getObject(*phKey); + if (osobject == NULL_PTR || !osobject->isValid()) + { rv = CKR_FUNCTION_FAILED; - } else if (osobject->startTransaction()) { + } + else if (osobject->startTransaction()) + { bool bOK = true; // Common Attributes - bOK = bOK && osobject->setAttribute(CKA_LOCAL,true); + bOK = bOK && osobject->setAttribute(CKA_LOCAL, true); CK_ULONG ulKeyGenMechanism = (CK_ULONG)CKM_GENERIC_SECRET_KEY_GEN; - bOK = bOK && osobject->setAttribute(CKA_KEY_GEN_MECHANISM,ulKeyGenMechanism); + bOK = bOK && osobject->setAttribute(CKA_KEY_GEN_MECHANISM, ulKeyGenMechanism); // Common Secret Key Attributes bool bAlwaysSensitive = osobject->getBooleanValue(CKA_SENSITIVE, false); - bOK = bOK && osobject->setAttribute(CKA_ALWAYS_SENSITIVE,bAlwaysSensitive); + bOK = bOK && osobject->setAttribute(CKA_ALWAYS_SENSITIVE, bAlwaysSensitive); bool bNeverExtractable = osobject->getBooleanValue(CKA_EXTRACTABLE, false) == false; bOK = bOK && osobject->setAttribute(CKA_NEVER_EXTRACTABLE, bNeverExtractable); @@ -8245,7 +8368,8 @@ CK_RV SoftHSM::generateGeneric if (!bOK) rv = CKR_FUNCTION_FAILED; - } else + } + else rv = CKR_FUNCTION_FAILED; } @@ -8255,9 +8379,10 @@ CK_RV SoftHSM::generateGeneric { if (*phKey != CK_INVALID_HANDLE) { - OSObject* oskey = (OSObject*)handleManager->getObject(*phKey); + OSObject *oskey = (OSObject *)handleManager->getObject(*phKey); handleManager->destroyObject(*phKey); - if (oskey) oskey->destroyObject(); + if (oskey) + oskey->destroyObject(); *phKey = CK_INVALID_HANDLE; } } @@ -8266,23 +8391,22 @@ CK_RV SoftHSM::generateGeneric } // Generate an AES secret key -CK_RV SoftHSM::generateAES -(CK_SESSION_HANDLE hSession, - CK_ATTRIBUTE_PTR pTemplate, - CK_ULONG ulCount, - CK_OBJECT_HANDLE_PTR phKey, - CK_BBOOL isOnToken, - CK_BBOOL isPrivate) +CK_RV SoftHSM::generateAES(CK_SESSION_HANDLE hSession, + CK_ATTRIBUTE_PTR pTemplate, + CK_ULONG ulCount, + CK_OBJECT_HANDLE_PTR phKey, + CK_BBOOL isOnToken, + CK_BBOOL isPrivate) { *phKey = CK_INVALID_HANDLE; // Get the session - Session* session = (Session*)handleManager->getSession(hSession); + Session *session = (Session *)handleManager->getSession(hSession); if (session == NULL) return CKR_SESSION_HANDLE_INVALID; // Get the token - Token* token = session->getToken(); + Token *token = session->getToken(); if (token == NULL) return CKR_GENERAL_ERROR; @@ -8293,24 +8417,24 @@ CK_RV SoftHSM::generateAES { switch (pTemplate[i].type) { - case CKA_VALUE_LEN: - if (pTemplate[i].ulValueLen != sizeof(CK_ULONG)) - { - INFO_MSG("CKA_VALUE_LEN does not have the size of CK_ULONG"); - return CKR_ATTRIBUTE_VALUE_INVALID; - } - keyLen = *(CK_ULONG*)pTemplate[i].pValue; - break; - case CKA_CHECK_VALUE: - if (pTemplate[i].ulValueLen > 0) - { - INFO_MSG("CKA_CHECK_VALUE must be a no-value (0 length) entry"); - return CKR_ATTRIBUTE_VALUE_INVALID; - } - checkValue = false; - break; - default: - break; + case CKA_VALUE_LEN: + if (pTemplate[i].ulValueLen != sizeof(CK_ULONG)) + { + INFO_MSG("CKA_VALUE_LEN does not have the size of CK_ULONG"); + return CKR_ATTRIBUTE_VALUE_INVALID; + } + keyLen = *(CK_ULONG *)pTemplate[i].pValue; + break; + case CKA_CHECK_VALUE: + if (pTemplate[i].ulValueLen > 0) + { + INFO_MSG("CKA_CHECK_VALUE must be a no-value (0 length) entry"); + return CKR_ATTRIBUTE_VALUE_INVALID; + } + checkValue = false; + break; + default: + break; } } @@ -8329,15 +8453,15 @@ CK_RV SoftHSM::generateAES } // Generate the secret key - AESKey* key = new AESKey(keyLen * 8); - SymmetricAlgorithm* aes = CryptoFactory::i()->getSymmetricAlgorithm(SymAlgo::AES); + AESKey *key = new AESKey(keyLen * 8); + SymmetricAlgorithm *aes = CryptoFactory::i()->getSymmetricAlgorithm(SymAlgo::AES); if (aes == NULL) { ERROR_MSG("Could not get SymmetricAlgorithm"); delete key; return CKR_GENERAL_ERROR; } - RNG* rng = CryptoFactory::i()->getRNG(); + RNG *rng = CryptoFactory::i()->getRNG(); if (rng == NULL) { ERROR_MSG("Could not get RNG"); @@ -8360,54 +8484,54 @@ CK_RV SoftHSM::generateAES CK_OBJECT_CLASS objClass = CKO_SECRET_KEY; CK_KEY_TYPE keyType = CKK_AES; CK_ATTRIBUTE keyAttribs[maxAttribs] = { - { CKA_CLASS, &objClass, sizeof(objClass) }, - { CKA_TOKEN, &isOnToken, sizeof(isOnToken) }, - { CKA_PRIVATE, &isPrivate, sizeof(isPrivate) }, - { CKA_KEY_TYPE, &keyType, sizeof(keyType) }, + {CKA_CLASS, &objClass, sizeof(objClass)}, + {CKA_TOKEN, &isOnToken, sizeof(isOnToken)}, + {CKA_PRIVATE, &isPrivate, sizeof(isPrivate)}, + {CKA_KEY_TYPE, &keyType, sizeof(keyType)}, }; CK_ULONG keyAttribsCount = 4; // Add the additional if (ulCount > (maxAttribs - keyAttribsCount)) rv = CKR_TEMPLATE_INCONSISTENT; - for (CK_ULONG i=0; i < ulCount && rv == CKR_OK; ++i) + for (CK_ULONG i = 0; i < ulCount && rv == CKR_OK; ++i) { switch (pTemplate[i].type) { - case CKA_CLASS: - case CKA_TOKEN: - case CKA_PRIVATE: - case CKA_KEY_TYPE: - case CKA_CHECK_VALUE: - continue; + case CKA_CLASS: + case CKA_TOKEN: + case CKA_PRIVATE: + case CKA_KEY_TYPE: + case CKA_CHECK_VALUE: + continue; default: keyAttribs[keyAttribsCount++] = pTemplate[i]; } } if (rv == CKR_OK) - rv = this->CreateObject(hSession, keyAttribs, keyAttribsCount, phKey,OBJECT_OP_GENERATE); + rv = this->CreateObject(hSession, keyAttribs, keyAttribsCount, phKey, OBJECT_OP_GENERATE); // Store the attributes that are being supplied if (rv == CKR_OK) { - OSObject* osobject = (OSObject*)handleManager->getObject(*phKey); - if (osobject == NULL_PTR || !osobject->isValid()) - { + OSObject *osobject = (OSObject *)handleManager->getObject(*phKey); + if (osobject == NULL_PTR || !osobject->isValid()) + { rv = CKR_FUNCTION_FAILED; - } - else if (osobject->startTransaction()) - { + } + else if (osobject->startTransaction()) + { bool bOK = true; // Common Attributes - bOK = bOK && osobject->setAttribute(CKA_LOCAL,true); + bOK = bOK && osobject->setAttribute(CKA_LOCAL, true); CK_ULONG ulKeyGenMechanism = (CK_ULONG)CKM_AES_KEY_GEN; - bOK = bOK && osobject->setAttribute(CKA_KEY_GEN_MECHANISM,ulKeyGenMechanism); + bOK = bOK && osobject->setAttribute(CKA_KEY_GEN_MECHANISM, ulKeyGenMechanism); // Common Secret Key Attributes bool bAlwaysSensitive = osobject->getBooleanValue(CKA_SENSITIVE, false); - bOK = bOK && osobject->setAttribute(CKA_ALWAYS_SENSITIVE,bAlwaysSensitive); + bOK = bOK && osobject->setAttribute(CKA_ALWAYS_SENSITIVE, bAlwaysSensitive); bool bNeverExtractable = osobject->getBooleanValue(CKA_EXTRACTABLE, false) == false; bOK = bOK && osobject->setAttribute(CKA_NEVER_EXTRACTABLE, bNeverExtractable); @@ -8435,7 +8559,8 @@ CK_RV SoftHSM::generateAES if (!bOK) rv = CKR_FUNCTION_FAILED; - } else + } + else rv = CKR_FUNCTION_FAILED; } @@ -8448,9 +8573,10 @@ CK_RV SoftHSM::generateAES { if (*phKey != CK_INVALID_HANDLE) { - OSObject* oskey = (OSObject*)handleManager->getObject(*phKey); + OSObject *oskey = (OSObject *)handleManager->getObject(*phKey); handleManager->destroyObject(*phKey); - if (oskey) oskey->destroyObject(); + if (oskey) + oskey->destroyObject(); *phKey = CK_INVALID_HANDLE; } } @@ -8459,23 +8585,22 @@ CK_RV SoftHSM::generateAES } // Generate a DES secret key -CK_RV SoftHSM::generateDES -(CK_SESSION_HANDLE hSession, - CK_ATTRIBUTE_PTR pTemplate, - CK_ULONG ulCount, - CK_OBJECT_HANDLE_PTR phKey, - CK_BBOOL isOnToken, - CK_BBOOL isPrivate) +CK_RV SoftHSM::generateDES(CK_SESSION_HANDLE hSession, + CK_ATTRIBUTE_PTR pTemplate, + CK_ULONG ulCount, + CK_OBJECT_HANDLE_PTR phKey, + CK_BBOOL isOnToken, + CK_BBOOL isPrivate) { *phKey = CK_INVALID_HANDLE; // Get the session - Session* session = (Session*)handleManager->getSession(hSession); + Session *session = (Session *)handleManager->getSession(hSession); if (session == NULL) return CKR_SESSION_HANDLE_INVALID; // Get the token - Token* token = session->getToken(); + Token *token = session->getToken(); if (token == NULL) return CKR_GENERAL_ERROR; @@ -8485,29 +8610,29 @@ CK_RV SoftHSM::generateDES { switch (pTemplate[i].type) { - case CKA_CHECK_VALUE: - if (pTemplate[i].ulValueLen > 0) - { - INFO_MSG("CKA_CHECK_VALUE must be a no-value (0 length) entry"); - return CKR_ATTRIBUTE_VALUE_INVALID; - } - checkValue = false; - break; - default: - break; + case CKA_CHECK_VALUE: + if (pTemplate[i].ulValueLen > 0) + { + INFO_MSG("CKA_CHECK_VALUE must be a no-value (0 length) entry"); + return CKR_ATTRIBUTE_VALUE_INVALID; + } + checkValue = false; + break; + default: + break; } } // Generate the secret key - DESKey* key = new DESKey(56); - SymmetricAlgorithm* des = CryptoFactory::i()->getSymmetricAlgorithm(SymAlgo::DES); + DESKey *key = new DESKey(56); + SymmetricAlgorithm *des = CryptoFactory::i()->getSymmetricAlgorithm(SymAlgo::DES); if (des == NULL) { ERROR_MSG("Could not get SymmetricAlgorithm"); delete key; return CKR_GENERAL_ERROR; } - RNG* rng = CryptoFactory::i()->getRNG(); + RNG *rng = CryptoFactory::i()->getRNG(); if (rng == NULL) { ERROR_MSG("Could not get RNG"); @@ -8530,51 +8655,54 @@ CK_RV SoftHSM::generateDES CK_OBJECT_CLASS objClass = CKO_SECRET_KEY; CK_KEY_TYPE keyType = CKK_DES; CK_ATTRIBUTE keyAttribs[maxAttribs] = { - { CKA_CLASS, &objClass, sizeof(objClass) }, - { CKA_TOKEN, &isOnToken, sizeof(isOnToken) }, - { CKA_PRIVATE, &isPrivate, sizeof(isPrivate) }, - { CKA_KEY_TYPE, &keyType, sizeof(keyType) }, + {CKA_CLASS, &objClass, sizeof(objClass)}, + {CKA_TOKEN, &isOnToken, sizeof(isOnToken)}, + {CKA_PRIVATE, &isPrivate, sizeof(isPrivate)}, + {CKA_KEY_TYPE, &keyType, sizeof(keyType)}, }; CK_ULONG keyAttribsCount = 4; // Add the additional if (ulCount > (maxAttribs - keyAttribsCount)) rv = CKR_TEMPLATE_INCONSISTENT; - for (CK_ULONG i=0; i < ulCount && rv == CKR_OK; ++i) + for (CK_ULONG i = 0; i < ulCount && rv == CKR_OK; ++i) { switch (pTemplate[i].type) { - case CKA_CLASS: - case CKA_TOKEN: - case CKA_PRIVATE: - case CKA_KEY_TYPE: - case CKA_CHECK_VALUE: - continue; + case CKA_CLASS: + case CKA_TOKEN: + case CKA_PRIVATE: + case CKA_KEY_TYPE: + case CKA_CHECK_VALUE: + continue; default: keyAttribs[keyAttribsCount++] = pTemplate[i]; } } if (rv == CKR_OK) - rv = this->CreateObject(hSession, keyAttribs, keyAttribsCount, phKey,OBJECT_OP_GENERATE); + rv = this->CreateObject(hSession, keyAttribs, keyAttribsCount, phKey, OBJECT_OP_GENERATE); // Store the attributes that are being supplied if (rv == CKR_OK) { - OSObject* osobject = (OSObject*)handleManager->getObject(*phKey); - if (osobject == NULL_PTR || !osobject->isValid()) { + OSObject *osobject = (OSObject *)handleManager->getObject(*phKey); + if (osobject == NULL_PTR || !osobject->isValid()) + { rv = CKR_FUNCTION_FAILED; - } else if (osobject->startTransaction()) { + } + else if (osobject->startTransaction()) + { bool bOK = true; // Common Attributes - bOK = bOK && osobject->setAttribute(CKA_LOCAL,true); + bOK = bOK && osobject->setAttribute(CKA_LOCAL, true); CK_ULONG ulKeyGenMechanism = (CK_ULONG)CKM_DES_KEY_GEN; - bOK = bOK && osobject->setAttribute(CKA_KEY_GEN_MECHANISM,ulKeyGenMechanism); + bOK = bOK && osobject->setAttribute(CKA_KEY_GEN_MECHANISM, ulKeyGenMechanism); // Common Secret Key Attributes bool bAlwaysSensitive = osobject->getBooleanValue(CKA_SENSITIVE, false); - bOK = bOK && osobject->setAttribute(CKA_ALWAYS_SENSITIVE,bAlwaysSensitive); + bOK = bOK && osobject->setAttribute(CKA_ALWAYS_SENSITIVE, bAlwaysSensitive); bool bNeverExtractable = osobject->getBooleanValue(CKA_EXTRACTABLE, false) == false; bOK = bOK && osobject->setAttribute(CKA_NEVER_EXTRACTABLE, bNeverExtractable); @@ -8602,7 +8730,8 @@ CK_RV SoftHSM::generateDES if (!bOK) rv = CKR_FUNCTION_FAILED; - } else + } + else rv = CKR_FUNCTION_FAILED; } @@ -8615,9 +8744,10 @@ CK_RV SoftHSM::generateDES { if (*phKey != CK_INVALID_HANDLE) { - OSObject* oskey = (OSObject*)handleManager->getObject(*phKey); + OSObject *oskey = (OSObject *)handleManager->getObject(*phKey); handleManager->destroyObject(*phKey); - if (oskey) oskey->destroyObject(); + if (oskey) + oskey->destroyObject(); *phKey = CK_INVALID_HANDLE; } } @@ -8626,23 +8756,22 @@ CK_RV SoftHSM::generateDES } // Generate a DES2 secret key -CK_RV SoftHSM::generateDES2 -(CK_SESSION_HANDLE hSession, - CK_ATTRIBUTE_PTR pTemplate, - CK_ULONG ulCount, - CK_OBJECT_HANDLE_PTR phKey, - CK_BBOOL isOnToken, - CK_BBOOL isPrivate) +CK_RV SoftHSM::generateDES2(CK_SESSION_HANDLE hSession, + CK_ATTRIBUTE_PTR pTemplate, + CK_ULONG ulCount, + CK_OBJECT_HANDLE_PTR phKey, + CK_BBOOL isOnToken, + CK_BBOOL isPrivate) { *phKey = CK_INVALID_HANDLE; // Get the session - Session* session = (Session*)handleManager->getSession(hSession); + Session *session = (Session *)handleManager->getSession(hSession); if (session == NULL) return CKR_SESSION_HANDLE_INVALID; // Get the token - Token* token = session->getToken(); + Token *token = session->getToken(); if (token == NULL) return CKR_GENERAL_ERROR; @@ -8652,29 +8781,29 @@ CK_RV SoftHSM::generateDES2 { switch (pTemplate[i].type) { - case CKA_CHECK_VALUE: - if (pTemplate[i].ulValueLen > 0) - { - INFO_MSG("CKA_CHECK_VALUE must be a no-value (0 length) entry"); - return CKR_ATTRIBUTE_VALUE_INVALID; - } - checkValue = false; - break; - default: - break; + case CKA_CHECK_VALUE: + if (pTemplate[i].ulValueLen > 0) + { + INFO_MSG("CKA_CHECK_VALUE must be a no-value (0 length) entry"); + return CKR_ATTRIBUTE_VALUE_INVALID; + } + checkValue = false; + break; + default: + break; } } // Generate the secret key - DESKey* key = new DESKey(112); - SymmetricAlgorithm* des = CryptoFactory::i()->getSymmetricAlgorithm(SymAlgo::DES3); + DESKey *key = new DESKey(112); + SymmetricAlgorithm *des = CryptoFactory::i()->getSymmetricAlgorithm(SymAlgo::DES3); if (des == NULL) { ERROR_MSG("Could not get SymmetricAlgorith"); delete key; return CKR_GENERAL_ERROR; } - RNG* rng = CryptoFactory::i()->getRNG(); + RNG *rng = CryptoFactory::i()->getRNG(); if (rng == NULL) { ERROR_MSG("Could not get RNG"); @@ -8697,51 +8826,54 @@ CK_RV SoftHSM::generateDES2 CK_OBJECT_CLASS objClass = CKO_SECRET_KEY; CK_KEY_TYPE keyType = CKK_DES2; CK_ATTRIBUTE keyAttribs[maxAttribs] = { - { CKA_CLASS, &objClass, sizeof(objClass) }, - { CKA_TOKEN, &isOnToken, sizeof(isOnToken) }, - { CKA_PRIVATE, &isPrivate, sizeof(isPrivate) }, - { CKA_KEY_TYPE, &keyType, sizeof(keyType) }, + {CKA_CLASS, &objClass, sizeof(objClass)}, + {CKA_TOKEN, &isOnToken, sizeof(isOnToken)}, + {CKA_PRIVATE, &isPrivate, sizeof(isPrivate)}, + {CKA_KEY_TYPE, &keyType, sizeof(keyType)}, }; CK_ULONG keyAttribsCount = 4; // Add the additional if (ulCount > (maxAttribs - keyAttribsCount)) rv = CKR_TEMPLATE_INCONSISTENT; - for (CK_ULONG i=0; i < ulCount && rv == CKR_OK; ++i) + for (CK_ULONG i = 0; i < ulCount && rv == CKR_OK; ++i) { switch (pTemplate[i].type) { - case CKA_CLASS: - case CKA_TOKEN: - case CKA_PRIVATE: - case CKA_KEY_TYPE: - case CKA_CHECK_VALUE: - continue; + case CKA_CLASS: + case CKA_TOKEN: + case CKA_PRIVATE: + case CKA_KEY_TYPE: + case CKA_CHECK_VALUE: + continue; default: keyAttribs[keyAttribsCount++] = pTemplate[i]; } } if (rv == CKR_OK) - rv = this->CreateObject(hSession, keyAttribs, keyAttribsCount, phKey,OBJECT_OP_GENERATE); + rv = this->CreateObject(hSession, keyAttribs, keyAttribsCount, phKey, OBJECT_OP_GENERATE); // Store the attributes that are being supplied if (rv == CKR_OK) { - OSObject* osobject = (OSObject*)handleManager->getObject(*phKey); - if (osobject == NULL_PTR || !osobject->isValid()) { + OSObject *osobject = (OSObject *)handleManager->getObject(*phKey); + if (osobject == NULL_PTR || !osobject->isValid()) + { rv = CKR_FUNCTION_FAILED; - } else if (osobject->startTransaction()) { + } + else if (osobject->startTransaction()) + { bool bOK = true; // Common Attributes - bOK = bOK && osobject->setAttribute(CKA_LOCAL,true); + bOK = bOK && osobject->setAttribute(CKA_LOCAL, true); CK_ULONG ulKeyGenMechanism = (CK_ULONG)CKM_DES2_KEY_GEN; - bOK = bOK && osobject->setAttribute(CKA_KEY_GEN_MECHANISM,ulKeyGenMechanism); + bOK = bOK && osobject->setAttribute(CKA_KEY_GEN_MECHANISM, ulKeyGenMechanism); // Common Secret Key Attributes bool bAlwaysSensitive = osobject->getBooleanValue(CKA_SENSITIVE, false); - bOK = bOK && osobject->setAttribute(CKA_ALWAYS_SENSITIVE,bAlwaysSensitive); + bOK = bOK && osobject->setAttribute(CKA_ALWAYS_SENSITIVE, bAlwaysSensitive); bool bNeverExtractable = osobject->getBooleanValue(CKA_EXTRACTABLE, false) == false; bOK = bOK && osobject->setAttribute(CKA_NEVER_EXTRACTABLE, bNeverExtractable); @@ -8769,7 +8901,8 @@ CK_RV SoftHSM::generateDES2 if (!bOK) rv = CKR_FUNCTION_FAILED; - } else + } + else rv = CKR_FUNCTION_FAILED; } @@ -8782,9 +8915,10 @@ CK_RV SoftHSM::generateDES2 { if (*phKey != CK_INVALID_HANDLE) { - OSObject* oskey = (OSObject*)handleManager->getObject(*phKey); + OSObject *oskey = (OSObject *)handleManager->getObject(*phKey); handleManager->destroyObject(*phKey); - if (oskey) oskey->destroyObject(); + if (oskey) + oskey->destroyObject(); *phKey = CK_INVALID_HANDLE; } } @@ -8793,23 +8927,22 @@ CK_RV SoftHSM::generateDES2 } // Generate a DES3 secret key -CK_RV SoftHSM::generateDES3 -(CK_SESSION_HANDLE hSession, - CK_ATTRIBUTE_PTR pTemplate, - CK_ULONG ulCount, - CK_OBJECT_HANDLE_PTR phKey, - CK_BBOOL isOnToken, - CK_BBOOL isPrivate) +CK_RV SoftHSM::generateDES3(CK_SESSION_HANDLE hSession, + CK_ATTRIBUTE_PTR pTemplate, + CK_ULONG ulCount, + CK_OBJECT_HANDLE_PTR phKey, + CK_BBOOL isOnToken, + CK_BBOOL isPrivate) { *phKey = CK_INVALID_HANDLE; // Get the session - Session* session = (Session*)handleManager->getSession(hSession); + Session *session = (Session *)handleManager->getSession(hSession); if (session == NULL) return CKR_SESSION_HANDLE_INVALID; // Get the token - Token* token = session->getToken(); + Token *token = session->getToken(); if (token == NULL) return CKR_GENERAL_ERROR; @@ -8819,29 +8952,29 @@ CK_RV SoftHSM::generateDES3 { switch (pTemplate[i].type) { - case CKA_CHECK_VALUE: - if (pTemplate[i].ulValueLen > 0) - { - INFO_MSG("CKA_CHECK_VALUE must be a no-value (0 length) entry"); - return CKR_ATTRIBUTE_VALUE_INVALID; - } - checkValue = false; - break; - default: - break; + case CKA_CHECK_VALUE: + if (pTemplate[i].ulValueLen > 0) + { + INFO_MSG("CKA_CHECK_VALUE must be a no-value (0 length) entry"); + return CKR_ATTRIBUTE_VALUE_INVALID; + } + checkValue = false; + break; + default: + break; } } // Generate the secret key - DESKey* key = new DESKey(168); - SymmetricAlgorithm* des = CryptoFactory::i()->getSymmetricAlgorithm(SymAlgo::DES3); + DESKey *key = new DESKey(168); + SymmetricAlgorithm *des = CryptoFactory::i()->getSymmetricAlgorithm(SymAlgo::DES3); if (des == NULL) { ERROR_MSG("Could not get SymmetricAlgorithm"); delete key; return CKR_GENERAL_ERROR; } - RNG* rng = CryptoFactory::i()->getRNG(); + RNG *rng = CryptoFactory::i()->getRNG(); if (rng == NULL) { ERROR_MSG("Could not get RNG"); @@ -8864,51 +8997,54 @@ CK_RV SoftHSM::generateDES3 CK_OBJECT_CLASS objClass = CKO_SECRET_KEY; CK_KEY_TYPE keyType = CKK_DES3; CK_ATTRIBUTE keyAttribs[maxAttribs] = { - { CKA_CLASS, &objClass, sizeof(objClass) }, - { CKA_TOKEN, &isOnToken, sizeof(isOnToken) }, - { CKA_PRIVATE, &isPrivate, sizeof(isPrivate) }, - { CKA_KEY_TYPE, &keyType, sizeof(keyType) }, + {CKA_CLASS, &objClass, sizeof(objClass)}, + {CKA_TOKEN, &isOnToken, sizeof(isOnToken)}, + {CKA_PRIVATE, &isPrivate, sizeof(isPrivate)}, + {CKA_KEY_TYPE, &keyType, sizeof(keyType)}, }; CK_ULONG keyAttribsCount = 4; // Add the additional if (ulCount > (maxAttribs - keyAttribsCount)) rv = CKR_TEMPLATE_INCONSISTENT; - for (CK_ULONG i=0; i < ulCount && rv == CKR_OK; ++i) + for (CK_ULONG i = 0; i < ulCount && rv == CKR_OK; ++i) { switch (pTemplate[i].type) { - case CKA_CLASS: - case CKA_TOKEN: - case CKA_PRIVATE: - case CKA_KEY_TYPE: - case CKA_CHECK_VALUE: - continue; + case CKA_CLASS: + case CKA_TOKEN: + case CKA_PRIVATE: + case CKA_KEY_TYPE: + case CKA_CHECK_VALUE: + continue; default: keyAttribs[keyAttribsCount++] = pTemplate[i]; } } if (rv == CKR_OK) - rv = this->CreateObject(hSession, keyAttribs, keyAttribsCount, phKey,OBJECT_OP_GENERATE); + rv = this->CreateObject(hSession, keyAttribs, keyAttribsCount, phKey, OBJECT_OP_GENERATE); // Store the attributes that are being supplied if (rv == CKR_OK) { - OSObject* osobject = (OSObject*)handleManager->getObject(*phKey); - if (osobject == NULL_PTR || !osobject->isValid()) { + OSObject *osobject = (OSObject *)handleManager->getObject(*phKey); + if (osobject == NULL_PTR || !osobject->isValid()) + { rv = CKR_FUNCTION_FAILED; - } else if (osobject->startTransaction()) { + } + else if (osobject->startTransaction()) + { bool bOK = true; // Common Attributes - bOK = bOK && osobject->setAttribute(CKA_LOCAL,true); + bOK = bOK && osobject->setAttribute(CKA_LOCAL, true); CK_ULONG ulKeyGenMechanism = (CK_ULONG)CKM_DES3_KEY_GEN; - bOK = bOK && osobject->setAttribute(CKA_KEY_GEN_MECHANISM,ulKeyGenMechanism); + bOK = bOK && osobject->setAttribute(CKA_KEY_GEN_MECHANISM, ulKeyGenMechanism); // Common Secret Key Attributes bool bAlwaysSensitive = osobject->getBooleanValue(CKA_SENSITIVE, false); - bOK = bOK && osobject->setAttribute(CKA_ALWAYS_SENSITIVE,bAlwaysSensitive); + bOK = bOK && osobject->setAttribute(CKA_ALWAYS_SENSITIVE, bAlwaysSensitive); bool bNeverExtractable = osobject->getBooleanValue(CKA_EXTRACTABLE, false) == false; bOK = bOK && osobject->setAttribute(CKA_NEVER_EXTRACTABLE, bNeverExtractable); @@ -8936,7 +9072,8 @@ CK_RV SoftHSM::generateDES3 if (!bOK) rv = CKR_FUNCTION_FAILED; - } else + } + else rv = CKR_FUNCTION_FAILED; } @@ -8949,9 +9086,10 @@ CK_RV SoftHSM::generateDES3 { if (*phKey != CK_INVALID_HANDLE) { - OSObject* oskey = (OSObject*)handleManager->getObject(*phKey); + OSObject *oskey = (OSObject *)handleManager->getObject(*phKey); handleManager->destroyObject(*phKey); - if (oskey) oskey->destroyObject(); + if (oskey) + oskey->destroyObject(); *phKey = CK_INVALID_HANDLE; } } @@ -8960,30 +9098,28 @@ CK_RV SoftHSM::generateDES3 } // Generate an RSA key pair -CK_RV SoftHSM::generateRSA -(CK_SESSION_HANDLE hSession, - CK_ATTRIBUTE_PTR pPublicKeyTemplate, - CK_ULONG ulPublicKeyAttributeCount, - CK_ATTRIBUTE_PTR pPrivateKeyTemplate, - CK_ULONG ulPrivateKeyAttributeCount, - CK_OBJECT_HANDLE_PTR phPublicKey, - CK_OBJECT_HANDLE_PTR phPrivateKey, - CK_BBOOL isPublicKeyOnToken, - CK_BBOOL isPublicKeyPrivate, - CK_BBOOL isPrivateKeyOnToken, - CK_BBOOL isPrivateKeyPrivate -) +CK_RV SoftHSM::generateRSA(CK_SESSION_HANDLE hSession, + CK_ATTRIBUTE_PTR pPublicKeyTemplate, + CK_ULONG ulPublicKeyAttributeCount, + CK_ATTRIBUTE_PTR pPrivateKeyTemplate, + CK_ULONG ulPrivateKeyAttributeCount, + CK_OBJECT_HANDLE_PTR phPublicKey, + CK_OBJECT_HANDLE_PTR phPrivateKey, + CK_BBOOL isPublicKeyOnToken, + CK_BBOOL isPublicKeyPrivate, + CK_BBOOL isPrivateKeyOnToken, + CK_BBOOL isPrivateKeyPrivate) { *phPublicKey = CK_INVALID_HANDLE; *phPrivateKey = CK_INVALID_HANDLE; // Get the session - Session* session = (Session*)handleManager->getSession(hSession); + Session *session = (Session *)handleManager->getSession(hSession); if (session == NULL) return CKR_SESSION_HANDLE_INVALID; // Get the token - Token* token = session->getToken(); + Token *token = session->getToken(); if (token == NULL) return CKR_GENERAL_ERROR; @@ -8994,24 +9130,25 @@ CK_RV SoftHSM::generateRSA { switch (pPublicKeyTemplate[i].type) { - case CKA_MODULUS_BITS: - if (pPublicKeyTemplate[i].ulValueLen != sizeof(CK_ULONG)) - { - INFO_MSG("CKA_MODULUS_BITS does not have the size of CK_ULONG"); - return CKR_ATTRIBUTE_VALUE_INVALID; - } - bitLen = *(CK_ULONG*)pPublicKeyTemplate[i].pValue; - break; - case CKA_PUBLIC_EXPONENT: - exponent = ByteString((unsigned char*)pPublicKeyTemplate[i].pValue, pPublicKeyTemplate[i].ulValueLen); - break; - default: - break; + case CKA_MODULUS_BITS: + if (pPublicKeyTemplate[i].ulValueLen != sizeof(CK_ULONG)) + { + INFO_MSG("CKA_MODULUS_BITS does not have the size of CK_ULONG"); + return CKR_ATTRIBUTE_VALUE_INVALID; + } + bitLen = *(CK_ULONG *)pPublicKeyTemplate[i].pValue; + break; + case CKA_PUBLIC_EXPONENT: + exponent = ByteString((unsigned char *)pPublicKeyTemplate[i].pValue, pPublicKeyTemplate[i].ulValueLen); + break; + default: + break; } } // CKA_MODULUS_BITS must be specified to be able to generate a key pair. - if (bitLen == 0) { + if (bitLen == 0) + { INFO_MSG("Missing CKA_MODULUS_BITS in pPublicKeyTemplate"); return CKR_TEMPLATE_INCOMPLETE; } @@ -9022,8 +9159,8 @@ CK_RV SoftHSM::generateRSA p.setBitLength(bitLen); // Generate key pair - AsymmetricKeyPair* kp = NULL; - AsymmetricAlgorithm* rsa = CryptoFactory::i()->getAsymmetricAlgorithm(AsymAlgo::RSA); + AsymmetricKeyPair *kp = NULL; + AsymmetricAlgorithm *rsa = CryptoFactory::i()->getAsymmetricAlgorithm(AsymAlgo::RSA); if (rsa == NULL) return CKR_GENERAL_ERROR; if (!rsa->generateKeyPair(&kp, &p)) @@ -9033,8 +9170,8 @@ CK_RV SoftHSM::generateRSA return CKR_GENERAL_ERROR; } - RSAPublicKey* pub = (RSAPublicKey*) kp->getPublicKey(); - RSAPrivateKey* priv = (RSAPrivateKey*) kp->getPrivateKey(); + RSAPublicKey *pub = (RSAPublicKey *)kp->getPublicKey(); + RSAPrivateKey *priv = (RSAPrivateKey *)kp->getPrivateKey(); CK_RV rv = CKR_OK; @@ -9045,47 +9182,50 @@ CK_RV SoftHSM::generateRSA CK_OBJECT_CLASS publicKeyClass = CKO_PUBLIC_KEY; CK_KEY_TYPE publicKeyType = CKK_RSA; CK_ATTRIBUTE publicKeyAttribs[maxAttribs] = { - { CKA_CLASS, &publicKeyClass, sizeof(publicKeyClass) }, - { CKA_TOKEN, &isPublicKeyOnToken, sizeof(isPublicKeyOnToken) }, - { CKA_PRIVATE, &isPublicKeyPrivate, sizeof(isPublicKeyPrivate) }, - { CKA_KEY_TYPE, &publicKeyType, sizeof(publicKeyType) }, + {CKA_CLASS, &publicKeyClass, sizeof(publicKeyClass)}, + {CKA_TOKEN, &isPublicKeyOnToken, sizeof(isPublicKeyOnToken)}, + {CKA_PRIVATE, &isPublicKeyPrivate, sizeof(isPublicKeyPrivate)}, + {CKA_KEY_TYPE, &publicKeyType, sizeof(publicKeyType)}, }; CK_ULONG publicKeyAttribsCount = 4; // Add the additional if (ulPublicKeyAttributeCount > (maxAttribs - publicKeyAttribsCount)) rv = CKR_TEMPLATE_INCONSISTENT; - for (CK_ULONG i=0; i < ulPublicKeyAttributeCount && rv == CKR_OK; ++i) + for (CK_ULONG i = 0; i < ulPublicKeyAttributeCount && rv == CKR_OK; ++i) { switch (pPublicKeyTemplate[i].type) { - case CKA_CLASS: - case CKA_TOKEN: - case CKA_PRIVATE: - case CKA_KEY_TYPE: - case CKA_PUBLIC_EXPONENT: - continue; - default: - publicKeyAttribs[publicKeyAttribsCount++] = pPublicKeyTemplate[i]; + case CKA_CLASS: + case CKA_TOKEN: + case CKA_PRIVATE: + case CKA_KEY_TYPE: + case CKA_PUBLIC_EXPONENT: + continue; + default: + publicKeyAttribs[publicKeyAttribsCount++] = pPublicKeyTemplate[i]; } } if (rv == CKR_OK) - rv = this->CreateObject(hSession,publicKeyAttribs,publicKeyAttribsCount,phPublicKey,OBJECT_OP_GENERATE); + rv = this->CreateObject(hSession, publicKeyAttribs, publicKeyAttribsCount, phPublicKey, OBJECT_OP_GENERATE); // Store the attributes that are being supplied by the key generation to the object if (rv == CKR_OK) { - OSObject* osobject = (OSObject*)handleManager->getObject(*phPublicKey); - if (osobject == NULL_PTR || !osobject->isValid()) { + OSObject *osobject = (OSObject *)handleManager->getObject(*phPublicKey); + if (osobject == NULL_PTR || !osobject->isValid()) + { rv = CKR_FUNCTION_FAILED; - } else if (osobject->startTransaction()) { + } + else if (osobject->startTransaction()) + { bool bOK = true; // Common Key Attributes - bOK = bOK && osobject->setAttribute(CKA_LOCAL,true); + bOK = bOK && osobject->setAttribute(CKA_LOCAL, true); CK_ULONG ulKeyGenMechanism = (CK_ULONG)CKM_RSA_PKCS_KEY_PAIR_GEN; - bOK = bOK && osobject->setAttribute(CKA_KEY_GEN_MECHANISM,ulKeyGenMechanism); + bOK = bOK && osobject->setAttribute(CKA_KEY_GEN_MECHANISM, ulKeyGenMechanism); // RSA Public Key Attributes ByteString modulus; @@ -9110,7 +9250,8 @@ CK_RV SoftHSM::generateRSA if (!bOK) rv = CKR_FUNCTION_FAILED; - } else + } + else rv = CKR_FUNCTION_FAILED; } } @@ -9122,48 +9263,51 @@ CK_RV SoftHSM::generateRSA CK_OBJECT_CLASS privateKeyClass = CKO_PRIVATE_KEY; CK_KEY_TYPE privateKeyType = CKK_RSA; CK_ATTRIBUTE privateKeyAttribs[maxAttribs] = { - { CKA_CLASS, &privateKeyClass, sizeof(privateKeyClass) }, - { CKA_TOKEN, &isPrivateKeyOnToken, sizeof(isPrivateKeyOnToken) }, - { CKA_PRIVATE, &isPrivateKeyPrivate, sizeof(isPrivateKeyPrivate) }, - { CKA_KEY_TYPE, &privateKeyType, sizeof(privateKeyType) }, + {CKA_CLASS, &privateKeyClass, sizeof(privateKeyClass)}, + {CKA_TOKEN, &isPrivateKeyOnToken, sizeof(isPrivateKeyOnToken)}, + {CKA_PRIVATE, &isPrivateKeyPrivate, sizeof(isPrivateKeyPrivate)}, + {CKA_KEY_TYPE, &privateKeyType, sizeof(privateKeyType)}, }; CK_ULONG privateKeyAttribsCount = 4; if (ulPrivateKeyAttributeCount > (maxAttribs - privateKeyAttribsCount)) rv = CKR_TEMPLATE_INCONSISTENT; - for (CK_ULONG i=0; i < ulPrivateKeyAttributeCount && rv == CKR_OK; ++i) + for (CK_ULONG i = 0; i < ulPrivateKeyAttributeCount && rv == CKR_OK; ++i) { switch (pPrivateKeyTemplate[i].type) { - case CKA_CLASS: - case CKA_TOKEN: - case CKA_PRIVATE: - case CKA_KEY_TYPE: - continue; - default: - privateKeyAttribs[privateKeyAttribsCount++] = pPrivateKeyTemplate[i]; - } - } + case CKA_CLASS: + case CKA_TOKEN: + case CKA_PRIVATE: + case CKA_KEY_TYPE: + continue; + default: + privateKeyAttribs[privateKeyAttribsCount++] = pPrivateKeyTemplate[i]; + } + } if (rv == CKR_OK) - rv = this->CreateObject(hSession,privateKeyAttribs,privateKeyAttribsCount,phPrivateKey,OBJECT_OP_GENERATE); + rv = this->CreateObject(hSession, privateKeyAttribs, privateKeyAttribsCount, phPrivateKey, OBJECT_OP_GENERATE); // Store the attributes that are being supplied by the key generation to the object if (rv == CKR_OK) { - OSObject* osobject = (OSObject*)handleManager->getObject(*phPrivateKey); - if (osobject == NULL_PTR || !osobject->isValid()) { + OSObject *osobject = (OSObject *)handleManager->getObject(*phPrivateKey); + if (osobject == NULL_PTR || !osobject->isValid()) + { rv = CKR_FUNCTION_FAILED; - } else if (osobject->startTransaction()) { + } + else if (osobject->startTransaction()) + { bool bOK = true; // Common Key Attributes - bOK = bOK && osobject->setAttribute(CKA_LOCAL,true); + bOK = bOK && osobject->setAttribute(CKA_LOCAL, true); CK_ULONG ulKeyGenMechanism = (CK_ULONG)CKM_RSA_PKCS_KEY_PAIR_GEN; - bOK = bOK && osobject->setAttribute(CKA_KEY_GEN_MECHANISM,ulKeyGenMechanism); + bOK = bOK && osobject->setAttribute(CKA_KEY_GEN_MECHANISM, ulKeyGenMechanism); // Common Private Key Attributes bool bAlwaysSensitive = osobject->getBooleanValue(CKA_SENSITIVE, false); - bOK = bOK && osobject->setAttribute(CKA_ALWAYS_SENSITIVE,bAlwaysSensitive); + bOK = bOK && osobject->setAttribute(CKA_ALWAYS_SENSITIVE, bAlwaysSensitive); bool bNeverExtractable = osobject->getBooleanValue(CKA_EXTRACTABLE, false) == false; bOK = bOK && osobject->setAttribute(CKA_NEVER_EXTRACTABLE, bNeverExtractable); @@ -9194,7 +9338,7 @@ CK_RV SoftHSM::generateRSA privateExponent = priv->getD(); prime1 = priv->getP(); prime2 = priv->getQ(); - exponent1 = priv->getDP1(); + exponent1 = priv->getDP1(); exponent2 = priv->getDQ1(); coefficient = priv->getPQ(); } @@ -9203,7 +9347,7 @@ CK_RV SoftHSM::generateRSA bOK = bOK && osobject->setAttribute(CKA_PRIVATE_EXPONENT, privateExponent); bOK = bOK && osobject->setAttribute(CKA_PRIME_1, prime1); bOK = bOK && osobject->setAttribute(CKA_PRIME_2, prime2); - bOK = bOK && osobject->setAttribute(CKA_EXPONENT_1,exponent1); + bOK = bOK && osobject->setAttribute(CKA_EXPONENT_1, exponent1); bOK = bOK && osobject->setAttribute(CKA_EXPONENT_2, exponent2); bOK = bOK && osobject->setAttribute(CKA_COEFFICIENT, coefficient); @@ -9214,7 +9358,8 @@ CK_RV SoftHSM::generateRSA if (!bOK) rv = CKR_FUNCTION_FAILED; - } else + } + else rv = CKR_FUNCTION_FAILED; } } @@ -9228,17 +9373,19 @@ CK_RV SoftHSM::generateRSA { if (*phPrivateKey != CK_INVALID_HANDLE) { - OSObject* ospriv = (OSObject*)handleManager->getObject(*phPrivateKey); + OSObject *ospriv = (OSObject *)handleManager->getObject(*phPrivateKey); handleManager->destroyObject(*phPrivateKey); - if (ospriv) ospriv->destroyObject(); + if (ospriv) + ospriv->destroyObject(); *phPrivateKey = CK_INVALID_HANDLE; } if (*phPublicKey != CK_INVALID_HANDLE) { - OSObject* ospub = (OSObject*)handleManager->getObject(*phPublicKey); + OSObject *ospub = (OSObject *)handleManager->getObject(*phPublicKey); handleManager->destroyObject(*phPublicKey); - if (ospub) ospub->destroyObject(); + if (ospub) + ospub->destroyObject(); *phPublicKey = CK_INVALID_HANDLE; } } @@ -9247,29 +9394,28 @@ CK_RV SoftHSM::generateRSA } // Generate a DSA key pair -CK_RV SoftHSM::generateDSA -(CK_SESSION_HANDLE hSession, - CK_ATTRIBUTE_PTR pPublicKeyTemplate, - CK_ULONG ulPublicKeyAttributeCount, - CK_ATTRIBUTE_PTR pPrivateKeyTemplate, - CK_ULONG ulPrivateKeyAttributeCount, - CK_OBJECT_HANDLE_PTR phPublicKey, - CK_OBJECT_HANDLE_PTR phPrivateKey, - CK_BBOOL isPublicKeyOnToken, - CK_BBOOL isPublicKeyPrivate, - CK_BBOOL isPrivateKeyOnToken, - CK_BBOOL isPrivateKeyPrivate) +CK_RV SoftHSM::generateDSA(CK_SESSION_HANDLE hSession, + CK_ATTRIBUTE_PTR pPublicKeyTemplate, + CK_ULONG ulPublicKeyAttributeCount, + CK_ATTRIBUTE_PTR pPrivateKeyTemplate, + CK_ULONG ulPrivateKeyAttributeCount, + CK_OBJECT_HANDLE_PTR phPublicKey, + CK_OBJECT_HANDLE_PTR phPrivateKey, + CK_BBOOL isPublicKeyOnToken, + CK_BBOOL isPublicKeyPrivate, + CK_BBOOL isPrivateKeyOnToken, + CK_BBOOL isPrivateKeyPrivate) { *phPublicKey = CK_INVALID_HANDLE; *phPrivateKey = CK_INVALID_HANDLE; // Get the session - Session* session = (Session*)handleManager->getSession(hSession); + Session *session = (Session *)handleManager->getSession(hSession); if (session == NULL) return CKR_SESSION_HANDLE_INVALID; // Get the token - Token* token = session->getToken(); + Token *token = session->getToken(); if (token == NULL) return CKR_GENERAL_ERROR; @@ -9281,22 +9427,23 @@ CK_RV SoftHSM::generateDSA { switch (pPublicKeyTemplate[i].type) { - case CKA_PRIME: - prime = ByteString((unsigned char*)pPublicKeyTemplate[i].pValue, pPublicKeyTemplate[i].ulValueLen); - break; - case CKA_SUBPRIME: - subprime = ByteString((unsigned char*)pPublicKeyTemplate[i].pValue, pPublicKeyTemplate[i].ulValueLen); - break; - case CKA_BASE: - generator = ByteString((unsigned char*)pPublicKeyTemplate[i].pValue, pPublicKeyTemplate[i].ulValueLen); - break; - default: - break; + case CKA_PRIME: + prime = ByteString((unsigned char *)pPublicKeyTemplate[i].pValue, pPublicKeyTemplate[i].ulValueLen); + break; + case CKA_SUBPRIME: + subprime = ByteString((unsigned char *)pPublicKeyTemplate[i].pValue, pPublicKeyTemplate[i].ulValueLen); + break; + case CKA_BASE: + generator = ByteString((unsigned char *)pPublicKeyTemplate[i].pValue, pPublicKeyTemplate[i].ulValueLen); + break; + default: + break; } } // The parameters must be specified to be able to generate a key pair. - if (prime.size() == 0 || subprime.size() == 0 || generator.size() == 0) { + if (prime.size() == 0 || subprime.size() == 0 || generator.size() == 0) + { INFO_MSG("Missing parameter(s) in pPublicKeyTemplate"); return CKR_TEMPLATE_INCOMPLETE; } @@ -9308,9 +9455,10 @@ CK_RV SoftHSM::generateDSA p.setG(generator); // Generate key pair - AsymmetricKeyPair* kp = NULL; - AsymmetricAlgorithm* dsa = CryptoFactory::i()->getAsymmetricAlgorithm(AsymAlgo::DSA); - if (dsa == NULL) return CKR_GENERAL_ERROR; + AsymmetricKeyPair *kp = NULL; + AsymmetricAlgorithm *dsa = CryptoFactory::i()->getAsymmetricAlgorithm(AsymAlgo::DSA); + if (dsa == NULL) + return CKR_GENERAL_ERROR; if (!dsa->generateKeyPair(&kp, &p)) { ERROR_MSG("Could not generate key pair"); @@ -9318,8 +9466,8 @@ CK_RV SoftHSM::generateDSA return CKR_GENERAL_ERROR; } - DSAPublicKey* pub = (DSAPublicKey*) kp->getPublicKey(); - DSAPrivateKey* priv = (DSAPrivateKey*) kp->getPrivateKey(); + DSAPublicKey *pub = (DSAPublicKey *)kp->getPublicKey(); + DSAPrivateKey *priv = (DSAPrivateKey *)kp->getPrivateKey(); CK_RV rv = CKR_OK; @@ -9330,46 +9478,49 @@ CK_RV SoftHSM::generateDSA CK_OBJECT_CLASS publicKeyClass = CKO_PUBLIC_KEY; CK_KEY_TYPE publicKeyType = CKK_DSA; CK_ATTRIBUTE publicKeyAttribs[maxAttribs] = { - { CKA_CLASS, &publicKeyClass, sizeof(publicKeyClass) }, - { CKA_TOKEN, &isPublicKeyOnToken, sizeof(isPublicKeyOnToken) }, - { CKA_PRIVATE, &isPublicKeyPrivate, sizeof(isPublicKeyPrivate) }, - { CKA_KEY_TYPE, &publicKeyType, sizeof(publicKeyType) }, + {CKA_CLASS, &publicKeyClass, sizeof(publicKeyClass)}, + {CKA_TOKEN, &isPublicKeyOnToken, sizeof(isPublicKeyOnToken)}, + {CKA_PRIVATE, &isPublicKeyPrivate, sizeof(isPublicKeyPrivate)}, + {CKA_KEY_TYPE, &publicKeyType, sizeof(publicKeyType)}, }; CK_ULONG publicKeyAttribsCount = 4; // Add the additional if (ulPublicKeyAttributeCount > (maxAttribs - publicKeyAttribsCount)) rv = CKR_TEMPLATE_INCONSISTENT; - for (CK_ULONG i=0; i < ulPublicKeyAttributeCount && rv == CKR_OK; ++i) + for (CK_ULONG i = 0; i < ulPublicKeyAttributeCount && rv == CKR_OK; ++i) { switch (pPublicKeyTemplate[i].type) { - case CKA_CLASS: - case CKA_TOKEN: - case CKA_PRIVATE: - case CKA_KEY_TYPE: - continue; - default: - publicKeyAttribs[publicKeyAttribsCount++] = pPublicKeyTemplate[i]; + case CKA_CLASS: + case CKA_TOKEN: + case CKA_PRIVATE: + case CKA_KEY_TYPE: + continue; + default: + publicKeyAttribs[publicKeyAttribsCount++] = pPublicKeyTemplate[i]; } } if (rv == CKR_OK) - rv = this->CreateObject(hSession,publicKeyAttribs,publicKeyAttribsCount,phPublicKey,OBJECT_OP_GENERATE); + rv = this->CreateObject(hSession, publicKeyAttribs, publicKeyAttribsCount, phPublicKey, OBJECT_OP_GENERATE); // Store the attributes that are being supplied by the key generation to the object if (rv == CKR_OK) { - OSObject* osobject = (OSObject*)handleManager->getObject(*phPublicKey); - if (osobject == NULL_PTR || !osobject->isValid()) { + OSObject *osobject = (OSObject *)handleManager->getObject(*phPublicKey); + if (osobject == NULL_PTR || !osobject->isValid()) + { rv = CKR_FUNCTION_FAILED; - } else if (osobject->startTransaction()) { + } + else if (osobject->startTransaction()) + { bool bOK = true; // Common Key Attributes - bOK = bOK && osobject->setAttribute(CKA_LOCAL,true); + bOK = bOK && osobject->setAttribute(CKA_LOCAL, true); CK_ULONG ulKeyGenMechanism = (CK_ULONG)CKM_DSA_KEY_PAIR_GEN; - bOK = bOK && osobject->setAttribute(CKA_KEY_GEN_MECHANISM,ulKeyGenMechanism); + bOK = bOK && osobject->setAttribute(CKA_KEY_GEN_MECHANISM, ulKeyGenMechanism); // DSA Public Key Attributes ByteString value; @@ -9390,7 +9541,8 @@ CK_RV SoftHSM::generateDSA if (!bOK) rv = CKR_FUNCTION_FAILED; - } else + } + else rv = CKR_FUNCTION_FAILED; } } @@ -9402,48 +9554,51 @@ CK_RV SoftHSM::generateDSA CK_OBJECT_CLASS privateKeyClass = CKO_PRIVATE_KEY; CK_KEY_TYPE privateKeyType = CKK_DSA; CK_ATTRIBUTE privateKeyAttribs[maxAttribs] = { - { CKA_CLASS, &privateKeyClass, sizeof(privateKeyClass) }, - { CKA_TOKEN, &isPrivateKeyOnToken, sizeof(isPrivateKeyOnToken) }, - { CKA_PRIVATE, &isPrivateKeyPrivate, sizeof(isPrivateKeyPrivate) }, - { CKA_KEY_TYPE, &privateKeyType, sizeof(privateKeyType) }, + {CKA_CLASS, &privateKeyClass, sizeof(privateKeyClass)}, + {CKA_TOKEN, &isPrivateKeyOnToken, sizeof(isPrivateKeyOnToken)}, + {CKA_PRIVATE, &isPrivateKeyPrivate, sizeof(isPrivateKeyPrivate)}, + {CKA_KEY_TYPE, &privateKeyType, sizeof(privateKeyType)}, }; CK_ULONG privateKeyAttribsCount = 4; if (ulPrivateKeyAttributeCount > (maxAttribs - privateKeyAttribsCount)) rv = CKR_TEMPLATE_INCONSISTENT; - for (CK_ULONG i=0; i < ulPrivateKeyAttributeCount && rv == CKR_OK; ++i) + for (CK_ULONG i = 0; i < ulPrivateKeyAttributeCount && rv == CKR_OK; ++i) { switch (pPrivateKeyTemplate[i].type) { - case CKA_CLASS: - case CKA_TOKEN: - case CKA_PRIVATE: - case CKA_KEY_TYPE: - continue; - default: - privateKeyAttribs[privateKeyAttribsCount++] = pPrivateKeyTemplate[i]; + case CKA_CLASS: + case CKA_TOKEN: + case CKA_PRIVATE: + case CKA_KEY_TYPE: + continue; + default: + privateKeyAttribs[privateKeyAttribsCount++] = pPrivateKeyTemplate[i]; } } if (rv == CKR_OK) - rv = this->CreateObject(hSession,privateKeyAttribs,privateKeyAttribsCount,phPrivateKey,OBJECT_OP_GENERATE); + rv = this->CreateObject(hSession, privateKeyAttribs, privateKeyAttribsCount, phPrivateKey, OBJECT_OP_GENERATE); // Store the attributes that are being supplied by the key generation to the object if (rv == CKR_OK) { - OSObject* osobject = (OSObject*)handleManager->getObject(*phPrivateKey); - if (osobject == NULL_PTR || !osobject->isValid()) { + OSObject *osobject = (OSObject *)handleManager->getObject(*phPrivateKey); + if (osobject == NULL_PTR || !osobject->isValid()) + { rv = CKR_FUNCTION_FAILED; - } else if (osobject->startTransaction()) { + } + else if (osobject->startTransaction()) + { bool bOK = true; // Common Key Attributes - bOK = bOK && osobject->setAttribute(CKA_LOCAL,true); + bOK = bOK && osobject->setAttribute(CKA_LOCAL, true); CK_ULONG ulKeyGenMechanism = (CK_ULONG)CKM_DSA_KEY_PAIR_GEN; - bOK = bOK && osobject->setAttribute(CKA_KEY_GEN_MECHANISM,ulKeyGenMechanism); + bOK = bOK && osobject->setAttribute(CKA_KEY_GEN_MECHANISM, ulKeyGenMechanism); // Common Private Key Attributes bool bAlwaysSensitive = osobject->getBooleanValue(CKA_SENSITIVE, false); - bOK = bOK && osobject->setAttribute(CKA_ALWAYS_SENSITIVE,bAlwaysSensitive); + bOK = bOK && osobject->setAttribute(CKA_ALWAYS_SENSITIVE, bAlwaysSensitive); bool bNeverExtractable = osobject->getBooleanValue(CKA_EXTRACTABLE, false) == false; bOK = bOK && osobject->setAttribute(CKA_NEVER_EXTRACTABLE, bNeverExtractable); @@ -9478,7 +9633,8 @@ CK_RV SoftHSM::generateDSA if (!bOK) rv = CKR_FUNCTION_FAILED; - } else + } + else rv = CKR_FUNCTION_FAILED; } } @@ -9492,17 +9648,19 @@ CK_RV SoftHSM::generateDSA { if (*phPrivateKey != CK_INVALID_HANDLE) { - OSObject* ospriv = (OSObject*)handleManager->getObject(*phPrivateKey); + OSObject *ospriv = (OSObject *)handleManager->getObject(*phPrivateKey); handleManager->destroyObject(*phPrivateKey); - if (ospriv) ospriv->destroyObject(); + if (ospriv) + ospriv->destroyObject(); *phPrivateKey = CK_INVALID_HANDLE; } if (*phPublicKey != CK_INVALID_HANDLE) { - OSObject* ospub = (OSObject*)handleManager->getObject(*phPublicKey); + OSObject *ospub = (OSObject *)handleManager->getObject(*phPublicKey); handleManager->destroyObject(*phPublicKey); - if (ospub) ospub->destroyObject(); + if (ospub) + ospub->destroyObject(); *phPublicKey = CK_INVALID_HANDLE; } } @@ -9511,23 +9669,22 @@ CK_RV SoftHSM::generateDSA } // Generate a DSA domain parameter set -CK_RV SoftHSM::generateDSAParameters -(CK_SESSION_HANDLE hSession, - CK_ATTRIBUTE_PTR pTemplate, - CK_ULONG ulCount, - CK_OBJECT_HANDLE_PTR phKey, - CK_BBOOL isOnToken, - CK_BBOOL isPrivate) +CK_RV SoftHSM::generateDSAParameters(CK_SESSION_HANDLE hSession, + CK_ATTRIBUTE_PTR pTemplate, + CK_ULONG ulCount, + CK_OBJECT_HANDLE_PTR phKey, + CK_BBOOL isOnToken, + CK_BBOOL isPrivate) { *phKey = CK_INVALID_HANDLE; // Get the session - Session* session = (Session*)handleManager->getSession(hSession); + Session *session = (Session *)handleManager->getSession(hSession); if (session == NULL) return CKR_SESSION_HANDLE_INVALID; // Get the token - Token* token = session->getToken(); + Token *token = session->getToken(); if (token == NULL) return CKR_GENERAL_ERROR; @@ -9538,24 +9695,24 @@ CK_RV SoftHSM::generateDSAParameters { switch (pTemplate[i].type) { - case CKA_PRIME_BITS: - if (pTemplate[i].ulValueLen != sizeof(CK_ULONG)) - { - INFO_MSG("CKA_PRIME_BITS does not have the size of CK_ULONG"); - return CKR_ATTRIBUTE_VALUE_INVALID; - } - bitLen = *(CK_ULONG*)pTemplate[i].pValue; - break; - case CKA_SUB_PRIME_BITS: - if (pTemplate[i].ulValueLen != sizeof(CK_ULONG)) - { - INFO_MSG("CKA_SUB_PRIME_BITS does not have the size of CK_ULONG"); - return CKR_ATTRIBUTE_VALUE_INVALID; - } - qLen = *(CK_ULONG*)pTemplate[i].pValue; - break; - default: - break; + case CKA_PRIME_BITS: + if (pTemplate[i].ulValueLen != sizeof(CK_ULONG)) + { + INFO_MSG("CKA_PRIME_BITS does not have the size of CK_ULONG"); + return CKR_ATTRIBUTE_VALUE_INVALID; + } + bitLen = *(CK_ULONG *)pTemplate[i].pValue; + break; + case CKA_SUB_PRIME_BITS: + if (pTemplate[i].ulValueLen != sizeof(CK_ULONG)) + { + INFO_MSG("CKA_SUB_PRIME_BITS does not have the size of CK_ULONG"); + return CKR_ATTRIBUTE_VALUE_INVALID; + } + qLen = *(CK_ULONG *)pTemplate[i].pValue; + break; + default: + break; } } @@ -9568,15 +9725,15 @@ CK_RV SoftHSM::generateDSAParameters // No real choice for CKA_SUB_PRIME_BITS if ((qLen != 0) && - (((bitLen >= 2048) && (qLen != 256)) || - ((bitLen < 2048) && (qLen != 160)))) + (((bitLen >= 2048) && (qLen != 256)) || + ((bitLen < 2048) && (qLen != 160)))) INFO_MSG("CKA_SUB_PRIME_BITS is ignored"); - // Generate domain parameters - AsymmetricParameters* p = NULL; - AsymmetricAlgorithm* dsa = CryptoFactory::i()->getAsymmetricAlgorithm(AsymAlgo::DSA); - if (dsa == NULL) return CKR_GENERAL_ERROR; + AsymmetricParameters *p = NULL; + AsymmetricAlgorithm *dsa = CryptoFactory::i()->getAsymmetricAlgorithm(AsymAlgo::DSA); + if (dsa == NULL) + return CKR_GENERAL_ERROR; if (!dsa->generateParameters(&p, (void *)bitLen)) { ERROR_MSG("Could not generate parameters"); @@ -9584,7 +9741,7 @@ CK_RV SoftHSM::generateDSAParameters return CKR_GENERAL_ERROR; } - DSAParameters* params = (DSAParameters*) p; + DSAParameters *params = (DSAParameters *)p; CK_RV rv = CKR_OK; @@ -9593,46 +9750,49 @@ CK_RV SoftHSM::generateDSAParameters CK_OBJECT_CLASS objClass = CKO_DOMAIN_PARAMETERS; CK_KEY_TYPE keyType = CKK_DSA; CK_ATTRIBUTE paramsAttribs[maxAttribs] = { - { CKA_CLASS, &objClass, sizeof(objClass) }, - { CKA_TOKEN, &isOnToken, sizeof(isOnToken) }, - { CKA_PRIVATE, &isPrivate, sizeof(isPrivate) }, - { CKA_KEY_TYPE, &keyType, sizeof(keyType) }, + {CKA_CLASS, &objClass, sizeof(objClass)}, + {CKA_TOKEN, &isOnToken, sizeof(isOnToken)}, + {CKA_PRIVATE, &isPrivate, sizeof(isPrivate)}, + {CKA_KEY_TYPE, &keyType, sizeof(keyType)}, }; CK_ULONG paramsAttribsCount = 4; // Add the additional if (ulCount > (maxAttribs - paramsAttribsCount)) rv = CKR_TEMPLATE_INCONSISTENT; - for (CK_ULONG i=0; i < ulCount && rv == CKR_OK; ++i) + for (CK_ULONG i = 0; i < ulCount && rv == CKR_OK; ++i) { switch (pTemplate[i].type) { - case CKA_CLASS: - case CKA_TOKEN: - case CKA_PRIVATE: - case CKA_KEY_TYPE: - continue; + case CKA_CLASS: + case CKA_TOKEN: + case CKA_PRIVATE: + case CKA_KEY_TYPE: + continue; default: paramsAttribs[paramsAttribsCount++] = pTemplate[i]; } } if (rv == CKR_OK) - rv = this->CreateObject(hSession, paramsAttribs, paramsAttribsCount, phKey,OBJECT_OP_GENERATE); + rv = this->CreateObject(hSession, paramsAttribs, paramsAttribsCount, phKey, OBJECT_OP_GENERATE); // Store the attributes that are being supplied if (rv == CKR_OK) { - OSObject* osobject = (OSObject*)handleManager->getObject(*phKey); - if (osobject == NULL_PTR || !osobject->isValid()) { + OSObject *osobject = (OSObject *)handleManager->getObject(*phKey); + if (osobject == NULL_PTR || !osobject->isValid()) + { rv = CKR_FUNCTION_FAILED; - } else if (osobject->startTransaction()) { + } + else if (osobject->startTransaction()) + { bool bOK = true; // Common Attributes - bOK = bOK && osobject->setAttribute(CKA_LOCAL,true); + bOK = bOK && osobject->setAttribute(CKA_LOCAL, true); CK_ULONG ulKeyGenMechanism = (CK_ULONG)CKM_DSA_PARAMETER_GEN; - bOK = bOK && osobject->setAttribute(CKA_KEY_GEN_MECHANISM,ulKeyGenMechanism); + bOK = bOK && osobject->setAttribute(CKA_KEY_GEN_MECHANISM, ulKeyGenMechanism); // DSA Domain Parameters Attributes ByteString prime; @@ -9661,7 +9821,8 @@ CK_RV SoftHSM::generateDSAParameters if (!bOK) rv = CKR_FUNCTION_FAILED; - } else + } + else rv = CKR_FUNCTION_FAILED; } @@ -9674,9 +9835,10 @@ CK_RV SoftHSM::generateDSAParameters { if (*phKey != CK_INVALID_HANDLE) { - OSObject* osparams = (OSObject*)handleManager->getObject(*phKey); + OSObject *osparams = (OSObject *)handleManager->getObject(*phKey); handleManager->destroyObject(*phKey); - if (osparams) osparams->destroyObject(); + if (osparams) + osparams->destroyObject(); *phKey = CK_INVALID_HANDLE; } } @@ -9685,29 +9847,28 @@ CK_RV SoftHSM::generateDSAParameters } // Generate an EC key pair -CK_RV SoftHSM::generateEC -(CK_SESSION_HANDLE hSession, - CK_ATTRIBUTE_PTR pPublicKeyTemplate, - CK_ULONG ulPublicKeyAttributeCount, - CK_ATTRIBUTE_PTR pPrivateKeyTemplate, - CK_ULONG ulPrivateKeyAttributeCount, - CK_OBJECT_HANDLE_PTR phPublicKey, - CK_OBJECT_HANDLE_PTR phPrivateKey, - CK_BBOOL isPublicKeyOnToken, - CK_BBOOL isPublicKeyPrivate, - CK_BBOOL isPrivateKeyOnToken, - CK_BBOOL isPrivateKeyPrivate) +CK_RV SoftHSM::generateEC(CK_SESSION_HANDLE hSession, + CK_ATTRIBUTE_PTR pPublicKeyTemplate, + CK_ULONG ulPublicKeyAttributeCount, + CK_ATTRIBUTE_PTR pPrivateKeyTemplate, + CK_ULONG ulPrivateKeyAttributeCount, + CK_OBJECT_HANDLE_PTR phPublicKey, + CK_OBJECT_HANDLE_PTR phPrivateKey, + CK_BBOOL isPublicKeyOnToken, + CK_BBOOL isPublicKeyPrivate, + CK_BBOOL isPrivateKeyOnToken, + CK_BBOOL isPrivateKeyPrivate) { *phPublicKey = CK_INVALID_HANDLE; *phPrivateKey = CK_INVALID_HANDLE; // Get the session - Session* session = (Session*)handleManager->getSession(hSession); + Session *session = (Session *)handleManager->getSession(hSession); if (session == NULL) return CKR_SESSION_HANDLE_INVALID; // Get the token - Token* token = session->getToken(); + Token *token = session->getToken(); if (token == NULL) return CKR_GENERAL_ERROR; @@ -9717,16 +9878,17 @@ CK_RV SoftHSM::generateEC { switch (pPublicKeyTemplate[i].type) { - case CKA_EC_PARAMS: - params = ByteString((unsigned char*)pPublicKeyTemplate[i].pValue, pPublicKeyTemplate[i].ulValueLen); - break; - default: - break; + case CKA_EC_PARAMS: + params = ByteString((unsigned char *)pPublicKeyTemplate[i].pValue, pPublicKeyTemplate[i].ulValueLen); + break; + default: + break; } } // The parameters must be specified to be able to generate a key pair. - if (params.size() == 0) { + if (params.size() == 0) + { INFO_MSG("Missing parameter(s) in pPublicKeyTemplate"); return CKR_TEMPLATE_INCOMPLETE; } @@ -9736,9 +9898,10 @@ CK_RV SoftHSM::generateEC p.setEC(params); // Generate key pair - AsymmetricKeyPair* kp = NULL; - AsymmetricAlgorithm* ec = CryptoFactory::i()->getAsymmetricAlgorithm(AsymAlgo::ECDSA); - if (ec == NULL) return CKR_GENERAL_ERROR; + AsymmetricKeyPair *kp = NULL; + AsymmetricAlgorithm *ec = CryptoFactory::i()->getAsymmetricAlgorithm(AsymAlgo::ECDSA); + if (ec == NULL) + return CKR_GENERAL_ERROR; if (!ec->generateKeyPair(&kp, &p)) { ERROR_MSG("Could not generate key pair"); @@ -9746,8 +9909,8 @@ CK_RV SoftHSM::generateEC return CKR_GENERAL_ERROR; } - ECPublicKey* pub = (ECPublicKey*) kp->getPublicKey(); - ECPrivateKey* priv = (ECPrivateKey*) kp->getPrivateKey(); + ECPublicKey *pub = (ECPublicKey *)kp->getPublicKey(); + ECPrivateKey *priv = (ECPrivateKey *)kp->getPrivateKey(); CK_RV rv = CKR_OK; @@ -9758,46 +9921,49 @@ CK_RV SoftHSM::generateEC CK_OBJECT_CLASS publicKeyClass = CKO_PUBLIC_KEY; CK_KEY_TYPE publicKeyType = CKK_EC; CK_ATTRIBUTE publicKeyAttribs[maxAttribs] = { - { CKA_CLASS, &publicKeyClass, sizeof(publicKeyClass) }, - { CKA_TOKEN, &isPublicKeyOnToken, sizeof(isPublicKeyOnToken) }, - { CKA_PRIVATE, &isPublicKeyPrivate, sizeof(isPublicKeyPrivate) }, - { CKA_KEY_TYPE, &publicKeyType, sizeof(publicKeyType) }, + {CKA_CLASS, &publicKeyClass, sizeof(publicKeyClass)}, + {CKA_TOKEN, &isPublicKeyOnToken, sizeof(isPublicKeyOnToken)}, + {CKA_PRIVATE, &isPublicKeyPrivate, sizeof(isPublicKeyPrivate)}, + {CKA_KEY_TYPE, &publicKeyType, sizeof(publicKeyType)}, }; CK_ULONG publicKeyAttribsCount = 4; // Add the additional if (ulPublicKeyAttributeCount > (maxAttribs - publicKeyAttribsCount)) rv = CKR_TEMPLATE_INCONSISTENT; - for (CK_ULONG i=0; i < ulPublicKeyAttributeCount && rv == CKR_OK; ++i) + for (CK_ULONG i = 0; i < ulPublicKeyAttributeCount && rv == CKR_OK; ++i) { switch (pPublicKeyTemplate[i].type) { - case CKA_CLASS: - case CKA_TOKEN: - case CKA_PRIVATE: - case CKA_KEY_TYPE: - continue; - default: - publicKeyAttribs[publicKeyAttribsCount++] = pPublicKeyTemplate[i]; + case CKA_CLASS: + case CKA_TOKEN: + case CKA_PRIVATE: + case CKA_KEY_TYPE: + continue; + default: + publicKeyAttribs[publicKeyAttribsCount++] = pPublicKeyTemplate[i]; } } if (rv == CKR_OK) - rv = this->CreateObject(hSession,publicKeyAttribs,publicKeyAttribsCount,phPublicKey,OBJECT_OP_GENERATE); + rv = this->CreateObject(hSession, publicKeyAttribs, publicKeyAttribsCount, phPublicKey, OBJECT_OP_GENERATE); // Store the attributes that are being supplied by the key generation to the object if (rv == CKR_OK) { - OSObject* osobject = (OSObject*)handleManager->getObject(*phPublicKey); - if (osobject == NULL_PTR || !osobject->isValid()) { + OSObject *osobject = (OSObject *)handleManager->getObject(*phPublicKey); + if (osobject == NULL_PTR || !osobject->isValid()) + { rv = CKR_FUNCTION_FAILED; - } else if (osobject->startTransaction()) { + } + else if (osobject->startTransaction()) + { bool bOK = true; // Common Key Attributes - bOK = bOK && osobject->setAttribute(CKA_LOCAL,true); + bOK = bOK && osobject->setAttribute(CKA_LOCAL, true); CK_ULONG ulKeyGenMechanism = (CK_ULONG)CKM_EC_KEY_PAIR_GEN; - bOK = bOK && osobject->setAttribute(CKA_KEY_GEN_MECHANISM,ulKeyGenMechanism); + bOK = bOK && osobject->setAttribute(CKA_KEY_GEN_MECHANISM, ulKeyGenMechanism); // EC Public Key Attributes ByteString point; @@ -9818,7 +9984,8 @@ CK_RV SoftHSM::generateEC if (!bOK) rv = CKR_FUNCTION_FAILED; - } else + } + else rv = CKR_FUNCTION_FAILED; } } @@ -9830,48 +9997,51 @@ CK_RV SoftHSM::generateEC CK_OBJECT_CLASS privateKeyClass = CKO_PRIVATE_KEY; CK_KEY_TYPE privateKeyType = CKK_EC; CK_ATTRIBUTE privateKeyAttribs[maxAttribs] = { - { CKA_CLASS, &privateKeyClass, sizeof(privateKeyClass) }, - { CKA_TOKEN, &isPrivateKeyOnToken, sizeof(isPrivateKeyOnToken) }, - { CKA_PRIVATE, &isPrivateKeyPrivate, sizeof(isPrivateKeyPrivate) }, - { CKA_KEY_TYPE, &privateKeyType, sizeof(privateKeyType) }, + {CKA_CLASS, &privateKeyClass, sizeof(privateKeyClass)}, + {CKA_TOKEN, &isPrivateKeyOnToken, sizeof(isPrivateKeyOnToken)}, + {CKA_PRIVATE, &isPrivateKeyPrivate, sizeof(isPrivateKeyPrivate)}, + {CKA_KEY_TYPE, &privateKeyType, sizeof(privateKeyType)}, }; CK_ULONG privateKeyAttribsCount = 4; if (ulPrivateKeyAttributeCount > (maxAttribs - privateKeyAttribsCount)) rv = CKR_TEMPLATE_INCONSISTENT; - for (CK_ULONG i=0; i < ulPrivateKeyAttributeCount && rv == CKR_OK; ++i) + for (CK_ULONG i = 0; i < ulPrivateKeyAttributeCount && rv == CKR_OK; ++i) { switch (pPrivateKeyTemplate[i].type) { - case CKA_CLASS: - case CKA_TOKEN: - case CKA_PRIVATE: - case CKA_KEY_TYPE: - continue; - default: - privateKeyAttribs[privateKeyAttribsCount++] = pPrivateKeyTemplate[i]; + case CKA_CLASS: + case CKA_TOKEN: + case CKA_PRIVATE: + case CKA_KEY_TYPE: + continue; + default: + privateKeyAttribs[privateKeyAttribsCount++] = pPrivateKeyTemplate[i]; } } if (rv == CKR_OK) - rv = this->CreateObject(hSession,privateKeyAttribs,privateKeyAttribsCount,phPrivateKey,OBJECT_OP_GENERATE); + rv = this->CreateObject(hSession, privateKeyAttribs, privateKeyAttribsCount, phPrivateKey, OBJECT_OP_GENERATE); // Store the attributes that are being supplied by the key generation to the object if (rv == CKR_OK) { - OSObject* osobject = (OSObject*)handleManager->getObject(*phPrivateKey); - if (osobject == NULL_PTR || !osobject->isValid()) { + OSObject *osobject = (OSObject *)handleManager->getObject(*phPrivateKey); + if (osobject == NULL_PTR || !osobject->isValid()) + { rv = CKR_FUNCTION_FAILED; - } else if (osobject->startTransaction()) { + } + else if (osobject->startTransaction()) + { bool bOK = true; // Common Key Attributes - bOK = bOK && osobject->setAttribute(CKA_LOCAL,true); + bOK = bOK && osobject->setAttribute(CKA_LOCAL, true); CK_ULONG ulKeyGenMechanism = (CK_ULONG)CKM_EC_KEY_PAIR_GEN; - bOK = bOK && osobject->setAttribute(CKA_KEY_GEN_MECHANISM,ulKeyGenMechanism); + bOK = bOK && osobject->setAttribute(CKA_KEY_GEN_MECHANISM, ulKeyGenMechanism); // Common Private Key Attributes bool bAlwaysSensitive = osobject->getBooleanValue(CKA_SENSITIVE, false); - bOK = bOK && osobject->setAttribute(CKA_ALWAYS_SENSITIVE,bAlwaysSensitive); + bOK = bOK && osobject->setAttribute(CKA_ALWAYS_SENSITIVE, bAlwaysSensitive); bool bNeverExtractable = osobject->getBooleanValue(CKA_EXTRACTABLE, false) == false; bOK = bOK && osobject->setAttribute(CKA_NEVER_EXTRACTABLE, bNeverExtractable); @@ -9898,7 +10068,8 @@ CK_RV SoftHSM::generateEC if (!bOK) rv = CKR_FUNCTION_FAILED; - } else + } + else rv = CKR_FUNCTION_FAILED; } } @@ -9912,17 +10083,19 @@ CK_RV SoftHSM::generateEC { if (*phPrivateKey != CK_INVALID_HANDLE) { - OSObject* ospriv = (OSObject*)handleManager->getObject(*phPrivateKey); + OSObject *ospriv = (OSObject *)handleManager->getObject(*phPrivateKey); handleManager->destroyObject(*phPrivateKey); - if (ospriv) ospriv->destroyObject(); + if (ospriv) + ospriv->destroyObject(); *phPrivateKey = CK_INVALID_HANDLE; } if (*phPublicKey != CK_INVALID_HANDLE) { - OSObject* ospub = (OSObject*)handleManager->getObject(*phPublicKey); + OSObject *ospub = (OSObject *)handleManager->getObject(*phPublicKey); handleManager->destroyObject(*phPublicKey); - if (ospub) ospub->destroyObject(); + if (ospub) + ospub->destroyObject(); *phPublicKey = CK_INVALID_HANDLE; } } @@ -9931,29 +10104,28 @@ CK_RV SoftHSM::generateEC } // Generate an EDDSA key pair -CK_RV SoftHSM::generateED -(CK_SESSION_HANDLE hSession, - CK_ATTRIBUTE_PTR pPublicKeyTemplate, - CK_ULONG ulPublicKeyAttributeCount, - CK_ATTRIBUTE_PTR pPrivateKeyTemplate, - CK_ULONG ulPrivateKeyAttributeCount, - CK_OBJECT_HANDLE_PTR phPublicKey, - CK_OBJECT_HANDLE_PTR phPrivateKey, - CK_BBOOL isPublicKeyOnToken, - CK_BBOOL isPublicKeyPrivate, - CK_BBOOL isPrivateKeyOnToken, - CK_BBOOL isPrivateKeyPrivate) +CK_RV SoftHSM::generateED(CK_SESSION_HANDLE hSession, + CK_ATTRIBUTE_PTR pPublicKeyTemplate, + CK_ULONG ulPublicKeyAttributeCount, + CK_ATTRIBUTE_PTR pPrivateKeyTemplate, + CK_ULONG ulPrivateKeyAttributeCount, + CK_OBJECT_HANDLE_PTR phPublicKey, + CK_OBJECT_HANDLE_PTR phPrivateKey, + CK_BBOOL isPublicKeyOnToken, + CK_BBOOL isPublicKeyPrivate, + CK_BBOOL isPrivateKeyOnToken, + CK_BBOOL isPrivateKeyPrivate) { *phPublicKey = CK_INVALID_HANDLE; *phPrivateKey = CK_INVALID_HANDLE; // Get the session - Session* session = (Session*)handleManager->getSession(hSession); + Session *session = (Session *)handleManager->getSession(hSession); if (session == NULL) return CKR_SESSION_HANDLE_INVALID; // Get the token - Token* token = session->getToken(); + Token *token = session->getToken(); if (token == NULL) return CKR_GENERAL_ERROR; @@ -9963,16 +10135,17 @@ CK_RV SoftHSM::generateED { switch (pPublicKeyTemplate[i].type) { - case CKA_EC_PARAMS: - params = ByteString((unsigned char*)pPublicKeyTemplate[i].pValue, pPublicKeyTemplate[i].ulValueLen); - break; - default: - break; + case CKA_EC_PARAMS: + params = ByteString((unsigned char *)pPublicKeyTemplate[i].pValue, pPublicKeyTemplate[i].ulValueLen); + break; + default: + break; } } // The parameters must be specified to be able to generate a key pair. - if (params.size() == 0) { + if (params.size() == 0) + { INFO_MSG("Missing parameter(s) in pPublicKeyTemplate"); return CKR_TEMPLATE_INCOMPLETE; } @@ -9982,9 +10155,10 @@ CK_RV SoftHSM::generateED p.setEC(params); // Generate key pair - AsymmetricKeyPair* kp = NULL; - AsymmetricAlgorithm* ec = CryptoFactory::i()->getAsymmetricAlgorithm(AsymAlgo::EDDSA); - if (ec == NULL) return CKR_GENERAL_ERROR; + AsymmetricKeyPair *kp = NULL; + AsymmetricAlgorithm *ec = CryptoFactory::i()->getAsymmetricAlgorithm(AsymAlgo::EDDSA); + if (ec == NULL) + return CKR_GENERAL_ERROR; if (!ec->generateKeyPair(&kp, &p)) { ERROR_MSG("Could not generate key pair"); @@ -9992,8 +10166,8 @@ CK_RV SoftHSM::generateED return CKR_GENERAL_ERROR; } - EDPublicKey* pub = (EDPublicKey*) kp->getPublicKey(); - EDPrivateKey* priv = (EDPrivateKey*) kp->getPrivateKey(); + EDPublicKey *pub = (EDPublicKey *)kp->getPublicKey(); + EDPrivateKey *priv = (EDPrivateKey *)kp->getPrivateKey(); CK_RV rv = CKR_OK; @@ -10004,46 +10178,49 @@ CK_RV SoftHSM::generateED CK_OBJECT_CLASS publicKeyClass = CKO_PUBLIC_KEY; CK_KEY_TYPE publicKeyType = CKK_EC_EDWARDS; CK_ATTRIBUTE publicKeyAttribs[maxAttribs] = { - { CKA_CLASS, &publicKeyClass, sizeof(publicKeyClass) }, - { CKA_TOKEN, &isPublicKeyOnToken, sizeof(isPublicKeyOnToken) }, - { CKA_PRIVATE, &isPublicKeyPrivate, sizeof(isPublicKeyPrivate) }, - { CKA_KEY_TYPE, &publicKeyType, sizeof(publicKeyType) }, + {CKA_CLASS, &publicKeyClass, sizeof(publicKeyClass)}, + {CKA_TOKEN, &isPublicKeyOnToken, sizeof(isPublicKeyOnToken)}, + {CKA_PRIVATE, &isPublicKeyPrivate, sizeof(isPublicKeyPrivate)}, + {CKA_KEY_TYPE, &publicKeyType, sizeof(publicKeyType)}, }; CK_ULONG publicKeyAttribsCount = 4; // Add the additional if (ulPublicKeyAttributeCount > (maxAttribs - publicKeyAttribsCount)) rv = CKR_TEMPLATE_INCONSISTENT; - for (CK_ULONG i=0; i < ulPublicKeyAttributeCount && rv == CKR_OK; ++i) + for (CK_ULONG i = 0; i < ulPublicKeyAttributeCount && rv == CKR_OK; ++i) { switch (pPublicKeyTemplate[i].type) { - case CKA_CLASS: - case CKA_TOKEN: - case CKA_PRIVATE: - case CKA_KEY_TYPE: - continue; - default: - publicKeyAttribs[publicKeyAttribsCount++] = pPublicKeyTemplate[i]; + case CKA_CLASS: + case CKA_TOKEN: + case CKA_PRIVATE: + case CKA_KEY_TYPE: + continue; + default: + publicKeyAttribs[publicKeyAttribsCount++] = pPublicKeyTemplate[i]; } } if (rv == CKR_OK) - rv = this->CreateObject(hSession,publicKeyAttribs,publicKeyAttribsCount,phPublicKey,OBJECT_OP_GENERATE); + rv = this->CreateObject(hSession, publicKeyAttribs, publicKeyAttribsCount, phPublicKey, OBJECT_OP_GENERATE); // Store the attributes that are being supplied by the key generation to the object if (rv == CKR_OK) { - OSObject* osobject = (OSObject*)handleManager->getObject(*phPublicKey); - if (osobject == NULL_PTR || !osobject->isValid()) { + OSObject *osobject = (OSObject *)handleManager->getObject(*phPublicKey); + if (osobject == NULL_PTR || !osobject->isValid()) + { rv = CKR_FUNCTION_FAILED; - } else if (osobject->startTransaction()) { + } + else if (osobject->startTransaction()) + { bool bOK = true; // Common Key Attributes - bOK = bOK && osobject->setAttribute(CKA_LOCAL,true); + bOK = bOK && osobject->setAttribute(CKA_LOCAL, true); CK_ULONG ulKeyGenMechanism = (CK_ULONG)CKM_EC_EDWARDS_KEY_PAIR_GEN; - bOK = bOK && osobject->setAttribute(CKA_KEY_GEN_MECHANISM,ulKeyGenMechanism); + bOK = bOK && osobject->setAttribute(CKA_KEY_GEN_MECHANISM, ulKeyGenMechanism); // EDDSA Public Key Attributes ByteString value; @@ -10064,7 +10241,8 @@ CK_RV SoftHSM::generateED if (!bOK) rv = CKR_FUNCTION_FAILED; - } else + } + else rv = CKR_FUNCTION_FAILED; } } @@ -10076,48 +10254,51 @@ CK_RV SoftHSM::generateED CK_OBJECT_CLASS privateKeyClass = CKO_PRIVATE_KEY; CK_KEY_TYPE privateKeyType = CKK_EC_EDWARDS; CK_ATTRIBUTE privateKeyAttribs[maxAttribs] = { - { CKA_CLASS, &privateKeyClass, sizeof(privateKeyClass) }, - { CKA_TOKEN, &isPrivateKeyOnToken, sizeof(isPrivateKeyOnToken) }, - { CKA_PRIVATE, &isPrivateKeyPrivate, sizeof(isPrivateKeyPrivate) }, - { CKA_KEY_TYPE, &privateKeyType, sizeof(privateKeyType) }, + {CKA_CLASS, &privateKeyClass, sizeof(privateKeyClass)}, + {CKA_TOKEN, &isPrivateKeyOnToken, sizeof(isPrivateKeyOnToken)}, + {CKA_PRIVATE, &isPrivateKeyPrivate, sizeof(isPrivateKeyPrivate)}, + {CKA_KEY_TYPE, &privateKeyType, sizeof(privateKeyType)}, }; CK_ULONG privateKeyAttribsCount = 4; if (ulPrivateKeyAttributeCount > (maxAttribs - privateKeyAttribsCount)) rv = CKR_TEMPLATE_INCONSISTENT; - for (CK_ULONG i=0; i < ulPrivateKeyAttributeCount && rv == CKR_OK; ++i) + for (CK_ULONG i = 0; i < ulPrivateKeyAttributeCount && rv == CKR_OK; ++i) { switch (pPrivateKeyTemplate[i].type) { - case CKA_CLASS: - case CKA_TOKEN: - case CKA_PRIVATE: - case CKA_KEY_TYPE: - continue; - default: - privateKeyAttribs[privateKeyAttribsCount++] = pPrivateKeyTemplate[i]; + case CKA_CLASS: + case CKA_TOKEN: + case CKA_PRIVATE: + case CKA_KEY_TYPE: + continue; + default: + privateKeyAttribs[privateKeyAttribsCount++] = pPrivateKeyTemplate[i]; } } if (rv == CKR_OK) - rv = this->CreateObject(hSession,privateKeyAttribs,privateKeyAttribsCount,phPrivateKey,OBJECT_OP_GENERATE); + rv = this->CreateObject(hSession, privateKeyAttribs, privateKeyAttribsCount, phPrivateKey, OBJECT_OP_GENERATE); // Store the attributes that are being supplied by the key generation to the object if (rv == CKR_OK) { - OSObject* osobject = (OSObject*)handleManager->getObject(*phPrivateKey); - if (osobject == NULL_PTR || !osobject->isValid()) { + OSObject *osobject = (OSObject *)handleManager->getObject(*phPrivateKey); + if (osobject == NULL_PTR || !osobject->isValid()) + { rv = CKR_FUNCTION_FAILED; - } else if (osobject->startTransaction()) { + } + else if (osobject->startTransaction()) + { bool bOK = true; // Common Key Attributes - bOK = bOK && osobject->setAttribute(CKA_LOCAL,true); + bOK = bOK && osobject->setAttribute(CKA_LOCAL, true); CK_ULONG ulKeyGenMechanism = (CK_ULONG)CKM_EC_EDWARDS_KEY_PAIR_GEN; - bOK = bOK && osobject->setAttribute(CKA_KEY_GEN_MECHANISM,ulKeyGenMechanism); + bOK = bOK && osobject->setAttribute(CKA_KEY_GEN_MECHANISM, ulKeyGenMechanism); // Common Private Key Attributes bool bAlwaysSensitive = osobject->getBooleanValue(CKA_SENSITIVE, false); - bOK = bOK && osobject->setAttribute(CKA_ALWAYS_SENSITIVE,bAlwaysSensitive); + bOK = bOK && osobject->setAttribute(CKA_ALWAYS_SENSITIVE, bAlwaysSensitive); bool bNeverExtractable = osobject->getBooleanValue(CKA_EXTRACTABLE, false) == false; bOK = bOK && osobject->setAttribute(CKA_NEVER_EXTRACTABLE, bNeverExtractable); @@ -10144,7 +10325,8 @@ CK_RV SoftHSM::generateED if (!bOK) rv = CKR_FUNCTION_FAILED; - } else + } + else rv = CKR_FUNCTION_FAILED; } } @@ -10158,17 +10340,19 @@ CK_RV SoftHSM::generateED { if (*phPrivateKey != CK_INVALID_HANDLE) { - OSObject* ospriv = (OSObject*)handleManager->getObject(*phPrivateKey); + OSObject *ospriv = (OSObject *)handleManager->getObject(*phPrivateKey); handleManager->destroyObject(*phPrivateKey); - if (ospriv) ospriv->destroyObject(); + if (ospriv) + ospriv->destroyObject(); *phPrivateKey = CK_INVALID_HANDLE; } if (*phPublicKey != CK_INVALID_HANDLE) { - OSObject* ospub = (OSObject*)handleManager->getObject(*phPublicKey); + OSObject *ospub = (OSObject *)handleManager->getObject(*phPublicKey); handleManager->destroyObject(*phPublicKey); - if (ospub) ospub->destroyObject(); + if (ospub) + ospub->destroyObject(); *phPublicKey = CK_INVALID_HANDLE; } } @@ -10177,29 +10361,28 @@ CK_RV SoftHSM::generateED } // Generate a DH key pair -CK_RV SoftHSM::generateDH -(CK_SESSION_HANDLE hSession, - CK_ATTRIBUTE_PTR pPublicKeyTemplate, - CK_ULONG ulPublicKeyAttributeCount, - CK_ATTRIBUTE_PTR pPrivateKeyTemplate, - CK_ULONG ulPrivateKeyAttributeCount, - CK_OBJECT_HANDLE_PTR phPublicKey, - CK_OBJECT_HANDLE_PTR phPrivateKey, - CK_BBOOL isPublicKeyOnToken, - CK_BBOOL isPublicKeyPrivate, - CK_BBOOL isPrivateKeyOnToken, - CK_BBOOL isPrivateKeyPrivate) +CK_RV SoftHSM::generateDH(CK_SESSION_HANDLE hSession, + CK_ATTRIBUTE_PTR pPublicKeyTemplate, + CK_ULONG ulPublicKeyAttributeCount, + CK_ATTRIBUTE_PTR pPrivateKeyTemplate, + CK_ULONG ulPrivateKeyAttributeCount, + CK_OBJECT_HANDLE_PTR phPublicKey, + CK_OBJECT_HANDLE_PTR phPrivateKey, + CK_BBOOL isPublicKeyOnToken, + CK_BBOOL isPublicKeyPrivate, + CK_BBOOL isPrivateKeyOnToken, + CK_BBOOL isPrivateKeyPrivate) { *phPublicKey = CK_INVALID_HANDLE; *phPrivateKey = CK_INVALID_HANDLE; // Get the session - Session* session = (Session*)handleManager->getSession(hSession); + Session *session = (Session *)handleManager->getSession(hSession); if (session == NULL) return CKR_SESSION_HANDLE_INVALID; // Get the token - Token* token = session->getToken(); + Token *token = session->getToken(); if (token == NULL) return CKR_GENERAL_ERROR; @@ -10210,19 +10393,20 @@ CK_RV SoftHSM::generateDH { switch (pPublicKeyTemplate[i].type) { - case CKA_PRIME: - prime = ByteString((unsigned char*)pPublicKeyTemplate[i].pValue, pPublicKeyTemplate[i].ulValueLen); - break; - case CKA_BASE: - generator = ByteString((unsigned char*)pPublicKeyTemplate[i].pValue, pPublicKeyTemplate[i].ulValueLen); - break; - default: - break; + case CKA_PRIME: + prime = ByteString((unsigned char *)pPublicKeyTemplate[i].pValue, pPublicKeyTemplate[i].ulValueLen); + break; + case CKA_BASE: + generator = ByteString((unsigned char *)pPublicKeyTemplate[i].pValue, pPublicKeyTemplate[i].ulValueLen); + break; + default: + break; } } // The parameters must be specified to be able to generate a key pair. - if (prime.size() == 0 || generator.size() == 0) { + if (prime.size() == 0 || generator.size() == 0) + { INFO_MSG("Missing parameter(s) in pPublicKeyTemplate"); return CKR_TEMPLATE_INCOMPLETE; } @@ -10233,11 +10417,11 @@ CK_RV SoftHSM::generateDH { switch (pPrivateKeyTemplate[i].type) { - case CKA_VALUE_BITS: - bitLen = *(CK_ULONG*)pPrivateKeyTemplate[i].pValue; - break; - default: - break; + case CKA_VALUE_BITS: + bitLen = *(CK_ULONG *)pPrivateKeyTemplate[i].pValue; + break; + default: + break; } } @@ -10248,9 +10432,10 @@ CK_RV SoftHSM::generateDH p.setXBitLength(bitLen); // Generate key pair - AsymmetricKeyPair* kp = NULL; - AsymmetricAlgorithm* dh = CryptoFactory::i()->getAsymmetricAlgorithm(AsymAlgo::DH); - if (dh == NULL) return CKR_GENERAL_ERROR; + AsymmetricKeyPair *kp = NULL; + AsymmetricAlgorithm *dh = CryptoFactory::i()->getAsymmetricAlgorithm(AsymAlgo::DH); + if (dh == NULL) + return CKR_GENERAL_ERROR; if (!dh->generateKeyPair(&kp, &p)) { ERROR_MSG("Could not generate key pair"); @@ -10258,8 +10443,8 @@ CK_RV SoftHSM::generateDH return CKR_GENERAL_ERROR; } - DHPublicKey* pub = (DHPublicKey*) kp->getPublicKey(); - DHPrivateKey* priv = (DHPrivateKey*) kp->getPrivateKey(); + DHPublicKey *pub = (DHPublicKey *)kp->getPublicKey(); + DHPrivateKey *priv = (DHPrivateKey *)kp->getPrivateKey(); CK_RV rv = CKR_OK; @@ -10270,46 +10455,49 @@ CK_RV SoftHSM::generateDH CK_OBJECT_CLASS publicKeyClass = CKO_PUBLIC_KEY; CK_KEY_TYPE publicKeyType = CKK_DH; CK_ATTRIBUTE publicKeyAttribs[maxAttribs] = { - { CKA_CLASS, &publicKeyClass, sizeof(publicKeyClass) }, - { CKA_TOKEN, &isPublicKeyOnToken, sizeof(isPublicKeyOnToken) }, - { CKA_PRIVATE, &isPublicKeyPrivate, sizeof(isPublicKeyPrivate) }, - { CKA_KEY_TYPE, &publicKeyType, sizeof(publicKeyType) }, + {CKA_CLASS, &publicKeyClass, sizeof(publicKeyClass)}, + {CKA_TOKEN, &isPublicKeyOnToken, sizeof(isPublicKeyOnToken)}, + {CKA_PRIVATE, &isPublicKeyPrivate, sizeof(isPublicKeyPrivate)}, + {CKA_KEY_TYPE, &publicKeyType, sizeof(publicKeyType)}, }; CK_ULONG publicKeyAttribsCount = 4; // Add the additional if (ulPublicKeyAttributeCount > (maxAttribs - publicKeyAttribsCount)) rv = CKR_TEMPLATE_INCONSISTENT; - for (CK_ULONG i=0; i < ulPublicKeyAttributeCount && rv == CKR_OK; ++i) + for (CK_ULONG i = 0; i < ulPublicKeyAttributeCount && rv == CKR_OK; ++i) { switch (pPublicKeyTemplate[i].type) { - case CKA_CLASS: - case CKA_TOKEN: - case CKA_PRIVATE: - case CKA_KEY_TYPE: - continue; - default: - publicKeyAttribs[publicKeyAttribsCount++] = pPublicKeyTemplate[i]; + case CKA_CLASS: + case CKA_TOKEN: + case CKA_PRIVATE: + case CKA_KEY_TYPE: + continue; + default: + publicKeyAttribs[publicKeyAttribsCount++] = pPublicKeyTemplate[i]; } } if (rv == CKR_OK) - rv = this->CreateObject(hSession,publicKeyAttribs,publicKeyAttribsCount,phPublicKey,OBJECT_OP_GENERATE); + rv = this->CreateObject(hSession, publicKeyAttribs, publicKeyAttribsCount, phPublicKey, OBJECT_OP_GENERATE); // Store the attributes that are being supplied by the key generation to the object if (rv == CKR_OK) { - OSObject* osobject = (OSObject*)handleManager->getObject(*phPublicKey); - if (osobject == NULL_PTR || !osobject->isValid()) { + OSObject *osobject = (OSObject *)handleManager->getObject(*phPublicKey); + if (osobject == NULL_PTR || !osobject->isValid()) + { rv = CKR_FUNCTION_FAILED; - } else if (osobject->startTransaction()) { + } + else if (osobject->startTransaction()) + { bool bOK = true; // Common Key Attributes - bOK = bOK && osobject->setAttribute(CKA_LOCAL,true); + bOK = bOK && osobject->setAttribute(CKA_LOCAL, true); CK_ULONG ulKeyGenMechanism = (CK_ULONG)CKM_DH_PKCS_KEY_PAIR_GEN; - bOK = bOK && osobject->setAttribute(CKA_KEY_GEN_MECHANISM,ulKeyGenMechanism); + bOK = bOK && osobject->setAttribute(CKA_KEY_GEN_MECHANISM, ulKeyGenMechanism); // DH Public Key Attributes ByteString value; @@ -10330,7 +10518,8 @@ CK_RV SoftHSM::generateDH if (!bOK) rv = CKR_FUNCTION_FAILED; - } else + } + else rv = CKR_FUNCTION_FAILED; } } @@ -10342,48 +10531,51 @@ CK_RV SoftHSM::generateDH CK_OBJECT_CLASS privateKeyClass = CKO_PRIVATE_KEY; CK_KEY_TYPE privateKeyType = CKK_DH; CK_ATTRIBUTE privateKeyAttribs[maxAttribs] = { - { CKA_CLASS, &privateKeyClass, sizeof(privateKeyClass) }, - { CKA_TOKEN, &isPrivateKeyOnToken, sizeof(isPrivateKeyOnToken) }, - { CKA_PRIVATE, &isPrivateKeyPrivate, sizeof(isPrivateKeyPrivate) }, - { CKA_KEY_TYPE, &privateKeyType, sizeof(privateKeyType) }, + {CKA_CLASS, &privateKeyClass, sizeof(privateKeyClass)}, + {CKA_TOKEN, &isPrivateKeyOnToken, sizeof(isPrivateKeyOnToken)}, + {CKA_PRIVATE, &isPrivateKeyPrivate, sizeof(isPrivateKeyPrivate)}, + {CKA_KEY_TYPE, &privateKeyType, sizeof(privateKeyType)}, }; CK_ULONG privateKeyAttribsCount = 4; if (ulPrivateKeyAttributeCount > (maxAttribs - privateKeyAttribsCount)) rv = CKR_TEMPLATE_INCONSISTENT; - for (CK_ULONG i=0; i < ulPrivateKeyAttributeCount && rv == CKR_OK; ++i) + for (CK_ULONG i = 0; i < ulPrivateKeyAttributeCount && rv == CKR_OK; ++i) { switch (pPrivateKeyTemplate[i].type) { - case CKA_CLASS: - case CKA_TOKEN: - case CKA_PRIVATE: - case CKA_KEY_TYPE: - continue; - default: - privateKeyAttribs[privateKeyAttribsCount++] = pPrivateKeyTemplate[i]; + case CKA_CLASS: + case CKA_TOKEN: + case CKA_PRIVATE: + case CKA_KEY_TYPE: + continue; + default: + privateKeyAttribs[privateKeyAttribsCount++] = pPrivateKeyTemplate[i]; } } if (rv == CKR_OK) - rv = this->CreateObject(hSession,privateKeyAttribs,privateKeyAttribsCount,phPrivateKey,OBJECT_OP_GENERATE); + rv = this->CreateObject(hSession, privateKeyAttribs, privateKeyAttribsCount, phPrivateKey, OBJECT_OP_GENERATE); // Store the attributes that are being supplied by the key generation to the object if (rv == CKR_OK) { - OSObject* osobject = (OSObject*)handleManager->getObject(*phPrivateKey); - if (osobject == NULL_PTR || !osobject->isValid()) { + OSObject *osobject = (OSObject *)handleManager->getObject(*phPrivateKey); + if (osobject == NULL_PTR || !osobject->isValid()) + { rv = CKR_FUNCTION_FAILED; - } else if (osobject->startTransaction()) { + } + else if (osobject->startTransaction()) + { bool bOK = true; // Common Key Attributes - bOK = bOK && osobject->setAttribute(CKA_LOCAL,true); + bOK = bOK && osobject->setAttribute(CKA_LOCAL, true); CK_ULONG ulKeyGenMechanism = (CK_ULONG)CKM_DH_PKCS_KEY_PAIR_GEN; - bOK = bOK && osobject->setAttribute(CKA_KEY_GEN_MECHANISM,ulKeyGenMechanism); + bOK = bOK && osobject->setAttribute(CKA_KEY_GEN_MECHANISM, ulKeyGenMechanism); // Common Private Key Attributes bool bAlwaysSensitive = osobject->getBooleanValue(CKA_SENSITIVE, false); - bOK = bOK && osobject->setAttribute(CKA_ALWAYS_SENSITIVE,bAlwaysSensitive); + bOK = bOK && osobject->setAttribute(CKA_ALWAYS_SENSITIVE, bAlwaysSensitive); bool bNeverExtractable = osobject->getBooleanValue(CKA_EXTRACTABLE, false) == false; bOK = bOK && osobject->setAttribute(CKA_NEVER_EXTRACTABLE, bNeverExtractable); @@ -10419,7 +10611,8 @@ CK_RV SoftHSM::generateDH if (!bOK) rv = CKR_FUNCTION_FAILED; - } else + } + else rv = CKR_FUNCTION_FAILED; } } @@ -10433,17 +10626,19 @@ CK_RV SoftHSM::generateDH { if (*phPrivateKey != CK_INVALID_HANDLE) { - OSObject* ospriv = (OSObject*)handleManager->getObject(*phPrivateKey); + OSObject *ospriv = (OSObject *)handleManager->getObject(*phPrivateKey); handleManager->destroyObject(*phPrivateKey); - if (ospriv) ospriv->destroyObject(); + if (ospriv) + ospriv->destroyObject(); *phPrivateKey = CK_INVALID_HANDLE; } if (*phPublicKey != CK_INVALID_HANDLE) { - OSObject* ospub = (OSObject*)handleManager->getObject(*phPublicKey); + OSObject *ospub = (OSObject *)handleManager->getObject(*phPublicKey); handleManager->destroyObject(*phPublicKey); - if (ospub) ospub->destroyObject(); + if (ospub) + ospub->destroyObject(); *phPublicKey = CK_INVALID_HANDLE; } } @@ -10452,23 +10647,22 @@ CK_RV SoftHSM::generateDH } // Generate a DH domain parameter set -CK_RV SoftHSM::generateDHParameters -(CK_SESSION_HANDLE hSession, - CK_ATTRIBUTE_PTR pTemplate, - CK_ULONG ulCount, - CK_OBJECT_HANDLE_PTR phKey, - CK_BBOOL isOnToken, - CK_BBOOL isPrivate) +CK_RV SoftHSM::generateDHParameters(CK_SESSION_HANDLE hSession, + CK_ATTRIBUTE_PTR pTemplate, + CK_ULONG ulCount, + CK_OBJECT_HANDLE_PTR phKey, + CK_BBOOL isOnToken, + CK_BBOOL isPrivate) { *phKey = CK_INVALID_HANDLE; // Get the session - Session* session = (Session*)handleManager->getSession(hSession); + Session *session = (Session *)handleManager->getSession(hSession); if (session == NULL) return CKR_SESSION_HANDLE_INVALID; // Get the token - Token* token = session->getToken(); + Token *token = session->getToken(); if (token == NULL) return CKR_GENERAL_ERROR; @@ -10478,16 +10672,16 @@ CK_RV SoftHSM::generateDHParameters { switch (pTemplate[i].type) { - case CKA_PRIME_BITS: - if (pTemplate[i].ulValueLen != sizeof(CK_ULONG)) - { - INFO_MSG("CKA_PRIME_BITS does not have the size of CK_ULONG"); - return CKR_ATTRIBUTE_VALUE_INVALID; - } - bitLen = *(CK_ULONG*)pTemplate[i].pValue; - break; - default: - break; + case CKA_PRIME_BITS: + if (pTemplate[i].ulValueLen != sizeof(CK_ULONG)) + { + INFO_MSG("CKA_PRIME_BITS does not have the size of CK_ULONG"); + return CKR_ATTRIBUTE_VALUE_INVALID; + } + bitLen = *(CK_ULONG *)pTemplate[i].pValue; + break; + default: + break; } } @@ -10499,9 +10693,10 @@ CK_RV SoftHSM::generateDHParameters } // Generate domain parameters - AsymmetricParameters* p = NULL; - AsymmetricAlgorithm* dh = CryptoFactory::i()->getAsymmetricAlgorithm(AsymAlgo::DH); - if (dh == NULL) return CKR_GENERAL_ERROR; + AsymmetricParameters *p = NULL; + AsymmetricAlgorithm *dh = CryptoFactory::i()->getAsymmetricAlgorithm(AsymAlgo::DH); + if (dh == NULL) + return CKR_GENERAL_ERROR; if (!dh->generateParameters(&p, (void *)bitLen)) { ERROR_MSG("Could not generate parameters"); @@ -10509,7 +10704,7 @@ CK_RV SoftHSM::generateDHParameters return CKR_GENERAL_ERROR; } - DHParameters* params = (DHParameters*) p; + DHParameters *params = (DHParameters *)p; CK_RV rv = CKR_OK; @@ -10518,46 +10713,49 @@ CK_RV SoftHSM::generateDHParameters CK_OBJECT_CLASS objClass = CKO_DOMAIN_PARAMETERS; CK_KEY_TYPE keyType = CKK_DH; CK_ATTRIBUTE paramsAttribs[maxAttribs] = { - { CKA_CLASS, &objClass, sizeof(objClass) }, - { CKA_TOKEN, &isOnToken, sizeof(isOnToken) }, - { CKA_PRIVATE, &isPrivate, sizeof(isPrivate) }, - { CKA_KEY_TYPE, &keyType, sizeof(keyType) }, + {CKA_CLASS, &objClass, sizeof(objClass)}, + {CKA_TOKEN, &isOnToken, sizeof(isOnToken)}, + {CKA_PRIVATE, &isPrivate, sizeof(isPrivate)}, + {CKA_KEY_TYPE, &keyType, sizeof(keyType)}, }; CK_ULONG paramsAttribsCount = 4; // Add the additional if (ulCount > (maxAttribs - paramsAttribsCount)) rv = CKR_TEMPLATE_INCONSISTENT; - for (CK_ULONG i=0; i < ulCount && rv == CKR_OK; ++i) + for (CK_ULONG i = 0; i < ulCount && rv == CKR_OK; ++i) { switch (pTemplate[i].type) { - case CKA_CLASS: - case CKA_TOKEN: - case CKA_PRIVATE: - case CKA_KEY_TYPE: - continue; + case CKA_CLASS: + case CKA_TOKEN: + case CKA_PRIVATE: + case CKA_KEY_TYPE: + continue; default: paramsAttribs[paramsAttribsCount++] = pTemplate[i]; } } if (rv == CKR_OK) - rv = this->CreateObject(hSession, paramsAttribs, paramsAttribsCount, phKey,OBJECT_OP_GENERATE); + rv = this->CreateObject(hSession, paramsAttribs, paramsAttribsCount, phKey, OBJECT_OP_GENERATE); // Store the attributes that are being supplied if (rv == CKR_OK) { - OSObject* osobject = (OSObject*)handleManager->getObject(*phKey); - if (osobject == NULL_PTR || !osobject->isValid()) { + OSObject *osobject = (OSObject *)handleManager->getObject(*phKey); + if (osobject == NULL_PTR || !osobject->isValid()) + { rv = CKR_FUNCTION_FAILED; - } else if (osobject->startTransaction()) { + } + else if (osobject->startTransaction()) + { bool bOK = true; // Common Attributes - bOK = bOK && osobject->setAttribute(CKA_LOCAL,true); + bOK = bOK && osobject->setAttribute(CKA_LOCAL, true); CK_ULONG ulKeyGenMechanism = (CK_ULONG)CKM_DH_PKCS_PARAMETER_GEN; - bOK = bOK && osobject->setAttribute(CKA_KEY_GEN_MECHANISM,ulKeyGenMechanism); + bOK = bOK && osobject->setAttribute(CKA_KEY_GEN_MECHANISM, ulKeyGenMechanism); // DH Domain Parameters Attributes ByteString prime; @@ -10582,7 +10780,8 @@ CK_RV SoftHSM::generateDHParameters if (!bOK) rv = CKR_FUNCTION_FAILED; - } else + } + else rv = CKR_FUNCTION_FAILED; } @@ -10595,9 +10794,10 @@ CK_RV SoftHSM::generateDHParameters { if (*phKey != CK_INVALID_HANDLE) { - OSObject* osparams = (OSObject*)handleManager->getObject(*phKey); + OSObject *osparams = (OSObject *)handleManager->getObject(*phKey); handleManager->destroyObject(*phKey); - if (osparams) osparams->destroyObject(); + if (osparams) + osparams->destroyObject(); *phKey = CK_INVALID_HANDLE; } } @@ -10606,29 +10806,28 @@ CK_RV SoftHSM::generateDHParameters } // Generate a GOST key pair -CK_RV SoftHSM::generateGOST -(CK_SESSION_HANDLE hSession, - CK_ATTRIBUTE_PTR pPublicKeyTemplate, - CK_ULONG ulPublicKeyAttributeCount, - CK_ATTRIBUTE_PTR pPrivateKeyTemplate, - CK_ULONG ulPrivateKeyAttributeCount, - CK_OBJECT_HANDLE_PTR phPublicKey, - CK_OBJECT_HANDLE_PTR phPrivateKey, - CK_BBOOL isPublicKeyOnToken, - CK_BBOOL isPublicKeyPrivate, - CK_BBOOL isPrivateKeyOnToken, - CK_BBOOL isPrivateKeyPrivate) +CK_RV SoftHSM::generateGOST(CK_SESSION_HANDLE hSession, + CK_ATTRIBUTE_PTR pPublicKeyTemplate, + CK_ULONG ulPublicKeyAttributeCount, + CK_ATTRIBUTE_PTR pPrivateKeyTemplate, + CK_ULONG ulPrivateKeyAttributeCount, + CK_OBJECT_HANDLE_PTR phPublicKey, + CK_OBJECT_HANDLE_PTR phPrivateKey, + CK_BBOOL isPublicKeyOnToken, + CK_BBOOL isPublicKeyPrivate, + CK_BBOOL isPrivateKeyOnToken, + CK_BBOOL isPrivateKeyPrivate) { *phPublicKey = CK_INVALID_HANDLE; *phPrivateKey = CK_INVALID_HANDLE; // Get the session - Session* session = (Session*)handleManager->getSession(hSession); + Session *session = (Session *)handleManager->getSession(hSession); if (session == NULL) return CKR_SESSION_HANDLE_INVALID; // Get the token - Token* token = session->getToken(); + Token *token = session->getToken(); if (token == NULL) return CKR_GENERAL_ERROR; @@ -10640,22 +10839,23 @@ CK_RV SoftHSM::generateGOST { switch (pPublicKeyTemplate[i].type) { - case CKA_GOSTR3410_PARAMS: - param_3410 = ByteString((unsigned char*)pPublicKeyTemplate[i].pValue, pPublicKeyTemplate[i].ulValueLen); - break; - case CKA_GOSTR3411_PARAMS: - param_3411 = ByteString((unsigned char*)pPublicKeyTemplate[i].pValue, pPublicKeyTemplate[i].ulValueLen); - break; - case CKA_GOST28147_PARAMS: - param_28147 = ByteString((unsigned char*)pPublicKeyTemplate[i].pValue, pPublicKeyTemplate[i].ulValueLen); - break; - default: - break; - } - } + case CKA_GOSTR3410_PARAMS: + param_3410 = ByteString((unsigned char *)pPublicKeyTemplate[i].pValue, pPublicKeyTemplate[i].ulValueLen); + break; + case CKA_GOSTR3411_PARAMS: + param_3411 = ByteString((unsigned char *)pPublicKeyTemplate[i].pValue, pPublicKeyTemplate[i].ulValueLen); + break; + case CKA_GOST28147_PARAMS: + param_28147 = ByteString((unsigned char *)pPublicKeyTemplate[i].pValue, pPublicKeyTemplate[i].ulValueLen); + break; + default: + break; + } + } // The parameters must be specified to be able to generate a key pair. - if (param_3410.size() == 0 || param_3411.size() == 0) { + if (param_3410.size() == 0 || param_3411.size() == 0) + { INFO_MSG("Missing parameter(s) in pPublicKeyTemplate"); return CKR_TEMPLATE_INCOMPLETE; } @@ -10665,9 +10865,10 @@ CK_RV SoftHSM::generateGOST p.setEC(param_3410); // Generate key pair - AsymmetricKeyPair* kp = NULL; - AsymmetricAlgorithm* gost = CryptoFactory::i()->getAsymmetricAlgorithm(AsymAlgo::GOST); - if (gost == NULL) return CKR_GENERAL_ERROR; + AsymmetricKeyPair *kp = NULL; + AsymmetricAlgorithm *gost = CryptoFactory::i()->getAsymmetricAlgorithm(AsymAlgo::GOST); + if (gost == NULL) + return CKR_GENERAL_ERROR; if (!gost->generateKeyPair(&kp, &p)) { ERROR_MSG("Could not generate key pair"); @@ -10675,8 +10876,8 @@ CK_RV SoftHSM::generateGOST return CKR_GENERAL_ERROR; } - GOSTPublicKey* pub = (GOSTPublicKey*) kp->getPublicKey(); - GOSTPrivateKey* priv = (GOSTPrivateKey*) kp->getPrivateKey(); + GOSTPublicKey *pub = (GOSTPublicKey *)kp->getPublicKey(); + GOSTPrivateKey *priv = (GOSTPrivateKey *)kp->getPrivateKey(); CK_RV rv = CKR_OK; @@ -10687,46 +10888,49 @@ CK_RV SoftHSM::generateGOST CK_OBJECT_CLASS publicKeyClass = CKO_PUBLIC_KEY; CK_KEY_TYPE publicKeyType = CKK_GOSTR3410; CK_ATTRIBUTE publicKeyAttribs[maxAttribs] = { - { CKA_CLASS, &publicKeyClass, sizeof(publicKeyClass) }, - { CKA_TOKEN, &isPublicKeyOnToken, sizeof(isPublicKeyOnToken) }, - { CKA_PRIVATE, &isPublicKeyPrivate, sizeof(isPublicKeyPrivate) }, - { CKA_KEY_TYPE, &publicKeyType, sizeof(publicKeyType) }, + {CKA_CLASS, &publicKeyClass, sizeof(publicKeyClass)}, + {CKA_TOKEN, &isPublicKeyOnToken, sizeof(isPublicKeyOnToken)}, + {CKA_PRIVATE, &isPublicKeyPrivate, sizeof(isPublicKeyPrivate)}, + {CKA_KEY_TYPE, &publicKeyType, sizeof(publicKeyType)}, }; CK_ULONG publicKeyAttribsCount = 4; // Add the additional if (ulPublicKeyAttributeCount > (maxAttribs - publicKeyAttribsCount)) rv = CKR_TEMPLATE_INCONSISTENT; - for (CK_ULONG i=0; i < ulPublicKeyAttributeCount && rv == CKR_OK; ++i) + for (CK_ULONG i = 0; i < ulPublicKeyAttributeCount && rv == CKR_OK; ++i) { switch (pPublicKeyTemplate[i].type) { - case CKA_CLASS: - case CKA_TOKEN: - case CKA_PRIVATE: - case CKA_KEY_TYPE: - continue; - default: - publicKeyAttribs[publicKeyAttribsCount++] = pPublicKeyTemplate[i]; + case CKA_CLASS: + case CKA_TOKEN: + case CKA_PRIVATE: + case CKA_KEY_TYPE: + continue; + default: + publicKeyAttribs[publicKeyAttribsCount++] = pPublicKeyTemplate[i]; } } if (rv == CKR_OK) - rv = this->CreateObject(hSession,publicKeyAttribs,publicKeyAttribsCount,phPublicKey,OBJECT_OP_GENERATE); + rv = this->CreateObject(hSession, publicKeyAttribs, publicKeyAttribsCount, phPublicKey, OBJECT_OP_GENERATE); // Store the attributes that are being supplied by the key generation to the object if (rv == CKR_OK) { - OSObject* osobject = (OSObject*)handleManager->getObject(*phPublicKey); - if (osobject == NULL_PTR || !osobject->isValid()) { + OSObject *osobject = (OSObject *)handleManager->getObject(*phPublicKey); + if (osobject == NULL_PTR || !osobject->isValid()) + { rv = CKR_FUNCTION_FAILED; - } else if (osobject->startTransaction()) { + } + else if (osobject->startTransaction()) + { bool bOK = true; // Common Key Attributes - bOK = bOK && osobject->setAttribute(CKA_LOCAL,true); + bOK = bOK && osobject->setAttribute(CKA_LOCAL, true); CK_ULONG ulKeyGenMechanism = (CK_ULONG)CKM_EC_KEY_PAIR_GEN; - bOK = bOK && osobject->setAttribute(CKA_KEY_GEN_MECHANISM,ulKeyGenMechanism); + bOK = bOK && osobject->setAttribute(CKA_KEY_GEN_MECHANISM, ulKeyGenMechanism); // EC Public Key Attributes ByteString point; @@ -10747,7 +10951,8 @@ CK_RV SoftHSM::generateGOST if (!bOK) rv = CKR_FUNCTION_FAILED; - } else + } + else rv = CKR_FUNCTION_FAILED; } } @@ -10759,48 +10964,51 @@ CK_RV SoftHSM::generateGOST CK_OBJECT_CLASS privateKeyClass = CKO_PRIVATE_KEY; CK_KEY_TYPE privateKeyType = CKK_GOSTR3410; CK_ATTRIBUTE privateKeyAttribs[maxAttribs] = { - { CKA_CLASS, &privateKeyClass, sizeof(privateKeyClass) }, - { CKA_TOKEN, &isPrivateKeyOnToken, sizeof(isPrivateKeyOnToken) }, - { CKA_PRIVATE, &isPrivateKeyPrivate, sizeof(isPrivateKeyPrivate) }, - { CKA_KEY_TYPE, &privateKeyType, sizeof(privateKeyType) }, + {CKA_CLASS, &privateKeyClass, sizeof(privateKeyClass)}, + {CKA_TOKEN, &isPrivateKeyOnToken, sizeof(isPrivateKeyOnToken)}, + {CKA_PRIVATE, &isPrivateKeyPrivate, sizeof(isPrivateKeyPrivate)}, + {CKA_KEY_TYPE, &privateKeyType, sizeof(privateKeyType)}, }; CK_ULONG privateKeyAttribsCount = 4; if (ulPrivateKeyAttributeCount > (maxAttribs - privateKeyAttribsCount)) rv = CKR_TEMPLATE_INCONSISTENT; - for (CK_ULONG i=0; i < ulPrivateKeyAttributeCount && rv == CKR_OK; ++i) + for (CK_ULONG i = 0; i < ulPrivateKeyAttributeCount && rv == CKR_OK; ++i) { switch (pPrivateKeyTemplate[i].type) { - case CKA_CLASS: - case CKA_TOKEN: - case CKA_PRIVATE: - case CKA_KEY_TYPE: - continue; - default: - privateKeyAttribs[privateKeyAttribsCount++] = pPrivateKeyTemplate[i]; + case CKA_CLASS: + case CKA_TOKEN: + case CKA_PRIVATE: + case CKA_KEY_TYPE: + continue; + default: + privateKeyAttribs[privateKeyAttribsCount++] = pPrivateKeyTemplate[i]; } } if (rv == CKR_OK) - rv = this->CreateObject(hSession,privateKeyAttribs,privateKeyAttribsCount,phPrivateKey,OBJECT_OP_GENERATE); + rv = this->CreateObject(hSession, privateKeyAttribs, privateKeyAttribsCount, phPrivateKey, OBJECT_OP_GENERATE); // Store the attributes that are being supplied by the key generation to the object if (rv == CKR_OK) { - OSObject* osobject = (OSObject*)handleManager->getObject(*phPrivateKey); - if (osobject == NULL_PTR || !osobject->isValid()) { + OSObject *osobject = (OSObject *)handleManager->getObject(*phPrivateKey); + if (osobject == NULL_PTR || !osobject->isValid()) + { rv = CKR_FUNCTION_FAILED; - } else if (osobject->startTransaction()) { + } + else if (osobject->startTransaction()) + { bool bOK = true; // Common Key Attributes - bOK = bOK && osobject->setAttribute(CKA_LOCAL,true); + bOK = bOK && osobject->setAttribute(CKA_LOCAL, true); CK_ULONG ulKeyGenMechanism = (CK_ULONG)CKM_EC_KEY_PAIR_GEN; - bOK = bOK && osobject->setAttribute(CKA_KEY_GEN_MECHANISM,ulKeyGenMechanism); + bOK = bOK && osobject->setAttribute(CKA_KEY_GEN_MECHANISM, ulKeyGenMechanism); // Common Private Key Attributes bool bAlwaysSensitive = osobject->getBooleanValue(CKA_SENSITIVE, false); - bOK = bOK && osobject->setAttribute(CKA_ALWAYS_SENSITIVE,bAlwaysSensitive); + bOK = bOK && osobject->setAttribute(CKA_ALWAYS_SENSITIVE, bAlwaysSensitive); bool bNeverExtractable = osobject->getBooleanValue(CKA_EXTRACTABLE, false) == false; bOK = bOK && osobject->setAttribute(CKA_NEVER_EXTRACTABLE, bNeverExtractable); @@ -10835,8 +11043,9 @@ CK_RV SoftHSM::generateGOST if (!bOK) rv = CKR_FUNCTION_FAILED; - } else - rv = CKR_FUNCTION_FAILED; + } + else + rv = CKR_FUNCTION_FAILED; } } @@ -10849,17 +11058,19 @@ CK_RV SoftHSM::generateGOST { if (*phPrivateKey != CK_INVALID_HANDLE) { - OSObject* ospriv = (OSObject*)handleManager->getObject(*phPrivateKey); + OSObject *ospriv = (OSObject *)handleManager->getObject(*phPrivateKey); handleManager->destroyObject(*phPrivateKey); - if (ospriv) ospriv->destroyObject(); + if (ospriv) + ospriv->destroyObject(); *phPrivateKey = CK_INVALID_HANDLE; } if (*phPublicKey != CK_INVALID_HANDLE) { - OSObject* ospub = (OSObject*)handleManager->getObject(*phPublicKey); + OSObject *ospub = (OSObject *)handleManager->getObject(*phPublicKey); handleManager->destroyObject(*phPublicKey); - if (ospub) ospub->destroyObject(); + if (ospub) + ospub->destroyObject(); *phPublicKey = CK_INVALID_HANDLE; } } @@ -10868,29 +11079,30 @@ CK_RV SoftHSM::generateGOST } // Derive a DH secret -CK_RV SoftHSM::deriveDH -(CK_SESSION_HANDLE hSession, - CK_MECHANISM_PTR pMechanism, - CK_OBJECT_HANDLE hBaseKey, - CK_ATTRIBUTE_PTR pTemplate, - CK_ULONG ulCount, - CK_OBJECT_HANDLE_PTR phKey, - CK_KEY_TYPE keyType, - CK_BBOOL isOnToken, - CK_BBOOL isPrivate) +CK_RV SoftHSM::deriveDH(CK_SESSION_HANDLE hSession, + CK_MECHANISM_PTR pMechanism, + CK_OBJECT_HANDLE hBaseKey, + CK_ATTRIBUTE_PTR pTemplate, + CK_ULONG ulCount, + CK_OBJECT_HANDLE_PTR phKey, + CK_KEY_TYPE keyType, + CK_BBOOL isOnToken, + CK_BBOOL isPrivate) { *phKey = CK_INVALID_HANDLE; - if (pMechanism->pParameter == NULL_PTR) return CKR_MECHANISM_PARAM_INVALID; - if (pMechanism->ulParameterLen == 0) return CKR_MECHANISM_PARAM_INVALID; + if (pMechanism->pParameter == NULL_PTR) + return CKR_MECHANISM_PARAM_INVALID; + if (pMechanism->ulParameterLen == 0) + return CKR_MECHANISM_PARAM_INVALID; // Get the session - Session* session = (Session*)handleManager->getSession(hSession); + Session *session = (Session *)handleManager->getSession(hSession); if (session == NULL) return CKR_SESSION_HANDLE_INVALID; // Get the token - Token* token = session->getToken(); + Token *token = session->getToken(); if (token == NULL) return CKR_GENERAL_ERROR; @@ -10901,75 +11113,75 @@ CK_RV SoftHSM::deriveDH { switch (pTemplate[i].type) { - case CKA_VALUE: - INFO_MSG("CKA_VALUE must not be included"); - return CKR_ATTRIBUTE_READ_ONLY; - case CKA_VALUE_LEN: - if (pTemplate[i].ulValueLen != sizeof(CK_ULONG)) - { - INFO_MSG("CKA_VALUE_LEN does not have the size of CK_ULONG"); - return CKR_ATTRIBUTE_VALUE_INVALID; - } - byteLen = *(CK_ULONG*)pTemplate[i].pValue; - break; - case CKA_CHECK_VALUE: - if (pTemplate[i].ulValueLen > 0) - { - INFO_MSG("CKA_CHECK_VALUE must be a no-value (0 length) entry"); - return CKR_ATTRIBUTE_VALUE_INVALID; - } - checkValue = false; - break; - default: - break; - } - } - - // Check the length - switch (keyType) - { - case CKK_GENERIC_SECRET: - if (byteLen == 0) - { - INFO_MSG("CKA_VALUE_LEN must be set"); - return CKR_TEMPLATE_INCOMPLETE; - } - break; -#ifndef WITH_FIPS - case CKK_DES: - if (byteLen != 0) + case CKA_VALUE: + INFO_MSG("CKA_VALUE must not be included"); + return CKR_ATTRIBUTE_READ_ONLY; + case CKA_VALUE_LEN: + if (pTemplate[i].ulValueLen != sizeof(CK_ULONG)) { - INFO_MSG("CKA_VALUE_LEN must not be set"); - return CKR_ATTRIBUTE_READ_ONLY; - } - byteLen = 8; - break; -#endif - case CKK_DES2: - if (byteLen != 0) - { - INFO_MSG("CKA_VALUE_LEN must not be set"); - return CKR_ATTRIBUTE_READ_ONLY; - } - byteLen = 16; - break; - case CKK_DES3: - if (byteLen != 0) - { - INFO_MSG("CKA_VALUE_LEN must not be set"); - return CKR_ATTRIBUTE_READ_ONLY; + INFO_MSG("CKA_VALUE_LEN does not have the size of CK_ULONG"); + return CKR_ATTRIBUTE_VALUE_INVALID; } - byteLen = 24; + byteLen = *(CK_ULONG *)pTemplate[i].pValue; break; - case CKK_AES: - if (byteLen != 16 && byteLen != 24 && byteLen != 32) + case CKA_CHECK_VALUE: + if (pTemplate[i].ulValueLen > 0) { - INFO_MSG("CKA_VALUE_LEN must be 16, 24, or 32"); + INFO_MSG("CKA_CHECK_VALUE must be a no-value (0 length) entry"); return CKR_ATTRIBUTE_VALUE_INVALID; } + checkValue = false; break; default: + break; + } + } + + // Check the length + switch (keyType) + { + case CKK_GENERIC_SECRET: + if (byteLen == 0) + { + INFO_MSG("CKA_VALUE_LEN must be set"); + return CKR_TEMPLATE_INCOMPLETE; + } + break; +#ifndef WITH_FIPS + case CKK_DES: + if (byteLen != 0) + { + INFO_MSG("CKA_VALUE_LEN must not be set"); + return CKR_ATTRIBUTE_READ_ONLY; + } + byteLen = 8; + break; +#endif + case CKK_DES2: + if (byteLen != 0) + { + INFO_MSG("CKA_VALUE_LEN must not be set"); + return CKR_ATTRIBUTE_READ_ONLY; + } + byteLen = 16; + break; + case CKK_DES3: + if (byteLen != 0) + { + INFO_MSG("CKA_VALUE_LEN must not be set"); + return CKR_ATTRIBUTE_READ_ONLY; + } + byteLen = 24; + break; + case CKK_AES: + if (byteLen != 16 && byteLen != 24 && byteLen != 32) + { + INFO_MSG("CKA_VALUE_LEN must be 16, 24, or 32"); return CKR_ATTRIBUTE_VALUE_INVALID; + } + break; + default: + return CKR_ATTRIBUTE_VALUE_INVALID; } // Get the base key handle @@ -10978,18 +11190,18 @@ CK_RV SoftHSM::deriveDH return CKR_KEY_HANDLE_INVALID; // Get the DH algorithm handler - AsymmetricAlgorithm* dh = CryptoFactory::i()->getAsymmetricAlgorithm(AsymAlgo::DH); + AsymmetricAlgorithm *dh = CryptoFactory::i()->getAsymmetricAlgorithm(AsymAlgo::DH); if (dh == NULL) return CKR_MECHANISM_INVALID; // Get the keys - PrivateKey* privateKey = dh->newPrivateKey(); + PrivateKey *privateKey = dh->newPrivateKey(); if (privateKey == NULL) { CryptoFactory::i()->recycleAsymmetricAlgorithm(dh); return CKR_HOST_MEMORY; } - if (getDHPrivateKey((DHPrivateKey*)privateKey, token, baseKey) != CKR_OK) + if (getDHPrivateKey((DHPrivateKey *)privateKey, token, baseKey) != CKR_OK) { dh->recyclePrivateKey(privateKey); CryptoFactory::i()->recycleAsymmetricAlgorithm(dh); @@ -10999,14 +11211,14 @@ CK_RV SoftHSM::deriveDH ByteString mechParameters; mechParameters.resize(pMechanism->ulParameterLen); memcpy(&mechParameters[0], pMechanism->pParameter, pMechanism->ulParameterLen); - PublicKey* publicKey = dh->newPublicKey(); + PublicKey *publicKey = dh->newPublicKey(); if (publicKey == NULL) { dh->recyclePrivateKey(privateKey); CryptoFactory::i()->recycleAsymmetricAlgorithm(dh); return CKR_HOST_MEMORY; } - if (getDHPublicKey((DHPublicKey*)publicKey, (DHPrivateKey*)privateKey, mechParameters) != CKR_OK) + if (getDHPublicKey((DHPublicKey *)publicKey, (DHPrivateKey *)privateKey, mechParameters) != CKR_OK) { dh->recyclePrivateKey(privateKey); dh->recyclePublicKey(publicKey); @@ -11015,7 +11227,7 @@ CK_RV SoftHSM::deriveDH } // Derive the secret - SymmetricKey* secret = NULL; + SymmetricKey *secret = NULL; CK_RV rv = CKR_OK; if (!dh->deriveKey(&secret, publicKey, privateKey)) rv = CKR_GENERAL_ERROR; @@ -11026,26 +11238,26 @@ CK_RV SoftHSM::deriveDH const CK_ULONG maxAttribs = 32; CK_OBJECT_CLASS objClass = CKO_SECRET_KEY; CK_ATTRIBUTE secretAttribs[maxAttribs] = { - { CKA_CLASS, &objClass, sizeof(objClass) }, - { CKA_TOKEN, &isOnToken, sizeof(isOnToken) }, - { CKA_PRIVATE, &isPrivate, sizeof(isPrivate) }, - { CKA_KEY_TYPE, &keyType, sizeof(keyType) }, + {CKA_CLASS, &objClass, sizeof(objClass)}, + {CKA_TOKEN, &isOnToken, sizeof(isOnToken)}, + {CKA_PRIVATE, &isPrivate, sizeof(isPrivate)}, + {CKA_KEY_TYPE, &keyType, sizeof(keyType)}, }; CK_ULONG secretAttribsCount = 4; // Add the additional if (ulCount > (maxAttribs - secretAttribsCount)) rv = CKR_TEMPLATE_INCONSISTENT; - for (CK_ULONG i=0; i < ulCount && rv == CKR_OK; ++i) + for (CK_ULONG i = 0; i < ulCount && rv == CKR_OK; ++i) { switch (pTemplate[i].type) { - case CKA_CLASS: - case CKA_TOKEN: - case CKA_PRIVATE: - case CKA_KEY_TYPE: - case CKA_CHECK_VALUE: - continue; + case CKA_CLASS: + case CKA_TOKEN: + case CKA_PRIVATE: + case CKA_KEY_TYPE: + case CKA_CHECK_VALUE: + continue; default: secretAttribs[secretAttribsCount++] = pTemplate[i]; } @@ -11057,33 +11269,36 @@ CK_RV SoftHSM::deriveDH // Store the attributes that are being supplied if (rv == CKR_OK) { - OSObject* osobject = (OSObject*)handleManager->getObject(*phKey); - if (osobject == NULL_PTR || !osobject->isValid()) { + OSObject *osobject = (OSObject *)handleManager->getObject(*phKey); + if (osobject == NULL_PTR || !osobject->isValid()) + { rv = CKR_FUNCTION_FAILED; - } else if (osobject->startTransaction()) { + } + else if (osobject->startTransaction()) + { bool bOK = true; // Common Attributes - bOK = bOK && osobject->setAttribute(CKA_LOCAL,false); + bOK = bOK && osobject->setAttribute(CKA_LOCAL, false); // Common Secret Key Attributes if (baseKey->getBooleanValue(CKA_ALWAYS_SENSITIVE, false)) { bool bAlwaysSensitive = osobject->getBooleanValue(CKA_SENSITIVE, false); - bOK = bOK && osobject->setAttribute(CKA_ALWAYS_SENSITIVE,bAlwaysSensitive); + bOK = bOK && osobject->setAttribute(CKA_ALWAYS_SENSITIVE, bAlwaysSensitive); } else { - bOK = bOK && osobject->setAttribute(CKA_ALWAYS_SENSITIVE,false); + bOK = bOK && osobject->setAttribute(CKA_ALWAYS_SENSITIVE, false); } if (baseKey->getBooleanValue(CKA_NEVER_EXTRACTABLE, true)) { bool bNeverExtractable = osobject->getBooleanValue(CKA_EXTRACTABLE, false) == false; - bOK = bOK && osobject->setAttribute(CKA_NEVER_EXTRACTABLE,bNeverExtractable); + bOK = bOK && osobject->setAttribute(CKA_NEVER_EXTRACTABLE, bNeverExtractable); } else { - bOK = bOK && osobject->setAttribute(CKA_NEVER_EXTRACTABLE,false); + bOK = bOK && osobject->setAttribute(CKA_NEVER_EXTRACTABLE, false); } // Secret Attributes @@ -11105,8 +11320,8 @@ CK_RV SoftHSM::deriveDH // Fix the odd parity for DES if (keyType == CKK_DES || - keyType == CKK_DES2 || - keyType == CKK_DES3) + keyType == CKK_DES2 || + keyType == CKK_DES3) { for (size_t i = 0; i < secretValue.size(); i++) { @@ -11117,23 +11332,23 @@ CK_RV SoftHSM::deriveDH // Get the KCV switch (keyType) { - case CKK_GENERIC_SECRET: - secret->setBitLen(byteLen * 8); - plainKCV = secret->getKeyCheckValue(); - break; - case CKK_DES: - case CKK_DES2: - case CKK_DES3: - secret->setBitLen(byteLen * 7); - plainKCV = ((DESKey*)secret)->getKeyCheckValue(); - break; - case CKK_AES: - secret->setBitLen(byteLen * 8); - plainKCV = ((AESKey*)secret)->getKeyCheckValue(); - break; - default: - bOK = false; - break; + case CKK_GENERIC_SECRET: + secret->setBitLen(byteLen * 8); + plainKCV = secret->getKeyCheckValue(); + break; + case CKK_DES: + case CKK_DES2: + case CKK_DES3: + secret->setBitLen(byteLen * 7); + plainKCV = ((DESKey *)secret)->getKeyCheckValue(); + break; + case CKK_AES: + secret->setBitLen(byteLen * 8); + plainKCV = ((AESKey *)secret)->getKeyCheckValue(); + break; + default: + bOK = false; + break; } if (isPrivate) @@ -11158,7 +11373,8 @@ CK_RV SoftHSM::deriveDH if (!bOK) rv = CKR_FUNCTION_FAILED; - } else + } + else rv = CKR_FUNCTION_FAILED; } @@ -11171,9 +11387,10 @@ CK_RV SoftHSM::deriveDH { if (*phKey != CK_INVALID_HANDLE) { - OSObject* ossecret = (OSObject*)handleManager->getObject(*phKey); + OSObject *ossecret = (OSObject *)handleManager->getObject(*phKey); handleManager->destroyObject(*phKey); - if (ossecret) ossecret->destroyObject(); + if (ossecret) + ossecret->destroyObject(); *phKey = CK_INVALID_HANDLE; } } @@ -11183,21 +11400,20 @@ CK_RV SoftHSM::deriveDH // Derive an ECDH secret #ifdef WITH_ECC -CK_RV SoftHSM::deriveECDH -(CK_SESSION_HANDLE hSession, - CK_MECHANISM_PTR pMechanism, - CK_OBJECT_HANDLE hBaseKey, - CK_ATTRIBUTE_PTR pTemplate, - CK_ULONG ulCount, - CK_OBJECT_HANDLE_PTR phKey, - CK_KEY_TYPE keyType, - CK_BBOOL isOnToken, - CK_BBOOL isPrivate) +CK_RV SoftHSM::deriveECDH(CK_SESSION_HANDLE hSession, + CK_MECHANISM_PTR pMechanism, + CK_OBJECT_HANDLE hBaseKey, + CK_ATTRIBUTE_PTR pTemplate, + CK_ULONG ulCount, + CK_OBJECT_HANDLE_PTR phKey, + CK_KEY_TYPE keyType, + CK_BBOOL isOnToken, + CK_BBOOL isPrivate) { *phKey = CK_INVALID_HANDLE; if ((pMechanism->pParameter == NULL_PTR) || - (pMechanism->ulParameterLen != sizeof(CK_ECDH1_DERIVE_PARAMS))) + (pMechanism->ulParameterLen != sizeof(CK_ECDH1_DERIVE_PARAMS))) { DEBUG_MSG("pParameter must be of type CK_ECDH1_DERIVE_PARAMS"); return CKR_MECHANISM_PARAM_INVALID; @@ -11208,25 +11424,25 @@ CK_RV SoftHSM::deriveECDH return CKR_MECHANISM_PARAM_INVALID; } if ((CK_ECDH1_DERIVE_PARAMS_PTR(pMechanism->pParameter)->ulSharedDataLen != 0) || - (CK_ECDH1_DERIVE_PARAMS_PTR(pMechanism->pParameter)->pSharedData != NULL_PTR)) + (CK_ECDH1_DERIVE_PARAMS_PTR(pMechanism->pParameter)->pSharedData != NULL_PTR)) { DEBUG_MSG("there must be no shared data"); return CKR_MECHANISM_PARAM_INVALID; } if ((CK_ECDH1_DERIVE_PARAMS_PTR(pMechanism->pParameter)->ulPublicDataLen == 0) || - (CK_ECDH1_DERIVE_PARAMS_PTR(pMechanism->pParameter)->pPublicData == NULL_PTR)) + (CK_ECDH1_DERIVE_PARAMS_PTR(pMechanism->pParameter)->pPublicData == NULL_PTR)) { DEBUG_MSG("there must be a public data"); return CKR_MECHANISM_PARAM_INVALID; } // Get the session - Session* session = (Session*)handleManager->getSession(hSession); + Session *session = (Session *)handleManager->getSession(hSession); if (session == NULL) return CKR_SESSION_HANDLE_INVALID; // Get the token - Token* token = session->getToken(); + Token *token = session->getToken(); if (token == NULL) return CKR_GENERAL_ERROR; @@ -11237,71 +11453,71 @@ CK_RV SoftHSM::deriveECDH { switch (pTemplate[i].type) { - case CKA_VALUE: - INFO_MSG("CKA_VALUE must not be included"); - return CKR_ATTRIBUTE_READ_ONLY; - case CKA_VALUE_LEN: - if (pTemplate[i].ulValueLen != sizeof(CK_ULONG)) - { - INFO_MSG("CKA_VALUE_LEN does not have the size of CK_ULONG"); - return CKR_ATTRIBUTE_VALUE_INVALID; - } - byteLen = *(CK_ULONG*)pTemplate[i].pValue; - break; - case CKA_CHECK_VALUE: - if (pTemplate[i].ulValueLen > 0) - { - INFO_MSG("CKA_CHECK_VALUE must be a no-value (0 length) entry"); - return CKR_ATTRIBUTE_VALUE_INVALID; - } - checkValue = false; - break; - default: - break; - } - } - - // Check the length - // byteLen == 0 impiles return max size the ECC can derive - switch (keyType) - { - case CKK_GENERIC_SECRET: - break; -#ifndef WITH_FIPS - case CKK_DES: - if (byteLen != 0 && byteLen != 8) + case CKA_VALUE: + INFO_MSG("CKA_VALUE must not be included"); + return CKR_ATTRIBUTE_READ_ONLY; + case CKA_VALUE_LEN: + if (pTemplate[i].ulValueLen != sizeof(CK_ULONG)) { - INFO_MSG("CKA_VALUE_LEN must be 0 or 8"); + INFO_MSG("CKA_VALUE_LEN does not have the size of CK_ULONG"); return CKR_ATTRIBUTE_VALUE_INVALID; } - byteLen = 8; + byteLen = *(CK_ULONG *)pTemplate[i].pValue; break; -#endif - case CKK_DES2: - if (byteLen != 0 && byteLen != 16) + case CKA_CHECK_VALUE: + if (pTemplate[i].ulValueLen > 0) { - INFO_MSG("CKA_VALUE_LEN must be 0 or 16"); - return CKR_ATTRIBUTE_VALUE_INVALID; - } - byteLen = 16; - break; - case CKK_DES3: - if (byteLen != 0 && byteLen != 24) - { - INFO_MSG("CKA_VALUE_LEN must be 0 or 24"); - return CKR_ATTRIBUTE_VALUE_INVALID; - } - byteLen = 24; - break; - case CKK_AES: - if (byteLen != 0 && byteLen != 16 && byteLen != 24 && byteLen != 32) - { - INFO_MSG("CKA_VALUE_LEN must be 0, 16, 24, or 32"); + INFO_MSG("CKA_CHECK_VALUE must be a no-value (0 length) entry"); return CKR_ATTRIBUTE_VALUE_INVALID; } + checkValue = false; break; default: + break; + } + } + + // Check the length + // byteLen == 0 impiles return max size the ECC can derive + switch (keyType) + { + case CKK_GENERIC_SECRET: + break; +#ifndef WITH_FIPS + case CKK_DES: + if (byteLen != 0 && byteLen != 8) + { + INFO_MSG("CKA_VALUE_LEN must be 0 or 8"); return CKR_ATTRIBUTE_VALUE_INVALID; + } + byteLen = 8; + break; +#endif + case CKK_DES2: + if (byteLen != 0 && byteLen != 16) + { + INFO_MSG("CKA_VALUE_LEN must be 0 or 16"); + return CKR_ATTRIBUTE_VALUE_INVALID; + } + byteLen = 16; + break; + case CKK_DES3: + if (byteLen != 0 && byteLen != 24) + { + INFO_MSG("CKA_VALUE_LEN must be 0 or 24"); + return CKR_ATTRIBUTE_VALUE_INVALID; + } + byteLen = 24; + break; + case CKK_AES: + if (byteLen != 0 && byteLen != 16 && byteLen != 24 && byteLen != 32) + { + INFO_MSG("CKA_VALUE_LEN must be 0, 16, 24, or 32"); + return CKR_ATTRIBUTE_VALUE_INVALID; + } + break; + default: + return CKR_ATTRIBUTE_VALUE_INVALID; } // Get the base key handle @@ -11310,18 +11526,18 @@ CK_RV SoftHSM::deriveECDH return CKR_KEY_HANDLE_INVALID; // Get the ECDH algorithm handler - AsymmetricAlgorithm* ecdh = CryptoFactory::i()->getAsymmetricAlgorithm(AsymAlgo::ECDH); + AsymmetricAlgorithm *ecdh = CryptoFactory::i()->getAsymmetricAlgorithm(AsymAlgo::ECDH); if (ecdh == NULL) return CKR_MECHANISM_INVALID; // Get the keys - PrivateKey* privateKey = ecdh->newPrivateKey(); + PrivateKey *privateKey = ecdh->newPrivateKey(); if (privateKey == NULL) { CryptoFactory::i()->recycleAsymmetricAlgorithm(ecdh); return CKR_HOST_MEMORY; } - if (getECPrivateKey((ECPrivateKey*)privateKey, token, baseKey) != CKR_OK) + if (getECPrivateKey((ECPrivateKey *)privateKey, token, baseKey) != CKR_OK) { ecdh->recyclePrivateKey(privateKey); CryptoFactory::i()->recycleAsymmetricAlgorithm(ecdh); @@ -11331,16 +11547,16 @@ CK_RV SoftHSM::deriveECDH ByteString publicData; publicData.resize(CK_ECDH1_DERIVE_PARAMS_PTR(pMechanism->pParameter)->ulPublicDataLen); memcpy(&publicData[0], - CK_ECDH1_DERIVE_PARAMS_PTR(pMechanism->pParameter)->pPublicData, - CK_ECDH1_DERIVE_PARAMS_PTR(pMechanism->pParameter)->ulPublicDataLen); - PublicKey* publicKey = ecdh->newPublicKey(); + CK_ECDH1_DERIVE_PARAMS_PTR(pMechanism->pParameter)->pPublicData, + CK_ECDH1_DERIVE_PARAMS_PTR(pMechanism->pParameter)->ulPublicDataLen); + PublicKey *publicKey = ecdh->newPublicKey(); if (publicKey == NULL) { ecdh->recyclePrivateKey(privateKey); CryptoFactory::i()->recycleAsymmetricAlgorithm(ecdh); return CKR_HOST_MEMORY; } - if (getECDHPublicKey((ECPublicKey*)publicKey, (ECPrivateKey*)privateKey, publicData) != CKR_OK) + if (getECDHPublicKey((ECPublicKey *)publicKey, (ECPrivateKey *)privateKey, publicData) != CKR_OK) { ecdh->recyclePrivateKey(privateKey); ecdh->recyclePublicKey(publicKey); @@ -11349,7 +11565,7 @@ CK_RV SoftHSM::deriveECDH } // Derive the secret - SymmetricKey* secret = NULL; + SymmetricKey *secret = NULL; CK_RV rv = CKR_OK; if (!ecdh->deriveKey(&secret, publicKey, privateKey)) rv = CKR_GENERAL_ERROR; @@ -11360,26 +11576,26 @@ CK_RV SoftHSM::deriveECDH const CK_ULONG maxAttribs = 32; CK_OBJECT_CLASS objClass = CKO_SECRET_KEY; CK_ATTRIBUTE secretAttribs[maxAttribs] = { - { CKA_CLASS, &objClass, sizeof(objClass) }, - { CKA_TOKEN, &isOnToken, sizeof(isOnToken) }, - { CKA_PRIVATE, &isPrivate, sizeof(isPrivate) }, - { CKA_KEY_TYPE, &keyType, sizeof(keyType) }, + {CKA_CLASS, &objClass, sizeof(objClass)}, + {CKA_TOKEN, &isOnToken, sizeof(isOnToken)}, + {CKA_PRIVATE, &isPrivate, sizeof(isPrivate)}, + {CKA_KEY_TYPE, &keyType, sizeof(keyType)}, }; CK_ULONG secretAttribsCount = 4; // Add the additional if (ulCount > (maxAttribs - secretAttribsCount)) rv = CKR_TEMPLATE_INCONSISTENT; - for (CK_ULONG i=0; i < ulCount && rv == CKR_OK; ++i) + for (CK_ULONG i = 0; i < ulCount && rv == CKR_OK; ++i) { switch (pTemplate[i].type) { - case CKA_CLASS: - case CKA_TOKEN: - case CKA_PRIVATE: - case CKA_KEY_TYPE: - case CKA_CHECK_VALUE: - continue; + case CKA_CLASS: + case CKA_TOKEN: + case CKA_PRIVATE: + case CKA_KEY_TYPE: + case CKA_CHECK_VALUE: + continue; default: secretAttribs[secretAttribsCount++] = pTemplate[i]; } @@ -11391,33 +11607,36 @@ CK_RV SoftHSM::deriveECDH // Store the attributes that are being supplied if (rv == CKR_OK) { - OSObject* osobject = (OSObject*)handleManager->getObject(*phKey); - if (osobject == NULL_PTR || !osobject->isValid()) { + OSObject *osobject = (OSObject *)handleManager->getObject(*phKey); + if (osobject == NULL_PTR || !osobject->isValid()) + { rv = CKR_FUNCTION_FAILED; - } else if (osobject->startTransaction()) { + } + else if (osobject->startTransaction()) + { bool bOK = true; // Common Attributes - bOK = bOK && osobject->setAttribute(CKA_LOCAL,false); + bOK = bOK && osobject->setAttribute(CKA_LOCAL, false); // Common Secret Key Attributes if (baseKey->getBooleanValue(CKA_ALWAYS_SENSITIVE, false)) { bool bAlwaysSensitive = osobject->getBooleanValue(CKA_SENSITIVE, false); - bOK = bOK && osobject->setAttribute(CKA_ALWAYS_SENSITIVE,bAlwaysSensitive); + bOK = bOK && osobject->setAttribute(CKA_ALWAYS_SENSITIVE, bAlwaysSensitive); } else { - bOK = bOK && osobject->setAttribute(CKA_ALWAYS_SENSITIVE,false); + bOK = bOK && osobject->setAttribute(CKA_ALWAYS_SENSITIVE, false); } if (baseKey->getBooleanValue(CKA_NEVER_EXTRACTABLE, true)) { bool bNeverExtractable = osobject->getBooleanValue(CKA_EXTRACTABLE, false) == false; - bOK = bOK && osobject->setAttribute(CKA_NEVER_EXTRACTABLE,bNeverExtractable); + bOK = bOK && osobject->setAttribute(CKA_NEVER_EXTRACTABLE, bNeverExtractable); } else { - bOK = bOK && osobject->setAttribute(CKA_NEVER_EXTRACTABLE,false); + bOK = bOK && osobject->setAttribute(CKA_NEVER_EXTRACTABLE, false); } // Secret Attributes @@ -11432,16 +11651,16 @@ CK_RV SoftHSM::deriveECDH { switch (keyType) { - case CKK_GENERIC_SECRET: - byteLen = secretValue.size(); - break; - case CKK_AES: - if (secretValue.size() >= 32) - byteLen = 32; - else if (secretValue.size() >= 24) - byteLen = 24; - else - byteLen = 16; + case CKK_GENERIC_SECRET: + byteLen = secretValue.size(); + break; + case CKK_AES: + if (secretValue.size() >= 32) + byteLen = 32; + else if (secretValue.size() >= 24) + byteLen = 24; + else + byteLen = 16; } } @@ -11458,8 +11677,8 @@ CK_RV SoftHSM::deriveECDH // Fix the odd parity for DES if (keyType == CKK_DES || - keyType == CKK_DES2 || - keyType == CKK_DES3) + keyType == CKK_DES2 || + keyType == CKK_DES3) { for (size_t i = 0; i < secretValue.size(); i++) { @@ -11470,23 +11689,23 @@ CK_RV SoftHSM::deriveECDH // Get the KCV switch (keyType) { - case CKK_GENERIC_SECRET: - secret->setBitLen(byteLen * 8); - plainKCV = secret->getKeyCheckValue(); - break; - case CKK_DES: - case CKK_DES2: - case CKK_DES3: - secret->setBitLen(byteLen * 7); - plainKCV = ((DESKey*)secret)->getKeyCheckValue(); - break; - case CKK_AES: - secret->setBitLen(byteLen * 8); - plainKCV = ((AESKey*)secret)->getKeyCheckValue(); - break; - default: - bOK = false; - break; + case CKK_GENERIC_SECRET: + secret->setBitLen(byteLen * 8); + plainKCV = secret->getKeyCheckValue(); + break; + case CKK_DES: + case CKK_DES2: + case CKK_DES3: + secret->setBitLen(byteLen * 7); + plainKCV = ((DESKey *)secret)->getKeyCheckValue(); + break; + case CKK_AES: + secret->setBitLen(byteLen * 8); + plainKCV = ((AESKey *)secret)->getKeyCheckValue(); + break; + default: + bOK = false; + break; } if (isPrivate) @@ -11511,7 +11730,8 @@ CK_RV SoftHSM::deriveECDH if (!bOK) rv = CKR_FUNCTION_FAILED; - } else + } + else rv = CKR_FUNCTION_FAILED; } @@ -11524,9 +11744,10 @@ CK_RV SoftHSM::deriveECDH { if (*phKey != CK_INVALID_HANDLE) { - OSObject* ossecret = (OSObject*)handleManager->getObject(*phKey); + OSObject *ossecret = (OSObject *)handleManager->getObject(*phKey); handleManager->destroyObject(*phKey); - if (ossecret) ossecret->destroyObject(); + if (ossecret) + ossecret->destroyObject(); *phKey = CK_INVALID_HANDLE; } } @@ -11537,21 +11758,20 @@ CK_RV SoftHSM::deriveECDH // Derive an ECDH secret using Montgomery curves #ifdef WITH_EDDSA -CK_RV SoftHSM::deriveEDDSA -(CK_SESSION_HANDLE hSession, - CK_MECHANISM_PTR pMechanism, - CK_OBJECT_HANDLE hBaseKey, - CK_ATTRIBUTE_PTR pTemplate, - CK_ULONG ulCount, - CK_OBJECT_HANDLE_PTR phKey, - CK_KEY_TYPE keyType, - CK_BBOOL isOnToken, - CK_BBOOL isPrivate) +CK_RV SoftHSM::deriveEDDSA(CK_SESSION_HANDLE hSession, + CK_MECHANISM_PTR pMechanism, + CK_OBJECT_HANDLE hBaseKey, + CK_ATTRIBUTE_PTR pTemplate, + CK_ULONG ulCount, + CK_OBJECT_HANDLE_PTR phKey, + CK_KEY_TYPE keyType, + CK_BBOOL isOnToken, + CK_BBOOL isPrivate) { *phKey = CK_INVALID_HANDLE; if ((pMechanism->pParameter == NULL_PTR) || - (pMechanism->ulParameterLen != sizeof(CK_ECDH1_DERIVE_PARAMS))) + (pMechanism->ulParameterLen != sizeof(CK_ECDH1_DERIVE_PARAMS))) { DEBUG_MSG("pParameter must be of type CK_ECDH1_DERIVE_PARAMS"); return CKR_MECHANISM_PARAM_INVALID; @@ -11562,25 +11782,25 @@ CK_RV SoftHSM::deriveEDDSA return CKR_MECHANISM_PARAM_INVALID; } if ((CK_ECDH1_DERIVE_PARAMS_PTR(pMechanism->pParameter)->ulSharedDataLen != 0) || - (CK_ECDH1_DERIVE_PARAMS_PTR(pMechanism->pParameter)->pSharedData != NULL_PTR)) + (CK_ECDH1_DERIVE_PARAMS_PTR(pMechanism->pParameter)->pSharedData != NULL_PTR)) { DEBUG_MSG("there must be no shared data"); return CKR_MECHANISM_PARAM_INVALID; } if ((CK_ECDH1_DERIVE_PARAMS_PTR(pMechanism->pParameter)->ulPublicDataLen == 0) || - (CK_ECDH1_DERIVE_PARAMS_PTR(pMechanism->pParameter)->pPublicData == NULL_PTR)) + (CK_ECDH1_DERIVE_PARAMS_PTR(pMechanism->pParameter)->pPublicData == NULL_PTR)) { DEBUG_MSG("there must be a public data"); return CKR_MECHANISM_PARAM_INVALID; } // Get the session - Session* session = (Session*)handleManager->getSession(hSession); + Session *session = (Session *)handleManager->getSession(hSession); if (session == NULL) return CKR_SESSION_HANDLE_INVALID; // Get the token - Token* token = session->getToken(); + Token *token = session->getToken(); if (token == NULL) return CKR_GENERAL_ERROR; @@ -11591,71 +11811,71 @@ CK_RV SoftHSM::deriveEDDSA { switch (pTemplate[i].type) { - case CKA_VALUE: - INFO_MSG("CKA_VALUE must not be included"); - return CKR_ATTRIBUTE_READ_ONLY; - case CKA_VALUE_LEN: - if (pTemplate[i].ulValueLen != sizeof(CK_ULONG)) - { - INFO_MSG("CKA_VALUE_LEN does not have the size of CK_ULONG"); - return CKR_ATTRIBUTE_VALUE_INVALID; - } - byteLen = *(CK_ULONG*)pTemplate[i].pValue; - break; - case CKA_CHECK_VALUE: - if (pTemplate[i].ulValueLen > 0) - { - INFO_MSG("CKA_CHECK_VALUE must be a no-value (0 length) entry"); - return CKR_ATTRIBUTE_VALUE_INVALID; - } - checkValue = false; - break; - default: - break; - } - } - - // Check the length - // byteLen == 0 impiles return max size the ECC can derive - switch (keyType) - { - case CKK_GENERIC_SECRET: - break; -#ifndef WITH_FIPS - case CKK_DES: - if (byteLen != 0 && byteLen != 8) - { - INFO_MSG("CKA_VALUE_LEN must be 0 or 8"); - return CKR_ATTRIBUTE_VALUE_INVALID; - } - byteLen = 8; - break; -#endif - case CKK_DES2: - if (byteLen != 0 && byteLen != 16) + case CKA_VALUE: + INFO_MSG("CKA_VALUE must not be included"); + return CKR_ATTRIBUTE_READ_ONLY; + case CKA_VALUE_LEN: + if (pTemplate[i].ulValueLen != sizeof(CK_ULONG)) { - INFO_MSG("CKA_VALUE_LEN must be 0 or 16"); + INFO_MSG("CKA_VALUE_LEN does not have the size of CK_ULONG"); return CKR_ATTRIBUTE_VALUE_INVALID; } - byteLen = 16; + byteLen = *(CK_ULONG *)pTemplate[i].pValue; break; - case CKK_DES3: - if (byteLen != 0 && byteLen != 24) + case CKA_CHECK_VALUE: + if (pTemplate[i].ulValueLen > 0) { - INFO_MSG("CKA_VALUE_LEN must be 0 or 24"); - return CKR_ATTRIBUTE_VALUE_INVALID; - } - byteLen = 24; - break; - case CKK_AES: - if (byteLen != 0 && byteLen != 16 && byteLen != 24 && byteLen != 32) - { - INFO_MSG("CKA_VALUE_LEN must be 0, 16, 24, or 32"); + INFO_MSG("CKA_CHECK_VALUE must be a no-value (0 length) entry"); return CKR_ATTRIBUTE_VALUE_INVALID; } + checkValue = false; break; default: + break; + } + } + + // Check the length + // byteLen == 0 impiles return max size the ECC can derive + switch (keyType) + { + case CKK_GENERIC_SECRET: + break; +#ifndef WITH_FIPS + case CKK_DES: + if (byteLen != 0 && byteLen != 8) + { + INFO_MSG("CKA_VALUE_LEN must be 0 or 8"); return CKR_ATTRIBUTE_VALUE_INVALID; + } + byteLen = 8; + break; +#endif + case CKK_DES2: + if (byteLen != 0 && byteLen != 16) + { + INFO_MSG("CKA_VALUE_LEN must be 0 or 16"); + return CKR_ATTRIBUTE_VALUE_INVALID; + } + byteLen = 16; + break; + case CKK_DES3: + if (byteLen != 0 && byteLen != 24) + { + INFO_MSG("CKA_VALUE_LEN must be 0 or 24"); + return CKR_ATTRIBUTE_VALUE_INVALID; + } + byteLen = 24; + break; + case CKK_AES: + if (byteLen != 0 && byteLen != 16 && byteLen != 24 && byteLen != 32) + { + INFO_MSG("CKA_VALUE_LEN must be 0, 16, 24, or 32"); + return CKR_ATTRIBUTE_VALUE_INVALID; + } + break; + default: + return CKR_ATTRIBUTE_VALUE_INVALID; } // Get the base key handle @@ -11664,18 +11884,18 @@ CK_RV SoftHSM::deriveEDDSA return CKR_KEY_HANDLE_INVALID; // Get the EDDSA algorithm handler - AsymmetricAlgorithm* eddsa = CryptoFactory::i()->getAsymmetricAlgorithm(AsymAlgo::EDDSA); + AsymmetricAlgorithm *eddsa = CryptoFactory::i()->getAsymmetricAlgorithm(AsymAlgo::EDDSA); if (eddsa == NULL) return CKR_MECHANISM_INVALID; // Get the keys - PrivateKey* privateKey = eddsa->newPrivateKey(); + PrivateKey *privateKey = eddsa->newPrivateKey(); if (privateKey == NULL) { CryptoFactory::i()->recycleAsymmetricAlgorithm(eddsa); return CKR_HOST_MEMORY; } - if (getEDPrivateKey((EDPrivateKey*)privateKey, token, baseKey) != CKR_OK) + if (getEDPrivateKey((EDPrivateKey *)privateKey, token, baseKey) != CKR_OK) { eddsa->recyclePrivateKey(privateKey); CryptoFactory::i()->recycleAsymmetricAlgorithm(eddsa); @@ -11685,16 +11905,16 @@ CK_RV SoftHSM::deriveEDDSA ByteString publicData; publicData.resize(CK_ECDH1_DERIVE_PARAMS_PTR(pMechanism->pParameter)->ulPublicDataLen); memcpy(&publicData[0], - CK_ECDH1_DERIVE_PARAMS_PTR(pMechanism->pParameter)->pPublicData, - CK_ECDH1_DERIVE_PARAMS_PTR(pMechanism->pParameter)->ulPublicDataLen); - PublicKey* publicKey = eddsa->newPublicKey(); + CK_ECDH1_DERIVE_PARAMS_PTR(pMechanism->pParameter)->pPublicData, + CK_ECDH1_DERIVE_PARAMS_PTR(pMechanism->pParameter)->ulPublicDataLen); + PublicKey *publicKey = eddsa->newPublicKey(); if (publicKey == NULL) { eddsa->recyclePrivateKey(privateKey); CryptoFactory::i()->recycleAsymmetricAlgorithm(eddsa); return CKR_HOST_MEMORY; } - if (getEDDHPublicKey((EDPublicKey*)publicKey, (EDPrivateKey*)privateKey, publicData) != CKR_OK) + if (getEDDHPublicKey((EDPublicKey *)publicKey, (EDPrivateKey *)privateKey, publicData) != CKR_OK) { eddsa->recyclePrivateKey(privateKey); eddsa->recyclePublicKey(publicKey); @@ -11703,7 +11923,7 @@ CK_RV SoftHSM::deriveEDDSA } // Derive the secret - SymmetricKey* secret = NULL; + SymmetricKey *secret = NULL; CK_RV rv = CKR_OK; if (!eddsa->deriveKey(&secret, publicKey, privateKey)) rv = CKR_GENERAL_ERROR; @@ -11714,26 +11934,26 @@ CK_RV SoftHSM::deriveEDDSA const CK_ULONG maxAttribs = 32; CK_OBJECT_CLASS objClass = CKO_SECRET_KEY; CK_ATTRIBUTE secretAttribs[maxAttribs] = { - { CKA_CLASS, &objClass, sizeof(objClass) }, - { CKA_TOKEN, &isOnToken, sizeof(isOnToken) }, - { CKA_PRIVATE, &isPrivate, sizeof(isPrivate) }, - { CKA_KEY_TYPE, &keyType, sizeof(keyType) }, + {CKA_CLASS, &objClass, sizeof(objClass)}, + {CKA_TOKEN, &isOnToken, sizeof(isOnToken)}, + {CKA_PRIVATE, &isPrivate, sizeof(isPrivate)}, + {CKA_KEY_TYPE, &keyType, sizeof(keyType)}, }; CK_ULONG secretAttribsCount = 4; // Add the additional if (ulCount > (maxAttribs - secretAttribsCount)) rv = CKR_TEMPLATE_INCONSISTENT; - for (CK_ULONG i=0; i < ulCount && rv == CKR_OK; ++i) + for (CK_ULONG i = 0; i < ulCount && rv == CKR_OK; ++i) { switch (pTemplate[i].type) { - case CKA_CLASS: - case CKA_TOKEN: - case CKA_PRIVATE: - case CKA_KEY_TYPE: - case CKA_CHECK_VALUE: - continue; + case CKA_CLASS: + case CKA_TOKEN: + case CKA_PRIVATE: + case CKA_KEY_TYPE: + case CKA_CHECK_VALUE: + continue; default: secretAttribs[secretAttribsCount++] = pTemplate[i]; } @@ -11745,33 +11965,36 @@ CK_RV SoftHSM::deriveEDDSA // Store the attributes that are being supplied if (rv == CKR_OK) { - OSObject* osobject = (OSObject*)handleManager->getObject(*phKey); - if (osobject == NULL_PTR || !osobject->isValid()) { + OSObject *osobject = (OSObject *)handleManager->getObject(*phKey); + if (osobject == NULL_PTR || !osobject->isValid()) + { rv = CKR_FUNCTION_FAILED; - } else if (osobject->startTransaction()) { + } + else if (osobject->startTransaction()) + { bool bOK = true; // Common Attributes - bOK = bOK && osobject->setAttribute(CKA_LOCAL,false); + bOK = bOK && osobject->setAttribute(CKA_LOCAL, false); // Common Secret Key Attributes if (baseKey->getBooleanValue(CKA_ALWAYS_SENSITIVE, false)) { bool bAlwaysSensitive = osobject->getBooleanValue(CKA_SENSITIVE, false); - bOK = bOK && osobject->setAttribute(CKA_ALWAYS_SENSITIVE,bAlwaysSensitive); + bOK = bOK && osobject->setAttribute(CKA_ALWAYS_SENSITIVE, bAlwaysSensitive); } else { - bOK = bOK && osobject->setAttribute(CKA_ALWAYS_SENSITIVE,false); + bOK = bOK && osobject->setAttribute(CKA_ALWAYS_SENSITIVE, false); } if (baseKey->getBooleanValue(CKA_NEVER_EXTRACTABLE, true)) { bool bNeverExtractable = osobject->getBooleanValue(CKA_EXTRACTABLE, false) == false; - bOK = bOK && osobject->setAttribute(CKA_NEVER_EXTRACTABLE,bNeverExtractable); + bOK = bOK && osobject->setAttribute(CKA_NEVER_EXTRACTABLE, bNeverExtractable); } else { - bOK = bOK && osobject->setAttribute(CKA_NEVER_EXTRACTABLE,false); + bOK = bOK && osobject->setAttribute(CKA_NEVER_EXTRACTABLE, false); } // Secret Attributes @@ -11786,16 +12009,16 @@ CK_RV SoftHSM::deriveEDDSA { switch (keyType) { - case CKK_GENERIC_SECRET: - byteLen = secretValue.size(); - break; - case CKK_AES: - if (secretValue.size() >= 32) - byteLen = 32; - else if (secretValue.size() >= 24) - byteLen = 24; - else - byteLen = 16; + case CKK_GENERIC_SECRET: + byteLen = secretValue.size(); + break; + case CKK_AES: + if (secretValue.size() >= 32) + byteLen = 32; + else if (secretValue.size() >= 24) + byteLen = 24; + else + byteLen = 16; } } @@ -11812,8 +12035,8 @@ CK_RV SoftHSM::deriveEDDSA // Fix the odd parity for DES if (keyType == CKK_DES || - keyType == CKK_DES2 || - keyType == CKK_DES3) + keyType == CKK_DES2 || + keyType == CKK_DES3) { for (size_t i = 0; i < secretValue.size(); i++) { @@ -11824,23 +12047,23 @@ CK_RV SoftHSM::deriveEDDSA // Get the KCV switch (keyType) { - case CKK_GENERIC_SECRET: - secret->setBitLen(byteLen * 8); - plainKCV = secret->getKeyCheckValue(); - break; - case CKK_DES: - case CKK_DES2: - case CKK_DES3: - secret->setBitLen(byteLen * 7); - plainKCV = ((DESKey*)secret)->getKeyCheckValue(); - break; - case CKK_AES: - secret->setBitLen(byteLen * 8); - plainKCV = ((AESKey*)secret)->getKeyCheckValue(); - break; - default: - bOK = false; - break; + case CKK_GENERIC_SECRET: + secret->setBitLen(byteLen * 8); + plainKCV = secret->getKeyCheckValue(); + break; + case CKK_DES: + case CKK_DES2: + case CKK_DES3: + secret->setBitLen(byteLen * 7); + plainKCV = ((DESKey *)secret)->getKeyCheckValue(); + break; + case CKK_AES: + secret->setBitLen(byteLen * 8); + plainKCV = ((AESKey *)secret)->getKeyCheckValue(); + break; + default: + bOK = false; + break; } if (isPrivate) @@ -11865,7 +12088,8 @@ CK_RV SoftHSM::deriveEDDSA if (!bOK) rv = CKR_FUNCTION_FAILED; - } else + } + else rv = CKR_FUNCTION_FAILED; } @@ -11878,9 +12102,10 @@ CK_RV SoftHSM::deriveEDDSA { if (*phKey != CK_INVALID_HANDLE) { - OSObject* ossecret = (OSObject*)handleManager->getObject(*phKey); + OSObject *ossecret = (OSObject *)handleManager->getObject(*phKey); handleManager->destroyObject(*phKey); - if (ossecret) ossecret->destroyObject(); + if (ossecret) + ossecret->destroyObject(); *phKey = CK_INVALID_HANDLE; } } @@ -11890,16 +12115,15 @@ CK_RV SoftHSM::deriveEDDSA #endif // Derive an symmetric secret -CK_RV SoftHSM::deriveSymmetric -(CK_SESSION_HANDLE hSession, - CK_MECHANISM_PTR pMechanism, - CK_OBJECT_HANDLE hBaseKey, - CK_ATTRIBUTE_PTR pTemplate, - CK_ULONG ulCount, - CK_OBJECT_HANDLE_PTR phKey, - CK_KEY_TYPE keyType, - CK_BBOOL isOnToken, - CK_BBOOL isPrivate) +CK_RV SoftHSM::deriveSymmetric(CK_SESSION_HANDLE hSession, + CK_MECHANISM_PTR pMechanism, + CK_OBJECT_HANDLE hBaseKey, + CK_ATTRIBUTE_PTR pTemplate, + CK_ULONG ulCount, + CK_OBJECT_HANDLE_PTR phKey, + CK_KEY_TYPE keyType, + CK_BBOOL isOnToken, + CK_BBOOL isPrivate) { *phKey = CK_INVALID_HANDLE; CK_OBJECT_HANDLE_PTR phOtherKey = CK_INVALID_HANDLE; @@ -11914,8 +12138,8 @@ CK_RV SoftHSM::deriveSymmetric ByteString data; if ((pMechanism->mechanism == CKM_DES_ECB_ENCRYPT_DATA || - pMechanism->mechanism == CKM_DES3_ECB_ENCRYPT_DATA) && - pMechanism->ulParameterLen == sizeof(CK_KEY_DERIVATION_STRING_DATA)) + pMechanism->mechanism == CKM_DES3_ECB_ENCRYPT_DATA) && + pMechanism->ulParameterLen == sizeof(CK_KEY_DERIVATION_STRING_DATA)) { CK_BYTE_PTR pData = CK_KEY_DERIVATION_STRING_DATA_PTR(pMechanism->pParameter)->pData; CK_ULONG ulLen = CK_KEY_DERIVATION_STRING_DATA_PTR(pMechanism->pParameter)->ulLen; @@ -11931,12 +12155,12 @@ CK_RV SoftHSM::deriveSymmetric } data.resize(ulLen); memcpy(&data[0], - pData, - ulLen); + pData, + ulLen); } else if ((pMechanism->mechanism == CKM_DES_CBC_ENCRYPT_DATA || - pMechanism->mechanism == CKM_DES3_CBC_ENCRYPT_DATA) && - pMechanism->ulParameterLen == sizeof(CK_DES_CBC_ENCRYPT_DATA_PARAMS)) + pMechanism->mechanism == CKM_DES3_CBC_ENCRYPT_DATA) && + pMechanism->ulParameterLen == sizeof(CK_DES_CBC_ENCRYPT_DATA_PARAMS)) { CK_BYTE_PTR pData = CK_DES_CBC_ENCRYPT_DATA_PARAMS_PTR(pMechanism->pParameter)->pData; CK_ULONG length = CK_DES_CBC_ENCRYPT_DATA_PARAMS_PTR(pMechanism->pParameter)->length; @@ -11952,11 +12176,11 @@ CK_RV SoftHSM::deriveSymmetric } data.resize(length); memcpy(&data[0], - pData, - length); + pData, + length); } else if (pMechanism->mechanism == CKM_AES_ECB_ENCRYPT_DATA && - pMechanism->ulParameterLen == sizeof(CK_KEY_DERIVATION_STRING_DATA)) + pMechanism->ulParameterLen == sizeof(CK_KEY_DERIVATION_STRING_DATA)) { CK_BYTE_PTR pData = CK_KEY_DERIVATION_STRING_DATA_PTR(pMechanism->pParameter)->pData; CK_ULONG ulLen = CK_KEY_DERIVATION_STRING_DATA_PTR(pMechanism->pParameter)->ulLen; @@ -11972,11 +12196,11 @@ CK_RV SoftHSM::deriveSymmetric } data.resize(ulLen); memcpy(&data[0], - pData, - ulLen); + pData, + ulLen); } else if ((pMechanism->mechanism == CKM_AES_CBC_ENCRYPT_DATA) && - pMechanism->ulParameterLen == sizeof(CK_AES_CBC_ENCRYPT_DATA_PARAMS)) + pMechanism->ulParameterLen == sizeof(CK_AES_CBC_ENCRYPT_DATA_PARAMS)) { CK_BYTE_PTR pData = CK_AES_CBC_ENCRYPT_DATA_PARAMS_PTR(pMechanism->pParameter)->pData; CK_ULONG length = CK_AES_CBC_ENCRYPT_DATA_PARAMS_PTR(pMechanism->pParameter)->length; @@ -11992,12 +12216,12 @@ CK_RV SoftHSM::deriveSymmetric } data.resize(length); memcpy(&data[0], - pData, - length); + pData, + length); } else if ((pMechanism->mechanism == CKM_CONCATENATE_DATA_AND_BASE || - pMechanism->mechanism == CKM_CONCATENATE_BASE_AND_DATA) && - pMechanism->ulParameterLen == sizeof(CK_KEY_DERIVATION_STRING_DATA)) + pMechanism->mechanism == CKM_CONCATENATE_BASE_AND_DATA) && + pMechanism->ulParameterLen == sizeof(CK_KEY_DERIVATION_STRING_DATA)) { CK_BYTE_PTR pData = CK_KEY_DERIVATION_STRING_DATA_PTR(pMechanism->pParameter)->pData; CK_ULONG length = CK_KEY_DERIVATION_STRING_DATA_PTR(pMechanism->pParameter)->ulLen; @@ -12008,11 +12232,11 @@ CK_RV SoftHSM::deriveSymmetric } data.resize(length); memcpy(&data[0], - pData, - length); + pData, + length); } else if (pMechanism->mechanism == CKM_CONCATENATE_BASE_AND_KEY && - pMechanism->ulParameterLen == sizeof(CK_OBJECT_HANDLE)) + pMechanism->ulParameterLen == sizeof(CK_OBJECT_HANDLE)) { phOtherKey = CK_OBJECT_HANDLE_PTR(pMechanism->pParameter); if (phOtherKey == CK_INVALID_HANDLE) @@ -12029,24 +12253,30 @@ CK_RV SoftHSM::deriveSymmetric } // Get the session - Session* session = (Session*)handleManager->getSession(hSession); + Session *session = (Session *)handleManager->getSession(hSession); if (session == NULL) return CKR_SESSION_HANDLE_INVALID; // Get the token - Token* token = session->getToken(); + Token *token = session->getToken(); if (token == NULL) return CKR_GENERAL_ERROR; // Extract another key - if (pMechanism->mechanism == CKM_CONCATENATE_BASE_AND_KEY) { + if (pMechanism->mechanism == CKM_CONCATENATE_BASE_AND_KEY) + { // Check the key handle. otherKey = (OSObject *)handleManager->getObject(*phOtherKey); - if (otherKey == NULL_PTR || !otherKey->isValid()) return CKR_OBJECT_HANDLE_INVALID; - if (otherKey->getBooleanValue(CKA_PRIVATE, true)) { + if (otherKey == NULL_PTR || !otherKey->isValid()) + return CKR_OBJECT_HANDLE_INVALID; + if (otherKey->getBooleanValue(CKA_PRIVATE, true)) + { bool bOK = token->decrypt(otherKey->getByteStringValue(CKA_VALUE), data); - if (!bOK) return CKR_GENERAL_ERROR; - } else { + if (!bOK) + return CKR_GENERAL_ERROR; + } + else + { data = otherKey->getByteStringValue(CKA_VALUE); } } @@ -12058,72 +12288,79 @@ CK_RV SoftHSM::deriveSymmetric { switch (pTemplate[i].type) { - case CKA_VALUE: - INFO_MSG("CKA_VALUE must not be included"); - return CKR_ATTRIBUTE_READ_ONLY; - case CKA_VALUE_LEN: - if (pTemplate[i].ulValueLen != sizeof(CK_ULONG)) - { - INFO_MSG("CKA_VALUE_LEN does not have the size of CK_ULONG"); - return CKR_ATTRIBUTE_VALUE_INVALID; - } - byteLen = *(CK_ULONG*)pTemplate[i].pValue; - break; - case CKA_CHECK_VALUE: - if (pTemplate[i].ulValueLen > 0) - { - INFO_MSG("CKA_CHECK_VALUE must be a no-value (0 length) entry"); - return CKR_ATTRIBUTE_VALUE_INVALID; - } - checkValue = false; - break; - default: - break; + case CKA_VALUE: + INFO_MSG("CKA_VALUE must not be included"); + return CKR_ATTRIBUTE_READ_ONLY; + case CKA_VALUE_LEN: + if (pTemplate[i].ulValueLen != sizeof(CK_ULONG)) + { + INFO_MSG("CKA_VALUE_LEN does not have the size of CK_ULONG"); + return CKR_ATTRIBUTE_VALUE_INVALID; + } + byteLen = *(CK_ULONG *)pTemplate[i].pValue; + break; + case CKA_CHECK_VALUE: + if (pTemplate[i].ulValueLen > 0) + { + INFO_MSG("CKA_CHECK_VALUE must be a no-value (0 length) entry"); + return CKR_ATTRIBUTE_VALUE_INVALID; + } + checkValue = false; + break; + default: + break; } } // Check the length if it specified or a mechanism is not one of misc mechanisms if (byteLen > 0 || (pMechanism->mechanism != CKM_CONCATENATE_DATA_AND_BASE && - pMechanism->mechanism != CKM_CONCATENATE_BASE_AND_DATA && - pMechanism->mechanism != CKM_CONCATENATE_BASE_AND_KEY)) { - switch (keyType) { - case CKK_GENERIC_SECRET: - if (byteLen == 0) { - INFO_MSG("CKA_VALUE_LEN must be set"); - return CKR_TEMPLATE_INCOMPLETE; - } - break; + pMechanism->mechanism != CKM_CONCATENATE_BASE_AND_DATA && + pMechanism->mechanism != CKM_CONCATENATE_BASE_AND_KEY)) + { + switch (keyType) + { + case CKK_GENERIC_SECRET: + if (byteLen == 0) + { + INFO_MSG("CKA_VALUE_LEN must be set"); + return CKR_TEMPLATE_INCOMPLETE; + } + break; #ifndef WITH_FIPS - case CKK_DES: - if (byteLen != 0) { - INFO_MSG("CKA_VALUE_LEN must not be set"); - return CKR_ATTRIBUTE_READ_ONLY; - } - byteLen = 8; - break; + case CKK_DES: + if (byteLen != 0) + { + INFO_MSG("CKA_VALUE_LEN must not be set"); + return CKR_ATTRIBUTE_READ_ONLY; + } + byteLen = 8; + break; #endif - case CKK_DES2: - if (byteLen != 0) { - INFO_MSG("CKA_VALUE_LEN must not be set"); - return CKR_ATTRIBUTE_READ_ONLY; - } - byteLen = 16; - break; - case CKK_DES3: - if (byteLen != 0) { - INFO_MSG("CKA_VALUE_LEN must not be set"); - return CKR_ATTRIBUTE_READ_ONLY; - } - byteLen = 24; - break; - case CKK_AES: - if (byteLen != 16 && byteLen != 24 && byteLen != 32) { - INFO_MSG("CKA_VALUE_LEN must be 16, 24, or 32"); - return CKR_ATTRIBUTE_VALUE_INVALID; - } - break; - default: + case CKK_DES2: + if (byteLen != 0) + { + INFO_MSG("CKA_VALUE_LEN must not be set"); + return CKR_ATTRIBUTE_READ_ONLY; + } + byteLen = 16; + break; + case CKK_DES3: + if (byteLen != 0) + { + INFO_MSG("CKA_VALUE_LEN must not be set"); + return CKR_ATTRIBUTE_READ_ONLY; + } + byteLen = 24; + break; + case CKK_AES: + if (byteLen != 16 && byteLen != 24 && byteLen != 32) + { + INFO_MSG("CKA_VALUE_LEN must be 16, 24, or 32"); return CKR_ATTRIBUTE_VALUE_INVALID; + } + break; + default: + return CKR_ATTRIBUTE_VALUE_INVALID; } } @@ -12133,151 +12370,168 @@ CK_RV SoftHSM::deriveSymmetric bool padding = false; ByteString iv; size_t bb = 8; - switch(pMechanism->mechanism) { + switch (pMechanism->mechanism) + { #ifndef WITH_FIPS - case CKM_DES_ECB_ENCRYPT_DATA: - algo = SymAlgo::DES; - mode = SymMode::ECB; - bb = 7; - break; - case CKM_DES_CBC_ENCRYPT_DATA: - algo = SymAlgo::DES; - mode = SymMode::CBC; - bb = 7; - iv.resize(8); - memcpy(&iv[0], - &(CK_DES_CBC_ENCRYPT_DATA_PARAMS_PTR(pMechanism->pParameter)->iv[0]), - 8); - break; + case CKM_DES_ECB_ENCRYPT_DATA: + algo = SymAlgo::DES; + mode = SymMode::ECB; + bb = 7; + break; + case CKM_DES_CBC_ENCRYPT_DATA: + algo = SymAlgo::DES; + mode = SymMode::CBC; + bb = 7; + iv.resize(8); + memcpy(&iv[0], + &(CK_DES_CBC_ENCRYPT_DATA_PARAMS_PTR(pMechanism->pParameter)->iv[0]), + 8); + break; #endif - case CKM_DES3_ECB_ENCRYPT_DATA: - algo = SymAlgo::DES3; - mode = SymMode::ECB; - bb = 7; - break; - case CKM_DES3_CBC_ENCRYPT_DATA: - algo = SymAlgo::DES3; - mode = SymMode::CBC; - bb = 7; - iv.resize(8); - memcpy(&iv[0], - &(CK_DES_CBC_ENCRYPT_DATA_PARAMS_PTR(pMechanism->pParameter)->iv[0]), - 8); - break; - case CKM_AES_ECB_ENCRYPT_DATA: - algo = SymAlgo::AES; - mode = SymMode::ECB; - break; - case CKM_AES_CBC_ENCRYPT_DATA: - algo = SymAlgo::AES; - mode = SymMode::CBC; - iv.resize(16); - memcpy(&iv[0], - &(CK_AES_CBC_ENCRYPT_DATA_PARAMS_PTR(pMechanism->pParameter)->iv[0]), - 16); - break; - case CKM_CONCATENATE_DATA_AND_BASE: - case CKM_CONCATENATE_BASE_AND_DATA: - case CKM_CONCATENATE_BASE_AND_KEY: - break; - default: - return CKR_MECHANISM_INVALID; + case CKM_DES3_ECB_ENCRYPT_DATA: + algo = SymAlgo::DES3; + mode = SymMode::ECB; + bb = 7; + break; + case CKM_DES3_CBC_ENCRYPT_DATA: + algo = SymAlgo::DES3; + mode = SymMode::CBC; + bb = 7; + iv.resize(8); + memcpy(&iv[0], + &(CK_DES_CBC_ENCRYPT_DATA_PARAMS_PTR(pMechanism->pParameter)->iv[0]), + 8); + break; + case CKM_AES_ECB_ENCRYPT_DATA: + algo = SymAlgo::AES; + mode = SymMode::ECB; + break; + case CKM_AES_CBC_ENCRYPT_DATA: + algo = SymAlgo::AES; + mode = SymMode::CBC; + iv.resize(16); + memcpy(&iv[0], + &(CK_AES_CBC_ENCRYPT_DATA_PARAMS_PTR(pMechanism->pParameter)->iv[0]), + 16); + break; + case CKM_CONCATENATE_DATA_AND_BASE: + case CKM_CONCATENATE_BASE_AND_DATA: + case CKM_CONCATENATE_BASE_AND_KEY: + break; + default: + return CKR_MECHANISM_INVALID; } // Check the key handle OSObject *baseKey = (OSObject *)handleManager->getObject(hBaseKey); - if (baseKey == NULL_PTR || !baseKey->isValid()) return CKR_OBJECT_HANDLE_INVALID; - - // Get the data - ByteString secretValue; - - if (pMechanism->mechanism == CKM_CONCATENATE_DATA_AND_BASE || - pMechanism->mechanism == CKM_CONCATENATE_BASE_AND_DATA || - pMechanism->mechanism == CKM_CONCATENATE_BASE_AND_KEY) { - // Get the key data - ByteString keydata; - - // Get the CKA_PRIVATE attribute, when the attribute is not present use default false - bool isKeyPrivate = baseKey->getBooleanValue(CKA_PRIVATE, false); - if (isKeyPrivate) - { - bool bOK = token->decrypt(baseKey->getByteStringValue(CKA_VALUE), keydata); - if (!bOK) return CKR_GENERAL_ERROR; - } - else - { - keydata = baseKey->getByteStringValue(CKA_VALUE); - } - - if (pMechanism->mechanism == CKM_CONCATENATE_DATA_AND_BASE) { + if (baseKey == NULL_PTR || !baseKey->isValid()) + return CKR_OBJECT_HANDLE_INVALID; + + // Get the data + ByteString secretValue; + + if (pMechanism->mechanism == CKM_CONCATENATE_DATA_AND_BASE || + pMechanism->mechanism == CKM_CONCATENATE_BASE_AND_DATA || + pMechanism->mechanism == CKM_CONCATENATE_BASE_AND_KEY) + { + // Get the key data + ByteString keydata; + + // Get the CKA_PRIVATE attribute, when the attribute is not present use default false + bool isKeyPrivate = baseKey->getBooleanValue(CKA_PRIVATE, false); + if (isKeyPrivate) + { + bool bOK = token->decrypt(baseKey->getByteStringValue(CKA_VALUE), keydata); + if (!bOK) + return CKR_GENERAL_ERROR; + } + else + { + keydata = baseKey->getByteStringValue(CKA_VALUE); + } + + if (pMechanism->mechanism == CKM_CONCATENATE_DATA_AND_BASE) + { secretValue += data; secretValue += keydata; - } else if (pMechanism->mechanism == CKM_CONCATENATE_BASE_AND_DATA || - pMechanism->mechanism == CKM_CONCATENATE_BASE_AND_KEY) { + } + else if (pMechanism->mechanism == CKM_CONCATENATE_BASE_AND_DATA || + pMechanism->mechanism == CKM_CONCATENATE_BASE_AND_KEY) + { secretValue += keydata; secretValue += data; - } else { - return CKR_MECHANISM_INVALID; - } - - // If the CKA_VALUE_LEN attribute is not present use computed size - if (byteLen == 0) { - byteLen = data.size() + keydata.size(); - CK_RV rv = checkKeyLength(keyType, byteLen); - if (rv != CKR_OK) { - return rv; - } - } - } else { - SymmetricAlgorithm* cipher = CryptoFactory::i()->getSymmetricAlgorithm(algo); - if (cipher == NULL) return CKR_MECHANISM_INVALID; - - SymmetricKey* secretkey = new SymmetricKey(); - - if (getSymmetricKey(secretkey, token, baseKey) != CKR_OK) - { - cipher->recycleKey(secretkey); - CryptoFactory::i()->recycleSymmetricAlgorithm(cipher); - return CKR_GENERAL_ERROR; - } - - // adjust key bit length - secretkey->setBitLen(secretkey->getKeyBits().size() * bb); - - // Initialize encryption - if (!cipher->encryptInit(secretkey, mode, iv, padding)) { - cipher->recycleKey(secretkey); - CryptoFactory::i()->recycleSymmetricAlgorithm(cipher); - return CKR_MECHANISM_INVALID; - } - - // Encrypt the data - if (!cipher->encryptUpdate(data, secretValue)) { - cipher->recycleKey(secretkey); - CryptoFactory::i()->recycleSymmetricAlgorithm(cipher); - return CKR_GENERAL_ERROR; - } - - // Finalize encryption - ByteString encryptedFinal; - if (!cipher->encryptFinal(encryptedFinal)) { - cipher->recycleKey(secretkey); - CryptoFactory::i()->recycleSymmetricAlgorithm(cipher); - return CKR_GENERAL_ERROR; - } - cipher->recycleKey(secretkey); - CryptoFactory::i()->recycleSymmetricAlgorithm(cipher); - secretValue += encryptedFinal; - } + } + else + { + return CKR_MECHANISM_INVALID; + } + + // If the CKA_VALUE_LEN attribute is not present use computed size + if (byteLen == 0) + { + byteLen = data.size() + keydata.size(); + CK_RV rv = checkKeyLength(keyType, byteLen); + if (rv != CKR_OK) + { + return rv; + } + } + } + else + { + SymmetricAlgorithm *cipher = CryptoFactory::i()->getSymmetricAlgorithm(algo); + if (cipher == NULL) + return CKR_MECHANISM_INVALID; + + SymmetricKey *secretkey = new SymmetricKey(); + + if (getSymmetricKey(secretkey, token, baseKey) != CKR_OK) + { + cipher->recycleKey(secretkey); + CryptoFactory::i()->recycleSymmetricAlgorithm(cipher); + return CKR_GENERAL_ERROR; + } + + // adjust key bit length + secretkey->setBitLen(secretkey->getKeyBits().size() * bb); + + // Initialize encryption + if (!cipher->encryptInit(secretkey, mode, iv, padding)) + { + cipher->recycleKey(secretkey); + CryptoFactory::i()->recycleSymmetricAlgorithm(cipher); + return CKR_MECHANISM_INVALID; + } + + // Encrypt the data + if (!cipher->encryptUpdate(data, secretValue)) + { + cipher->recycleKey(secretkey); + CryptoFactory::i()->recycleSymmetricAlgorithm(cipher); + return CKR_GENERAL_ERROR; + } + + // Finalize encryption + ByteString encryptedFinal; + if (!cipher->encryptFinal(encryptedFinal)) + { + cipher->recycleKey(secretkey); + CryptoFactory::i()->recycleSymmetricAlgorithm(cipher); + return CKR_GENERAL_ERROR; + } + cipher->recycleKey(secretkey); + CryptoFactory::i()->recycleSymmetricAlgorithm(cipher); + secretValue += encryptedFinal; + } // Create the secret object using C_CreateObject const CK_ULONG maxAttribs = 32; CK_OBJECT_CLASS objClass = CKO_SECRET_KEY; CK_ATTRIBUTE secretAttribs[maxAttribs] = { - { CKA_CLASS, &objClass, sizeof(objClass) }, - { CKA_TOKEN, &isOnToken, sizeof(isOnToken) }, - { CKA_PRIVATE, &isPrivate, sizeof(isPrivate) }, - { CKA_KEY_TYPE, &keyType, sizeof(keyType) }, + {CKA_CLASS, &objClass, sizeof(objClass)}, + {CKA_TOKEN, &isOnToken, sizeof(isOnToken)}, + {CKA_PRIVATE, &isPrivate, sizeof(isPrivate)}, + {CKA_KEY_TYPE, &keyType, sizeof(keyType)}, }; CK_ULONG secretAttribsCount = 4; @@ -12285,18 +12539,18 @@ CK_RV SoftHSM::deriveSymmetric CK_RV rv = CKR_OK; if (ulCount > (maxAttribs - secretAttribsCount)) rv = CKR_TEMPLATE_INCONSISTENT; - for (CK_ULONG i=0; i < ulCount && rv == CKR_OK; ++i) + for (CK_ULONG i = 0; i < ulCount && rv == CKR_OK; ++i) { switch (pTemplate[i].type) { - case CKA_CLASS: - case CKA_TOKEN: - case CKA_PRIVATE: - case CKA_KEY_TYPE: - case CKA_CHECK_VALUE: - continue; - default: - secretAttribs[secretAttribsCount++] = pTemplate[i]; + case CKA_CLASS: + case CKA_TOKEN: + case CKA_PRIVATE: + case CKA_KEY_TYPE: + case CKA_CHECK_VALUE: + continue; + default: + secretAttribs[secretAttribsCount++] = pTemplate[i]; } } @@ -12306,17 +12560,21 @@ CK_RV SoftHSM::deriveSymmetric // Store the attributes that are being supplied if (rv == CKR_OK) { - OSObject* osobject = (OSObject*)handleManager->getObject(*phKey); - if (osobject == NULL_PTR || !osobject->isValid()) { + OSObject *osobject = (OSObject *)handleManager->getObject(*phKey); + if (osobject == NULL_PTR || !osobject->isValid()) + { rv = CKR_FUNCTION_FAILED; - } else if (osobject->startTransaction()) { + } + else if (osobject->startTransaction()) + { bool bOK = true; // Common Attributes - bOK = bOK && osobject->setAttribute(CKA_LOCAL,false); + bOK = bOK && osobject->setAttribute(CKA_LOCAL, false); // Common Secret Key Attributes - if (pMechanism->mechanism == CKM_CONCATENATE_BASE_AND_KEY) { + if (pMechanism->mechanism == CKM_CONCATENATE_BASE_AND_KEY) + { // [PKCS#11 v2.40, 2.31.3] // If either of the two original keys has its CKA_SENSITIVE attribute // set to CK_TRUE, so does the derived key. If not, then the derived @@ -12324,7 +12582,8 @@ CK_RV SoftHSM::deriveSymmetric // or from a default value. bool bSensitive = baseKey->getBooleanValue(CKA_SENSITIVE, true) || otherKey->getBooleanValue(CKA_SENSITIVE, true); - if (bSensitive) { + if (bSensitive) + { bOK = bOK && osobject->setAttribute(CKA_SENSITIVE, true); } // If either of the two original keys has its CKA_EXTRACTABLE attribute @@ -12333,7 +12592,8 @@ CK_RV SoftHSM::deriveSymmetric // or from a default value. bool bExtractable = baseKey->getBooleanValue(CKA_EXTRACTABLE, true) && otherKey->getBooleanValue(CKA_EXTRACTABLE, true); - if (!bExtractable) { + if (!bExtractable) + { bOK = bOK && osobject->setAttribute(CKA_EXTRACTABLE, false); } // The derived key’s CKA_ALWAYS_SENSITIVE attribute is set to CK_TRUE @@ -12350,19 +12610,21 @@ CK_RV SoftHSM::deriveSymmetric bOK = bOK && osobject->setAttribute(CKA_ALWAYS_SENSITIVE, bNeverExtractable); } else if (pMechanism->mechanism == CKM_CONCATENATE_BASE_AND_DATA || - pMechanism->mechanism == CKM_CONCATENATE_DATA_AND_BASE) + pMechanism->mechanism == CKM_CONCATENATE_DATA_AND_BASE) { // [PKCS#11 v2.40, 2.31.4-2.31.7] // If the base key has its CKA_SENSITIVE attribute set to CK_TRUE, so does the derived key. // If not, then the derived key’s CKA_SENSITIVE attribute is set either from the supplied // template or from a default value. - if (baseKey->getBooleanValue(CKA_SENSITIVE, true)) { + if (baseKey->getBooleanValue(CKA_SENSITIVE, true)) + { bOK = bOK && osobject->setAttribute(CKA_SENSITIVE, true); } // If the base key has its CKA_EXTRACTABLE attribute set to CK_FALSE, so does the derived key. // If not, then the derived key’s CKA_EXTRACTABLE attribute is set either from the supplied // template or from a default value. - if (!baseKey->getBooleanValue(CKA_EXTRACTABLE, false)) { + if (!baseKey->getBooleanValue(CKA_EXTRACTABLE, false)) + { bOK = bOK && osobject->setAttribute(CKA_EXTRACTABLE, false); } // The derived key’s CKA_ALWAYS_SENSITIVE attribute is set to CK_TRUE if and only @@ -12373,17 +12635,25 @@ CK_RV SoftHSM::deriveSymmetric // if the base key has its CKA_NEVER_EXTRACTABLE attribute set to CK_TRUE. bool bNeverExtractable = baseKey->getBooleanValue(CKA_NEVER_EXTRACTABLE, false); bOK = bOK && osobject->setAttribute(CKA_NEVER_EXTRACTABLE, bNeverExtractable); - } else { - if (baseKey->getBooleanValue(CKA_ALWAYS_SENSITIVE, false)) { + } + else + { + if (baseKey->getBooleanValue(CKA_ALWAYS_SENSITIVE, false)) + { bool bAlwaysSensitive = osobject->getBooleanValue(CKA_SENSITIVE, false); bOK = bOK && osobject->setAttribute(CKA_ALWAYS_SENSITIVE, bAlwaysSensitive); - } else { + } + else + { bOK = bOK && osobject->setAttribute(CKA_ALWAYS_SENSITIVE, false); } - if (baseKey->getBooleanValue(CKA_NEVER_EXTRACTABLE, true)) { + if (baseKey->getBooleanValue(CKA_NEVER_EXTRACTABLE, true)) + { bool bNeverExtractable = osobject->getBooleanValue(CKA_EXTRACTABLE, false) == false; bOK = bOK && osobject->setAttribute(CKA_NEVER_EXTRACTABLE, bNeverExtractable); - } else { + } + else + { bOK = bOK && osobject->setAttribute(CKA_NEVER_EXTRACTABLE, false); } } @@ -12405,8 +12675,8 @@ CK_RV SoftHSM::deriveSymmetric // Fix the odd parity for DES if (keyType == CKK_DES || - keyType == CKK_DES2 || - keyType == CKK_DES3) + keyType == CKK_DES2 || + keyType == CKK_DES3) { for (size_t i = 0; i < secretValue.size(); i++) { @@ -12415,27 +12685,27 @@ CK_RV SoftHSM::deriveSymmetric } // Get the KCV - SymmetricKey* secret = new SymmetricKey(); + SymmetricKey *secret = new SymmetricKey(); secret->setKeyBits(secretValue); switch (keyType) { - case CKK_GENERIC_SECRET: - secret->setBitLen(byteLen * 8); - plainKCV = secret->getKeyCheckValue(); - break; - case CKK_DES: - case CKK_DES2: - case CKK_DES3: - secret->setBitLen(byteLen * 7); - plainKCV = ((DESKey*)secret)->getKeyCheckValue(); - break; - case CKK_AES: - secret->setBitLen(byteLen * 8); - plainKCV = ((AESKey*)secret)->getKeyCheckValue(); - break; - default: - bOK = false; - break; + case CKK_GENERIC_SECRET: + secret->setBitLen(byteLen * 8); + plainKCV = secret->getKeyCheckValue(); + break; + case CKK_DES: + case CKK_DES2: + case CKK_DES3: + secret->setBitLen(byteLen * 7); + plainKCV = ((DESKey *)secret)->getKeyCheckValue(); + break; + case CKK_AES: + secret->setBitLen(byteLen * 8); + plainKCV = ((AESKey *)secret)->getKeyCheckValue(); + break; + default: + bOK = false; + break; } delete secret; @@ -12461,7 +12731,8 @@ CK_RV SoftHSM::deriveSymmetric if (!bOK) rv = CKR_FUNCTION_FAILED; - } else + } + else rv = CKR_FUNCTION_FAILED; } @@ -12470,9 +12741,10 @@ CK_RV SoftHSM::deriveSymmetric { if (*phKey != CK_INVALID_HANDLE) { - OSObject* ossecret = (OSObject*)handleManager->getObject(*phKey); + OSObject *ossecret = (OSObject *)handleManager->getObject(*phKey); handleManager->destroyObject(*phKey); - if (ossecret) ossecret->destroyObject(); + if (ossecret) + ossecret->destroyObject(); *phKey = CK_INVALID_HANDLE; } } @@ -12482,22 +12754,28 @@ CK_RV SoftHSM::deriveSymmetric CK_RV SoftHSM::CreateObject(CK_SESSION_HANDLE hSession, CK_ATTRIBUTE_PTR pTemplate, CK_ULONG ulCount, CK_OBJECT_HANDLE_PTR phObject, int op) { - if (!isInitialised) return CKR_CRYPTOKI_NOT_INITIALIZED; + if (!isInitialised) + return CKR_CRYPTOKI_NOT_INITIALIZED; - if (pTemplate == NULL_PTR) return CKR_ARGUMENTS_BAD; - if (phObject == NULL_PTR) return CKR_ARGUMENTS_BAD; + if (pTemplate == NULL_PTR) + return CKR_ARGUMENTS_BAD; + if (phObject == NULL_PTR) + return CKR_ARGUMENTS_BAD; // Get the session - Session* session = (Session*)handleManager->getSession(hSession); - if (session == NULL) return CKR_SESSION_HANDLE_INVALID; + Session *session = (Session *)handleManager->getSession(hSession); + if (session == NULL) + return CKR_SESSION_HANDLE_INVALID; // Get the slot - Slot* slot = session->getSlot(); - if (slot == NULL_PTR) return CKR_GENERAL_ERROR; + Slot *slot = session->getSlot(); + if (slot == NULL_PTR) + return CKR_GENERAL_ERROR; // Get the token - Token* token = session->getToken(); - if (token == NULL_PTR) return CKR_GENERAL_ERROR; + Token *token = session->getToken(); + if (token == NULL_PTR) + return CKR_GENERAL_ERROR; // Extract information from the template that is needed to create the object. CK_OBJECT_CLASS objClass = CKO_DATA; @@ -12506,7 +12784,7 @@ CK_RV SoftHSM::CreateObject(CK_SESSION_HANDLE hSession, CK_ATTRIBUTE_PTR pTempla CK_BBOOL isOnToken = CK_FALSE; CK_BBOOL isPrivate = CK_TRUE; bool isImplicit = false; - CK_RV rv = extractObjectInformation(pTemplate,ulCount,objClass,keyType,certType, isOnToken, isPrivate, isImplicit); + CK_RV rv = extractObjectInformation(pTemplate, ulCount, objClass, keyType, certType, isOnToken, isPrivate, isImplicit); if (rv != CKR_OK) { ERROR_MSG("Mandatory attribute not present in template"); @@ -12535,24 +12813,24 @@ CK_RV SoftHSM::CreateObject(CK_SESSION_HANDLE hSession, CK_ATTRIBUTE_PTR pTempla { return CKR_TEMPLATE_INCONSISTENT; } - for (CK_ULONG i=0; i < ulCount; i++) + for (CK_ULONG i = 0; i < ulCount; i++) { switch (pTemplate[i].type) { - case CKA_CHECK_VALUE: - saveAttribs[saveAttribsCount++] = pTemplate[i]; - break; - default: - attribs[attribsCount++] = pTemplate[i]; + case CKA_CHECK_VALUE: + saveAttribs[saveAttribsCount++] = pTemplate[i]; + break; + default: + attribs[attribsCount++] = pTemplate[i]; } } - for (CK_ULONG i=0; i < saveAttribsCount; i++) + for (CK_ULONG i = 0; i < saveAttribsCount; i++) { attribs[attribsCount++] = saveAttribs[i]; } - P11Object* p11object = NULL; - rv = newP11Object(objClass,keyType,certType,&p11object); + P11Object *p11object = NULL; + rv = newP11Object(objClass, keyType, certType, &p11object); if (rv != CKR_OK) return rv; @@ -12560,7 +12838,7 @@ CK_RV SoftHSM::CreateObject(CK_SESSION_HANDLE hSession, CK_ATTRIBUTE_PTR pTempla OSObject *object = NULL_PTR; if (isOnToken) { - object = (OSObject*) token->createObject(); + object = (OSObject *)token->createObject(); } else { @@ -12573,7 +12851,7 @@ CK_RV SoftHSM::CreateObject(CK_SESSION_HANDLE hSession, CK_ATTRIBUTE_PTR pTempla return CKR_GENERAL_ERROR; } - rv = p11object->saveTemplate(token, isPrivate != CK_FALSE, attribs,attribsCount,op); + rv = p11object->saveTemplate(token, isPrivate != CK_FALSE, attribs, attribsCount, op); delete p11object; if (rv != CKR_OK) return rv; @@ -12581,19 +12859,19 @@ CK_RV SoftHSM::CreateObject(CK_SESSION_HANDLE hSession, CK_ATTRIBUTE_PTR pTempla if (op == OBJECT_OP_CREATE) { if (objClass == CKO_PUBLIC_KEY && - (!object->startTransaction() || - !object->setAttribute(CKA_LOCAL, false) || - !object->commitTransaction())) + (!object->startTransaction() || + !object->setAttribute(CKA_LOCAL, false) || + !object->commitTransaction())) { return CKR_GENERAL_ERROR; } if ((objClass == CKO_SECRET_KEY || objClass == CKO_PRIVATE_KEY) && - (!object->startTransaction() || - !object->setAttribute(CKA_LOCAL, false) || - !object->setAttribute(CKA_ALWAYS_SENSITIVE, false) || - !object->setAttribute(CKA_NEVER_EXTRACTABLE, false) || - !object->commitTransaction())) + (!object->startTransaction() || + !object->setAttribute(CKA_LOCAL, false) || + !object->setAttribute(CKA_ALWAYS_SENSITIVE, false) || + !object->setAttribute(CKA_NEVER_EXTRACTABLE, false) || + !object->commitTransaction())) { return CKR_GENERAL_ERROR; } @@ -12602,18 +12880,23 @@ CK_RV SoftHSM::CreateObject(CK_SESSION_HANDLE hSession, CK_ATTRIBUTE_PTR pTempla if (isOnToken) { *phObject = handleManager->addTokenObject(slot->getSlotID(), isPrivate != CK_FALSE, object); - } else { + } + else + { *phObject = handleManager->addSessionObject(slot->getSlotID(), hSession, isPrivate != CK_FALSE, object); } return CKR_OK; } -CK_RV SoftHSM::getRSAPrivateKey(RSAPrivateKey* privateKey, Token* token, OSObject* key) +CK_RV SoftHSM::getRSAPrivateKey(RSAPrivateKey *privateKey, Token *token, OSObject *key) { - if (privateKey == NULL) return CKR_ARGUMENTS_BAD; - if (token == NULL) return CKR_ARGUMENTS_BAD; - if (key == NULL) return CKR_ARGUMENTS_BAD; + if (privateKey == NULL) + return CKR_ARGUMENTS_BAD; + if (token == NULL) + return CKR_ARGUMENTS_BAD; + if (key == NULL) + return CKR_ARGUMENTS_BAD; // Get the CKA_PRIVATE attribute, when the attribute is not present use default false bool isKeyPrivate = key->getBooleanValue(CKA_PRIVATE, false); @@ -12648,7 +12931,7 @@ CK_RV SoftHSM::getRSAPrivateKey(RSAPrivateKey* privateKey, Token* token, OSObjec privateExponent = key->getByteStringValue(CKA_PRIVATE_EXPONENT); prime1 = key->getByteStringValue(CKA_PRIME_1); prime2 = key->getByteStringValue(CKA_PRIME_2); - exponent1 = key->getByteStringValue(CKA_EXPONENT_1); + exponent1 = key->getByteStringValue(CKA_EXPONENT_1); exponent2 = key->getByteStringValue(CKA_EXPONENT_2); coefficient = key->getByteStringValue(CKA_COEFFICIENT); } @@ -12665,11 +12948,14 @@ CK_RV SoftHSM::getRSAPrivateKey(RSAPrivateKey* privateKey, Token* token, OSObjec return CKR_OK; } -CK_RV SoftHSM::getRSAPublicKey(RSAPublicKey* publicKey, Token* token, OSObject* key) +CK_RV SoftHSM::getRSAPublicKey(RSAPublicKey *publicKey, Token *token, OSObject *key) { - if (publicKey == NULL) return CKR_ARGUMENTS_BAD; - if (token == NULL) return CKR_ARGUMENTS_BAD; - if (key == NULL) return CKR_ARGUMENTS_BAD; + if (publicKey == NULL) + return CKR_ARGUMENTS_BAD; + if (token == NULL) + return CKR_ARGUMENTS_BAD; + if (key == NULL) + return CKR_ARGUMENTS_BAD; // Get the CKA_PRIVATE attribute, when the attribute is not present use default false bool isKeyPrivate = key->getBooleanValue(CKA_PRIVATE, false); @@ -12697,11 +12983,14 @@ CK_RV SoftHSM::getRSAPublicKey(RSAPublicKey* publicKey, Token* token, OSObject* return CKR_OK; } -CK_RV SoftHSM::getDSAPrivateKey(DSAPrivateKey* privateKey, Token* token, OSObject* key) +CK_RV SoftHSM::getDSAPrivateKey(DSAPrivateKey *privateKey, Token *token, OSObject *key) { - if (privateKey == NULL) return CKR_ARGUMENTS_BAD; - if (token == NULL) return CKR_ARGUMENTS_BAD; - if (key == NULL) return CKR_ARGUMENTS_BAD; + if (privateKey == NULL) + return CKR_ARGUMENTS_BAD; + if (token == NULL) + return CKR_ARGUMENTS_BAD; + if (key == NULL) + return CKR_ARGUMENTS_BAD; // Get the CKA_PRIVATE attribute, when the attribute is not present use default false bool isKeyPrivate = key->getBooleanValue(CKA_PRIVATE, false); @@ -12737,11 +13026,14 @@ CK_RV SoftHSM::getDSAPrivateKey(DSAPrivateKey* privateKey, Token* token, OSObjec return CKR_OK; } -CK_RV SoftHSM::getDSAPublicKey(DSAPublicKey* publicKey, Token* token, OSObject* key) +CK_RV SoftHSM::getDSAPublicKey(DSAPublicKey *publicKey, Token *token, OSObject *key) { - if (publicKey == NULL) return CKR_ARGUMENTS_BAD; - if (token == NULL) return CKR_ARGUMENTS_BAD; - if (key == NULL) return CKR_ARGUMENTS_BAD; + if (publicKey == NULL) + return CKR_ARGUMENTS_BAD; + if (token == NULL) + return CKR_ARGUMENTS_BAD; + if (key == NULL) + return CKR_ARGUMENTS_BAD; // Get the CKA_PRIVATE attribute, when the attribute is not present use default false bool isKeyPrivate = key->getBooleanValue(CKA_PRIVATE, false); @@ -12777,11 +13069,14 @@ CK_RV SoftHSM::getDSAPublicKey(DSAPublicKey* publicKey, Token* token, OSObject* return CKR_OK; } -CK_RV SoftHSM::getECPrivateKey(ECPrivateKey* privateKey, Token* token, OSObject* key) +CK_RV SoftHSM::getECPrivateKey(ECPrivateKey *privateKey, Token *token, OSObject *key) { - if (privateKey == NULL) return CKR_ARGUMENTS_BAD; - if (token == NULL) return CKR_ARGUMENTS_BAD; - if (key == NULL) return CKR_ARGUMENTS_BAD; + if (privateKey == NULL) + return CKR_ARGUMENTS_BAD; + if (token == NULL) + return CKR_ARGUMENTS_BAD; + if (key == NULL) + return CKR_ARGUMENTS_BAD; // Get the CKA_PRIVATE attribute, when the attribute is not present use default false bool isKeyPrivate = key->getBooleanValue(CKA_PRIVATE, false); @@ -12809,11 +13104,14 @@ CK_RV SoftHSM::getECPrivateKey(ECPrivateKey* privateKey, Token* token, OSObject* return CKR_OK; } -CK_RV SoftHSM::getECPublicKey(ECPublicKey* publicKey, Token* token, OSObject* key) +CK_RV SoftHSM::getECPublicKey(ECPublicKey *publicKey, Token *token, OSObject *key) { - if (publicKey == NULL) return CKR_ARGUMENTS_BAD; - if (token == NULL) return CKR_ARGUMENTS_BAD; - if (key == NULL) return CKR_ARGUMENTS_BAD; + if (publicKey == NULL) + return CKR_ARGUMENTS_BAD; + if (token == NULL) + return CKR_ARGUMENTS_BAD; + if (key == NULL) + return CKR_ARGUMENTS_BAD; // Get the CKA_PRIVATE attribute, when the attribute is not present use default false bool isKeyPrivate = key->getBooleanValue(CKA_PRIVATE, false); @@ -12841,11 +13139,14 @@ CK_RV SoftHSM::getECPublicKey(ECPublicKey* publicKey, Token* token, OSObject* ke return CKR_OK; } -CK_RV SoftHSM::getEDPrivateKey(EDPrivateKey* privateKey, Token* token, OSObject* key) +CK_RV SoftHSM::getEDPrivateKey(EDPrivateKey *privateKey, Token *token, OSObject *key) { - if (privateKey == NULL) return CKR_ARGUMENTS_BAD; - if (token == NULL) return CKR_ARGUMENTS_BAD; - if (key == NULL) return CKR_ARGUMENTS_BAD; + if (privateKey == NULL) + return CKR_ARGUMENTS_BAD; + if (token == NULL) + return CKR_ARGUMENTS_BAD; + if (key == NULL) + return CKR_ARGUMENTS_BAD; // Get the CKA_PRIVATE attribute, when the attribute is not present use default false bool isKeyPrivate = key->getBooleanValue(CKA_PRIVATE, false); @@ -12873,11 +13174,14 @@ CK_RV SoftHSM::getEDPrivateKey(EDPrivateKey* privateKey, Token* token, OSObject* return CKR_OK; } -CK_RV SoftHSM::getEDPublicKey(EDPublicKey* publicKey, Token* token, OSObject* key) +CK_RV SoftHSM::getEDPublicKey(EDPublicKey *publicKey, Token *token, OSObject *key) { - if (publicKey == NULL) return CKR_ARGUMENTS_BAD; - if (token == NULL) return CKR_ARGUMENTS_BAD; - if (key == NULL) return CKR_ARGUMENTS_BAD; + if (publicKey == NULL) + return CKR_ARGUMENTS_BAD; + if (token == NULL) + return CKR_ARGUMENTS_BAD; + if (key == NULL) + return CKR_ARGUMENTS_BAD; // Get the CKA_PRIVATE attribute, when the attribute is not present use default false bool isKeyPrivate = key->getBooleanValue(CKA_PRIVATE, false); @@ -12905,11 +13209,14 @@ CK_RV SoftHSM::getEDPublicKey(EDPublicKey* publicKey, Token* token, OSObject* ke return CKR_OK; } -CK_RV SoftHSM::getDHPrivateKey(DHPrivateKey* privateKey, Token* token, OSObject* key) +CK_RV SoftHSM::getDHPrivateKey(DHPrivateKey *privateKey, Token *token, OSObject *key) { - if (privateKey == NULL) return CKR_ARGUMENTS_BAD; - if (token == NULL) return CKR_ARGUMENTS_BAD; - if (key == NULL) return CKR_ARGUMENTS_BAD; + if (privateKey == NULL) + return CKR_ARGUMENTS_BAD; + if (token == NULL) + return CKR_ARGUMENTS_BAD; + if (key == NULL) + return CKR_ARGUMENTS_BAD; // Get the CKA_PRIVATE attribute, when the attribute is not present use default false bool isKeyPrivate = key->getBooleanValue(CKA_PRIVATE, false); @@ -12941,10 +13248,12 @@ CK_RV SoftHSM::getDHPrivateKey(DHPrivateKey* privateKey, Token* token, OSObject* return CKR_OK; } -CK_RV SoftHSM::getDHPublicKey(DHPublicKey* publicKey, DHPrivateKey* privateKey, ByteString& pubParams) +CK_RV SoftHSM::getDHPublicKey(DHPublicKey *publicKey, DHPrivateKey *privateKey, ByteString &pubParams) { - if (publicKey == NULL) return CKR_ARGUMENTS_BAD; - if (privateKey == NULL) return CKR_ARGUMENTS_BAD; + if (publicKey == NULL) + return CKR_ARGUMENTS_BAD; + if (privateKey == NULL) + return CKR_ARGUMENTS_BAD; // Copy Domain Parameters from Private Key publicKey->setP(privateKey->getP()); @@ -12956,10 +13265,12 @@ CK_RV SoftHSM::getDHPublicKey(DHPublicKey* publicKey, DHPrivateKey* privateKey, return CKR_OK; } -CK_RV SoftHSM::getECDHPublicKey(ECPublicKey* publicKey, ECPrivateKey* privateKey, ByteString& pubData) +CK_RV SoftHSM::getECDHPublicKey(ECPublicKey *publicKey, ECPrivateKey *privateKey, ByteString &pubData) { - if (publicKey == NULL) return CKR_ARGUMENTS_BAD; - if (privateKey == NULL) return CKR_ARGUMENTS_BAD; + if (publicKey == NULL) + return CKR_ARGUMENTS_BAD; + if (privateKey == NULL) + return CKR_ARGUMENTS_BAD; // Copy Domain Parameters from Private Key publicKey->setEC(privateKey->getEC()); @@ -12971,10 +13282,12 @@ CK_RV SoftHSM::getECDHPublicKey(ECPublicKey* publicKey, ECPrivateKey* privateKey return CKR_OK; } -CK_RV SoftHSM::getEDDHPublicKey(EDPublicKey* publicKey, EDPrivateKey* privateKey, ByteString& pubData) +CK_RV SoftHSM::getEDDHPublicKey(EDPublicKey *publicKey, EDPrivateKey *privateKey, ByteString &pubData) { - if (publicKey == NULL) return CKR_ARGUMENTS_BAD; - if (privateKey == NULL) return CKR_ARGUMENTS_BAD; + if (publicKey == NULL) + return CKR_ARGUMENTS_BAD; + if (privateKey == NULL) + return CKR_ARGUMENTS_BAD; // Copy Domain Parameters from Private Key publicKey->setEC(privateKey->getEC()); @@ -12988,7 +13301,7 @@ CK_RV SoftHSM::getEDDHPublicKey(EDPublicKey* publicKey, EDPrivateKey* privateKey // ECDH pubData can be in RAW or DER format. // Need to convert RAW as SoftHSM uses DER. -ByteString SoftHSM::getECDHPubData(ByteString& pubData) +ByteString SoftHSM::getECDHPubData(ByteString &pubData) { size_t len = pubData.size(); size_t controlOctets = 2; @@ -13007,7 +13320,8 @@ ByteString SoftHSM::getECDHPubData(ByteString& pubData) else if (pubData[1] < 0x80) { // Raw: Length octet does not match remaining data length - if (pubData[1] != (len - controlOctets)) controlOctets = 0; + if (pubData[1] != (len - controlOctets)) + controlOctets = 0; } else { @@ -13032,16 +13346,20 @@ ByteString SoftHSM::getECDHPubData(ByteString& pubData) } // DER format - if (controlOctets != 0) return pubData; + if (controlOctets != 0) + return pubData; return DERUTIL::raw2Octet(pubData); } -CK_RV SoftHSM::getGOSTPrivateKey(GOSTPrivateKey* privateKey, Token* token, OSObject* key) +CK_RV SoftHSM::getGOSTPrivateKey(GOSTPrivateKey *privateKey, Token *token, OSObject *key) { - if (privateKey == NULL) return CKR_ARGUMENTS_BAD; - if (token == NULL) return CKR_ARGUMENTS_BAD; - if (key == NULL) return CKR_ARGUMENTS_BAD; + if (privateKey == NULL) + return CKR_ARGUMENTS_BAD; + if (token == NULL) + return CKR_ARGUMENTS_BAD; + if (key == NULL) + return CKR_ARGUMENTS_BAD; // Get the CKA_PRIVATE attribute, when the attribute is not present use default false bool isKeyPrivate = key->getBooleanValue(CKA_PRIVATE, false); @@ -13069,11 +13387,14 @@ CK_RV SoftHSM::getGOSTPrivateKey(GOSTPrivateKey* privateKey, Token* token, OSObj return CKR_OK; } -CK_RV SoftHSM::getGOSTPublicKey(GOSTPublicKey* publicKey, Token* token, OSObject* key) +CK_RV SoftHSM::getGOSTPublicKey(GOSTPublicKey *publicKey, Token *token, OSObject *key) { - if (publicKey == NULL) return CKR_ARGUMENTS_BAD; - if (token == NULL) return CKR_ARGUMENTS_BAD; - if (key == NULL) return CKR_ARGUMENTS_BAD; + if (publicKey == NULL) + return CKR_ARGUMENTS_BAD; + if (token == NULL) + return CKR_ARGUMENTS_BAD; + if (key == NULL) + return CKR_ARGUMENTS_BAD; // Get the CKA_PRIVATE attribute, when the attribute is not present use default false bool isKeyPrivate = key->getBooleanValue(CKA_PRIVATE, false); @@ -13101,11 +13422,14 @@ CK_RV SoftHSM::getGOSTPublicKey(GOSTPublicKey* publicKey, Token* token, OSObject return CKR_OK; } -CK_RV SoftHSM::getSymmetricKey(SymmetricKey* skey, Token* token, OSObject* key) +CK_RV SoftHSM::getSymmetricKey(SymmetricKey *skey, Token *token, OSObject *key) { - if (skey == NULL) return CKR_ARGUMENTS_BAD; - if (token == NULL) return CKR_ARGUMENTS_BAD; - if (key == NULL) return CKR_ARGUMENTS_BAD; + if (skey == NULL) + return CKR_ARGUMENTS_BAD; + if (token == NULL) + return CKR_ARGUMENTS_BAD; + if (key == NULL) + return CKR_ARGUMENTS_BAD; // Get the CKA_PRIVATE attribute, when the attribute is not present use default false bool isKeyPrivate = key->getBooleanValue(CKA_PRIVATE, false); @@ -13126,12 +13450,12 @@ CK_RV SoftHSM::getSymmetricKey(SymmetricKey* skey, Token* token, OSObject* key) return CKR_OK; } -bool SoftHSM::setRSAPrivateKey(OSObject* key, const ByteString &ber, Token* token, bool isPrivate) const +bool SoftHSM::setRSAPrivateKey(OSObject *key, const ByteString &ber, Token *token, bool isPrivate) const { - AsymmetricAlgorithm* rsa = CryptoFactory::i()->getAsymmetricAlgorithm(AsymAlgo::RSA); + AsymmetricAlgorithm *rsa = CryptoFactory::i()->getAsymmetricAlgorithm(AsymAlgo::RSA); if (rsa == NULL) return false; - PrivateKey* priv = rsa->newPrivateKey(); + PrivateKey *priv = rsa->newPrivateKey(); if (priv == NULL) { CryptoFactory::i()->recycleAsymmetricAlgorithm(rsa); @@ -13154,25 +13478,25 @@ bool SoftHSM::setRSAPrivateKey(OSObject* key, const ByteString &ber, Token* toke ByteString coefficient; if (isPrivate) { - token->encrypt(((RSAPrivateKey*)priv)->getN(), modulus); - token->encrypt(((RSAPrivateKey*)priv)->getE(), publicExponent); - token->encrypt(((RSAPrivateKey*)priv)->getD(), privateExponent); - token->encrypt(((RSAPrivateKey*)priv)->getP(), prime1); - token->encrypt(((RSAPrivateKey*)priv)->getQ(), prime2); - token->encrypt(((RSAPrivateKey*)priv)->getDP1(), exponent1); - token->encrypt(((RSAPrivateKey*)priv)->getDQ1(), exponent2); - token->encrypt(((RSAPrivateKey*)priv)->getPQ(), coefficient); + token->encrypt(((RSAPrivateKey *)priv)->getN(), modulus); + token->encrypt(((RSAPrivateKey *)priv)->getE(), publicExponent); + token->encrypt(((RSAPrivateKey *)priv)->getD(), privateExponent); + token->encrypt(((RSAPrivateKey *)priv)->getP(), prime1); + token->encrypt(((RSAPrivateKey *)priv)->getQ(), prime2); + token->encrypt(((RSAPrivateKey *)priv)->getDP1(), exponent1); + token->encrypt(((RSAPrivateKey *)priv)->getDQ1(), exponent2); + token->encrypt(((RSAPrivateKey *)priv)->getPQ(), coefficient); } else { - modulus = ((RSAPrivateKey*)priv)->getN(); - publicExponent = ((RSAPrivateKey*)priv)->getE(); - privateExponent = ((RSAPrivateKey*)priv)->getD(); - prime1 = ((RSAPrivateKey*)priv)->getP(); - prime2 = ((RSAPrivateKey*)priv)->getQ(); - exponent1 = ((RSAPrivateKey*)priv)->getDP1(); - exponent2 = ((RSAPrivateKey*)priv)->getDQ1(); - coefficient = ((RSAPrivateKey*)priv)->getPQ(); + modulus = ((RSAPrivateKey *)priv)->getN(); + publicExponent = ((RSAPrivateKey *)priv)->getE(); + privateExponent = ((RSAPrivateKey *)priv)->getD(); + prime1 = ((RSAPrivateKey *)priv)->getP(); + prime2 = ((RSAPrivateKey *)priv)->getQ(); + exponent1 = ((RSAPrivateKey *)priv)->getDP1(); + exponent2 = ((RSAPrivateKey *)priv)->getDQ1(); + coefficient = ((RSAPrivateKey *)priv)->getPQ(); } bool bOK = true; bOK = bOK && key->setAttribute(CKA_MODULUS, modulus); @@ -13180,7 +13504,7 @@ bool SoftHSM::setRSAPrivateKey(OSObject* key, const ByteString &ber, Token* toke bOK = bOK && key->setAttribute(CKA_PRIVATE_EXPONENT, privateExponent); bOK = bOK && key->setAttribute(CKA_PRIME_1, prime1); bOK = bOK && key->setAttribute(CKA_PRIME_2, prime2); - bOK = bOK && key->setAttribute(CKA_EXPONENT_1,exponent1); + bOK = bOK && key->setAttribute(CKA_EXPONENT_1, exponent1); bOK = bOK && key->setAttribute(CKA_EXPONENT_2, exponent2); bOK = bOK && key->setAttribute(CKA_COEFFICIENT, coefficient); @@ -13190,12 +13514,12 @@ bool SoftHSM::setRSAPrivateKey(OSObject* key, const ByteString &ber, Token* toke return bOK; } -bool SoftHSM::setDSAPrivateKey(OSObject* key, const ByteString &ber, Token* token, bool isPrivate) const +bool SoftHSM::setDSAPrivateKey(OSObject *key, const ByteString &ber, Token *token, bool isPrivate) const { - AsymmetricAlgorithm* dsa = CryptoFactory::i()->getAsymmetricAlgorithm(AsymAlgo::DSA); + AsymmetricAlgorithm *dsa = CryptoFactory::i()->getAsymmetricAlgorithm(AsymAlgo::DSA); if (dsa == NULL) return false; - PrivateKey* priv = dsa->newPrivateKey(); + PrivateKey *priv = dsa->newPrivateKey(); if (priv == NULL) { CryptoFactory::i()->recycleAsymmetricAlgorithm(dsa); @@ -13214,17 +13538,17 @@ bool SoftHSM::setDSAPrivateKey(OSObject* key, const ByteString &ber, Token* toke ByteString value; if (isPrivate) { - token->encrypt(((DSAPrivateKey*)priv)->getP(), prime); - token->encrypt(((DSAPrivateKey*)priv)->getQ(), subprime); - token->encrypt(((DSAPrivateKey*)priv)->getG(), generator); - token->encrypt(((DSAPrivateKey*)priv)->getX(), value); + token->encrypt(((DSAPrivateKey *)priv)->getP(), prime); + token->encrypt(((DSAPrivateKey *)priv)->getQ(), subprime); + token->encrypt(((DSAPrivateKey *)priv)->getG(), generator); + token->encrypt(((DSAPrivateKey *)priv)->getX(), value); } else { - prime = ((DSAPrivateKey*)priv)->getP(); - subprime = ((DSAPrivateKey*)priv)->getQ(); - generator = ((DSAPrivateKey*)priv)->getG(); - value = ((DSAPrivateKey*)priv)->getX(); + prime = ((DSAPrivateKey *)priv)->getP(); + subprime = ((DSAPrivateKey *)priv)->getQ(); + generator = ((DSAPrivateKey *)priv)->getG(); + value = ((DSAPrivateKey *)priv)->getX(); } bool bOK = true; bOK = bOK && key->setAttribute(CKA_PRIME, prime); @@ -13238,12 +13562,12 @@ bool SoftHSM::setDSAPrivateKey(OSObject* key, const ByteString &ber, Token* toke return bOK; } -bool SoftHSM::setDHPrivateKey(OSObject* key, const ByteString &ber, Token* token, bool isPrivate) const +bool SoftHSM::setDHPrivateKey(OSObject *key, const ByteString &ber, Token *token, bool isPrivate) const { - AsymmetricAlgorithm* dh = CryptoFactory::i()->getAsymmetricAlgorithm(AsymAlgo::DH); + AsymmetricAlgorithm *dh = CryptoFactory::i()->getAsymmetricAlgorithm(AsymAlgo::DH); if (dh == NULL) return false; - PrivateKey* priv = dh->newPrivateKey(); + PrivateKey *priv = dh->newPrivateKey(); if (priv == NULL) { CryptoFactory::i()->recycleAsymmetricAlgorithm(dh); @@ -13261,15 +13585,15 @@ bool SoftHSM::setDHPrivateKey(OSObject* key, const ByteString &ber, Token* token ByteString value; if (isPrivate) { - token->encrypt(((DHPrivateKey*)priv)->getP(), prime); - token->encrypt(((DHPrivateKey*)priv)->getG(), generator); - token->encrypt(((DHPrivateKey*)priv)->getX(), value); + token->encrypt(((DHPrivateKey *)priv)->getP(), prime); + token->encrypt(((DHPrivateKey *)priv)->getG(), generator); + token->encrypt(((DHPrivateKey *)priv)->getX(), value); } else { - prime = ((DHPrivateKey*)priv)->getP(); - generator = ((DHPrivateKey*)priv)->getG(); - value = ((DHPrivateKey*)priv)->getX(); + prime = ((DHPrivateKey *)priv)->getP(); + generator = ((DHPrivateKey *)priv)->getG(); + value = ((DHPrivateKey *)priv)->getX(); } bool bOK = true; bOK = bOK && key->setAttribute(CKA_PRIME, prime); @@ -13282,12 +13606,12 @@ bool SoftHSM::setDHPrivateKey(OSObject* key, const ByteString &ber, Token* token return bOK; } -bool SoftHSM::setECPrivateKey(OSObject* key, const ByteString &ber, Token* token, bool isPrivate) const +bool SoftHSM::setECPrivateKey(OSObject *key, const ByteString &ber, Token *token, bool isPrivate) const { - AsymmetricAlgorithm* ecc = CryptoFactory::i()->getAsymmetricAlgorithm(AsymAlgo::ECDSA); + AsymmetricAlgorithm *ecc = CryptoFactory::i()->getAsymmetricAlgorithm(AsymAlgo::ECDSA); if (ecc == NULL) return false; - PrivateKey* priv = ecc->newPrivateKey(); + PrivateKey *priv = ecc->newPrivateKey(); if (priv == NULL) { CryptoFactory::i()->recycleAsymmetricAlgorithm(ecc); @@ -13304,13 +13628,13 @@ bool SoftHSM::setECPrivateKey(OSObject* key, const ByteString &ber, Token* token ByteString value; if (isPrivate) { - token->encrypt(((ECPrivateKey*)priv)->getEC(), group); - token->encrypt(((ECPrivateKey*)priv)->getD(), value); + token->encrypt(((ECPrivateKey *)priv)->getEC(), group); + token->encrypt(((ECPrivateKey *)priv)->getD(), value); } else { - group = ((ECPrivateKey*)priv)->getEC(); - value = ((ECPrivateKey*)priv)->getD(); + group = ((ECPrivateKey *)priv)->getEC(); + value = ((ECPrivateKey *)priv)->getD(); } bool bOK = true; bOK = bOK && key->setAttribute(CKA_EC_PARAMS, group); @@ -13322,12 +13646,12 @@ bool SoftHSM::setECPrivateKey(OSObject* key, const ByteString &ber, Token* token return bOK; } -bool SoftHSM::setEDPrivateKey(OSObject* key, const ByteString &ber, Token* token, bool isPrivate) const +bool SoftHSM::setEDPrivateKey(OSObject *key, const ByteString &ber, Token *token, bool isPrivate) const { - AsymmetricAlgorithm* ecc = CryptoFactory::i()->getAsymmetricAlgorithm(AsymAlgo::EDDSA); + AsymmetricAlgorithm *ecc = CryptoFactory::i()->getAsymmetricAlgorithm(AsymAlgo::EDDSA); if (ecc == NULL) return false; - PrivateKey* priv = ecc->newPrivateKey(); + PrivateKey *priv = ecc->newPrivateKey(); if (priv == NULL) { CryptoFactory::i()->recycleAsymmetricAlgorithm(ecc); @@ -13344,13 +13668,13 @@ bool SoftHSM::setEDPrivateKey(OSObject* key, const ByteString &ber, Token* token ByteString value; if (isPrivate) { - token->encrypt(((EDPrivateKey*)priv)->getEC(), group); - token->encrypt(((EDPrivateKey*)priv)->getK(), value); + token->encrypt(((EDPrivateKey *)priv)->getEC(), group); + token->encrypt(((EDPrivateKey *)priv)->getK(), value); } else { - group = ((EDPrivateKey*)priv)->getEC(); - value = ((EDPrivateKey*)priv)->getK(); + group = ((EDPrivateKey *)priv)->getEC(); + value = ((EDPrivateKey *)priv)->getK(); } bool bOK = true; bOK = bOK && key->setAttribute(CKA_EC_PARAMS, group); @@ -13362,12 +13686,12 @@ bool SoftHSM::setEDPrivateKey(OSObject* key, const ByteString &ber, Token* token return bOK; } -bool SoftHSM::setGOSTPrivateKey(OSObject* key, const ByteString &ber, Token* token, bool isPrivate) const +bool SoftHSM::setGOSTPrivateKey(OSObject *key, const ByteString &ber, Token *token, bool isPrivate) const { - AsymmetricAlgorithm* gost = CryptoFactory::i()->getAsymmetricAlgorithm(AsymAlgo::GOST); + AsymmetricAlgorithm *gost = CryptoFactory::i()->getAsymmetricAlgorithm(AsymAlgo::GOST); if (gost == NULL) return false; - PrivateKey* priv = gost->newPrivateKey(); + PrivateKey *priv = gost->newPrivateKey(); if (priv == NULL) { CryptoFactory::i()->recycleAsymmetricAlgorithm(gost); @@ -13384,13 +13708,13 @@ bool SoftHSM::setGOSTPrivateKey(OSObject* key, const ByteString &ber, Token* tok ByteString param_a; if (isPrivate) { - token->encrypt(((GOSTPrivateKey*)priv)->getD(), value); - token->encrypt(((GOSTPrivateKey*)priv)->getEC(), param_a); + token->encrypt(((GOSTPrivateKey *)priv)->getD(), value); + token->encrypt(((GOSTPrivateKey *)priv)->getEC(), param_a); } else { - value = ((GOSTPrivateKey*)priv)->getD(); - param_a = ((GOSTPrivateKey*)priv)->getEC(); + value = ((GOSTPrivateKey *)priv)->getD(); + param_a = ((GOSTPrivateKey *)priv)->getEC(); } bool bOK = true; bOK = bOK && key->setAttribute(CKA_VALUE, value); @@ -13405,25 +13729,26 @@ bool SoftHSM::setGOSTPrivateKey(OSObject* key, const ByteString &ber, Token* tok CK_RV SoftHSM::MechParamCheckRSAPKCSOAEP(CK_MECHANISM_PTR pMechanism) { // This is a programming error - if (pMechanism->mechanism != CKM_RSA_PKCS_OAEP) { + if (pMechanism->mechanism != CKM_RSA_PKCS_OAEP) + { ERROR_MSG("MechParamCheckRSAPKCSOAEP called on wrong mechanism"); return CKR_GENERAL_ERROR; } if (pMechanism->pParameter == NULL_PTR || - pMechanism->ulParameterLen != sizeof(CK_RSA_PKCS_OAEP_PARAMS)) + pMechanism->ulParameterLen != sizeof(CK_RSA_PKCS_OAEP_PARAMS)) { 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->source != CKZ_DATA_SPECIFIED) { ERROR_MSG("source must be CKZ_DATA_SPECIFIED"); return CKR_ARGUMENTS_BAD; } - if ((params-> pSourceData == NULL)&&(params->ulSourceDataLen != 0)) + if ((params->pSourceData == NULL) && (params->ulSourceDataLen != 0)) { ERROR_MSG("pSourceData is NULL"); return CKR_ARGUMENTS_BAD; @@ -13431,16 +13756,16 @@ CK_RV SoftHSM::MechParamCheckRSAPKCSOAEP(CK_MECHANISM_PTR pMechanism) return CKR_OK; } - CK_RV SoftHSM::MechParamCheckRSAAESKEYWRAP(CK_MECHANISM_PTR pMechanism) { // This is a programming error - if (pMechanism->mechanism != CKM_RSA_AES_KEY_WRAP) { + if (pMechanism->mechanism != CKM_RSA_AES_KEY_WRAP) + { ERROR_MSG("MechParamCheckRSAAESKEYWRAP called on wrong mechanism"); return CKR_GENERAL_ERROR; } if (pMechanism->pParameter == NULL_PTR || - pMechanism->ulParameterLen != sizeof(CK_RSA_AES_KEY_WRAP_PARAMS)) + pMechanism->ulParameterLen != sizeof(CK_RSA_AES_KEY_WRAP_PARAMS)) { ERROR_MSG("pParameter must be of type CK_RSA_AES_KEY_WRAP_PARAMS"); return CKR_ARGUMENTS_BAD; @@ -13457,36 +13782,106 @@ 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("source must be CKZ_DATA_SPECIFIED"); + ERROR_MSG("pSourceData is NULL"); return CKR_ARGUMENTS_BAD; } - if ((params-> pOAEPParams->pSourceData == NULL)&&(params->pOAEPParams->ulSourceDataLen != 0)) + return CKR_OK; +} + +CK_RV SoftHSM::BuildRSAOAEPParam(const CK_RSA_PKCS_OAEP_PARAMS *params, + void **parameters, + size_t *paramLen, + size_t *hashLen) +{ + RSA_PKCS_OAEP_PARAMS oaep_param; + 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; } - /*if (params->pOAEPParams->pSourceData != NULL) + switch (params->hashAlg) { - ERROR_MSG("pSourceData must be NULL"); + case CKM_SHA_1: + oaep_param.hashAlg = HashAlgo::SHA1; + if (hashLen) *hashLen = 20; + break; + case CKM_SHA224: + oaep_param.hashAlg = HashAlgo::SHA224; + if (hashLen) *hashLen = 28; + break; + case CKM_SHA256: + oaep_param.hashAlg = HashAlgo::SHA256; + if (hashLen) *hashLen = 32; + break; + case CKM_SHA384: + oaep_param.hashAlg = HashAlgo::SHA384; + if (hashLen) *hashLen = 48; + break; + case CKM_SHA512: + oaep_param.hashAlg = HashAlgo::SHA512; + if (hashLen) *hashLen = 64; + break; + default: + ERROR_MSG("hash algorithm not supported for OAEP"); return CKR_ARGUMENTS_BAD; } - if (params->pOAEPParams->ulSourceDataLen != 0) + switch (params->mgf) { - ERROR_MSG("ulSourceDataLen must be 0"); + case CKG_MGF1_SHA1: + oaep_param.mgf = AsymRSAMGF::MGF1_SHA1; + break; + case CKG_MGF1_SHA224: + oaep_param.mgf = AsymRSAMGF::MGF1_SHA224; + break; + case CKG_MGF1_SHA256: + oaep_param.mgf = AsymRSAMGF::MGF1_SHA256; + break; + case CKG_MGF1_SHA384: + oaep_param.mgf = AsymRSAMGF::MGF1_SHA384; + break; + case CKG_MGF1_SHA512: + oaep_param.mgf = AsymRSAMGF::MGF1_SHA512; + break; + default: + ERROR_MSG("mgf algorithm not supported for OAEP"); return CKR_ARGUMENTS_BAD; - }*/ - + } + // need copy parameters to session context + // label source data will be copyed to end of parameter block + size_t bufLen = sizeof(RSA_PKCS_OAEP_PARAMS) + params->ulSourceDataLen; + void *paramBuf = malloc(bufLen); + if (paramBuf == NULL) + { + return CKR_HOST_MEMORY; + } + // copy label data to end of parameter block + oaep_param.sourceData = (char *)parameters + sizeof(RSA_PKCS_OAEP_PARAMS); + oaep_param.sourceDataLen = params->ulSourceDataLen; + memcpy(paramBuf, &oaep_param, sizeof(RSA_PKCS_OAEP_PARAMS)); + memcpy(oaep_param.sourceData, params->pSourceData, params->ulSourceDataLen); + *parameters = paramBuf; + *paramLen = bufLen; return CKR_OK; } -bool SoftHSM::isMechanismPermitted(OSObject* key, CK_MECHANISM_TYPE mechanism) +bool SoftHSM::isMechanismPermitted(OSObject *key, CK_MECHANISM_TYPE mechanism) { std::list mechs = supportedMechanisms; /* First check if the algorithm is enabled in the global configuration */ @@ -13495,21 +13890,26 @@ bool SoftHSM::isMechanismPermitted(OSObject* key, CK_MECHANISM_TYPE mechanism) return false; /* If we have object, consult also its allowed mechanisms */ - if (key) { + if (key) + { OSAttribute attribute = key->getAttribute(CKA_ALLOWED_MECHANISMS); std::set allowed = attribute.getMechanismTypeSetValue(); /* empty allow list means we allowing everything that is built-in */ - if (allowed.empty()) { + if (allowed.empty()) + { return true; } return allowed.find(mechanism) != allowed.end(); - } else { + } + else + { return true; } } -bool SoftHSM::detectFork(void) { +bool SoftHSM::detectFork(void) +{ #ifdef _WIN32 return forkID != _getpid(); #else diff --git a/src/lib/SoftHSM.h b/src/lib/SoftHSM.h index ba0b7c62..42c07772 100644 --- a/src/lib/SoftHSM.h +++ b/src/lib/SoftHSM.h @@ -509,7 +509,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, + void** parameters,size_t* paramLen, + size_t* hashLen = NULL); bool isMechanismPermitted(OSObject* key, CK_MECHANISM_TYPE mechanism); void prepareSupportedMechanisms(std::map &t); bool detectFork(void); From eb02aa2fd5ea98a3bbf8bc4c9965ac1c9ca184a2 Mon Sep 17 00:00:00 2001 From: Golikov Pavel Evgenevich Date: Fri, 26 Dec 2025 13:35:06 +0300 Subject: [PATCH 07/15] Add OpenSSL 1 support --- src/lib/crypto/OSSLRSA.cpp | 34 ++++--- src/lib/crypto/OSSLRSAPrivateKey.cpp | 140 +++++++++++++++++++-------- src/lib/crypto/OSSLRSAPublicKey.cpp | 52 ++++++++-- 3 files changed, 163 insertions(+), 63 deletions(-) diff --git a/src/lib/crypto/OSSLRSA.cpp b/src/lib/crypto/OSSLRSA.cpp index 1cf20bf3..32e93e91 100644 --- a/src/lib/crypto/OSSLRSA.cpp +++ b/src/lib/crypto/OSSLRSA.cpp @@ -1500,7 +1500,7 @@ 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)EVP_PKEY_get_size(rsa)) + if (data.size() != (size_t)EVP_PKEY_size(rsa)) { ERROR_MSG("Incorrect amount of input data supplied for raw RSA encryption"); @@ -1516,7 +1516,7 @@ bool OSSLRSA::encrypt(PublicKey *publicKey, const ByteString &data, } // Perform the RSA operation - size_t encLen = EVP_PKEY_get_size(rsa); + size_t encLen = EVP_PKEY_size(rsa); EVP_PKEY_CTX *ctx = EVP_PKEY_CTX_new(rsa, NULL); if (ctx == NULL) @@ -1583,7 +1583,7 @@ bool OSSLRSA::decrypt(PrivateKey *privateKey, const ByteString &encryptedData, const RSA_PKCS_OAEP_PARAMS *oaepParam = NULL; // Check the input size - if (encryptedData.size() != (size_t)EVP_PKEY_get_size(rsa)) + if (encryptedData.size() != (size_t)EVP_PKEY_size(rsa)) { ERROR_MSG("Invalid amount of input data supplied for RSA decryption"); @@ -1659,7 +1659,7 @@ bool OSSLRSA::decrypt(PrivateKey *privateKey, const ByteString &encryptedData, } // Perform the RSA operation - size_t decSize = EVP_PKEY_get_size(rsa); + size_t decSize = EVP_PKEY_size(rsa); EVP_PKEY_CTX *ctx = EVP_PKEY_CTX_new(rsa, NULL); if (ctx == NULL) @@ -1764,25 +1764,31 @@ bool OSSLRSA::generateKeyPair(AsymmetricKeyPair **ppKeyPair, AsymmetricParameter } if ((EVP_PKEY_keygen_init(ctx) <= 0) || (EVP_PKEY_CTX_set_rsa_keygen_bits(ctx, params->getBitLength()) <= 0) || - (EVP_PKEY_CTX_set1_rsa_keygen_pubexp(ctx, bn_e) <= 0) || - (EVP_PKEY_keygen(ctx, &rsa) <= 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("RSA key generation failed (0x%08X)", ERR_get_error()); - BN_free(bn_e); + 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 (!RSA_generate_key_ex(rsa, params->getBitLength(), bn_e, NULL)) + 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); - EVP_PKEY_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(); diff --git a/src/lib/crypto/OSSLRSAPrivateKey.cpp b/src/lib/crypto/OSSLRSAPrivateKey.cpp index f5cb0ed3..feee9632 100644 --- a/src/lib/crypto/OSSLRSAPrivateKey.cpp +++ b/src/lib/crypto/OSSLRSAPrivateKey.cpp @@ -39,6 +39,8 @@ #include #if OPENSSL_VERSION_NUMBER >= 0x30000000L #include +#else +#include #endif #ifdef WITH_FIPS #include @@ -70,6 +72,7 @@ OSSLRSAPrivateKey::~OSSLRSAPrivateKey() // Set from OpenSSL representation void OSSLRSAPrivateKey::setFromOSSL(const EVP_PKEY *inRSA) { +#if OPENSSL_VERSION_NUMBER >= 0x30000000L BIGNUM *bn_p = NULL; BIGNUM *bn_q = NULL; BIGNUM *bn_dmp1 = NULL; @@ -78,7 +81,7 @@ void OSSLRSAPrivateKey::setFromOSSL(const EVP_PKEY *inRSA) BIGNUM *bn_n = NULL; BIGNUM *bn_e = NULL; BIGNUM *bn_d = NULL; -#if OPENSSL_VERSION_NUMBER >= 0x30000000L + 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); @@ -87,59 +90,92 @@ void OSSLRSAPrivateKey::setFromOSSL(const EVP_PKEY *inRSA) 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); -#endif - // 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); - if (bn_p) { - ByteString inP = OSSL::bn2ByteString(bn_p); - setP(inP); + setP(OSSL::bn2ByteString(bn_p)); BN_free(bn_p); } if (bn_q) { - ByteString inQ = OSSL::bn2ByteString(bn_q); - setQ(inQ); + setQ(OSSL::bn2ByteString(bn_q)); BN_free(bn_q); } if (bn_dmp1) { - ByteString inDP1 = OSSL::bn2ByteString(bn_dmp1); - setDP1(inDP1); + setDP1(OSSL::bn2ByteString(bn_dmp1)); BN_free(bn_dmp1); } if (bn_dmq1) { - ByteString inDQ1 = OSSL::bn2ByteString(bn_dmq1); - setDQ1(inDQ1); + setDQ1(OSSL::bn2ByteString(bn_dmq1)); BN_free(bn_dmq1); } if (bn_iqmp) { - ByteString inPQ = OSSL::bn2ByteString(bn_iqmp); - setPQ(inPQ); + setPQ(OSSL::bn2ByteString(bn_iqmp)); BN_free(bn_iqmp); } 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); } if (bn_d) { - ByteString inD = OSSL::bn2ByteString(bn_d); - setD(inD); + 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; + const BIGNUM *bn_dmq1 = NULL; + const BIGNUM *bn_iqmp = NULL; + const BIGNUM *bn_n = NULL; + const BIGNUM *bn_e = NULL; + const BIGNUM *bn_d = NULL; + const RSA *inRSA1 = EVP_PKEY_get0_RSA(const_cast(inRSA)); + 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) + { + setP(OSSL::bn2ByteString(bn_p)); + } + if (bn_q) + { + setQ(OSSL::bn2ByteString(bn_q)); + } + if (bn_dmp1) + { + setDP1(OSSL::bn2ByteString(bn_dmp1)); + } + if (bn_dmq1) + { + setDQ1(OSSL::bn2ByteString(bn_dmq1)); + } + if (bn_iqmp) + { + setPQ(OSSL::bn2ByteString(bn_iqmp)); + } + if (bn_n) + { + setN(OSSL::bn2ByteString(bn_n)); + } + if (bn_e) + { + setE(OSSL::bn2ByteString(bn_e)); + } + if (bn_d) + { + setD(OSSL::bn2ByteString(bn_d)); + } +#endif } // Check if the key is of the given type @@ -309,9 +345,9 @@ void OSSLRSAPrivateKey::createOSSLKey() #if OPENSSL_VERSION_NUMBER >= 0x30000000L OSSL_PARAM_BLD *param_bld = OSSL_PARAM_BLD_new(); - bool bBuildErr = false; + bool bBuildErr = false; if ((param_bld == NULL) || - (bn_n == NULL) || + (bn_n == NULL) || (bn_e == NULL) || (bn_d == NULL) || (OSSL_PARAM_BLD_push_BN(param_bld, "n", bn_n) <= 0) || @@ -320,15 +356,15 @@ void OSSLRSAPrivateKey::createOSSLKey() { bBuildErr = true; } - if ((!bBuildErr)&&(bn_p != NULL)) + if ((!bBuildErr) && (bn_p != NULL)) bBuildErr |= (OSSL_PARAM_BLD_push_BN(param_bld, "rsa-factor1", bn_p) <= 0); - if ((!bBuildErr)&&(bn_q != NULL)) + if ((!bBuildErr) && (bn_q != NULL)) bBuildErr |= (OSSL_PARAM_BLD_push_BN(param_bld, "rsa-factor2", bn_q) <= 0); - if ((!bBuildErr)&&(bn_dmp1 != NULL)) + if ((!bBuildErr) && (bn_dmp1 != NULL)) bBuildErr |= (OSSL_PARAM_BLD_push_BN(param_bld, "rsa-exponent1", bn_dmp1) <= 0); - if ((!bBuildErr)&&(bn_dmq1 != NULL)) + if ((!bBuildErr) && (bn_dmq1 != NULL)) bBuildErr |= (OSSL_PARAM_BLD_push_BN(param_bld, "rsa-exponent2", bn_dmq1) <= 0); - if ((!bBuildErr)&&(bn_iqmp != NULL)) + if ((!bBuildErr) && (bn_iqmp != NULL)) bBuildErr |= (OSSL_PARAM_BLD_push_BN(param_bld, "rsa-coefficient1", bn_iqmp) <= 0); OSSL_PARAM *params = OSSL_PARAM_BLD_to_param(param_bld); @@ -336,12 +372,12 @@ void OSSLRSAPrivateKey::createOSSLKey() BN_free(bn_n); BN_free(bn_e); BN_free(bn_d); - BN_free(bn_p); + BN_free(bn_p); BN_free(bn_q); BN_free(bn_dmp1); BN_free(bn_dmq1); BN_free(bn_iqmp); - if ((bBuildErr)||(params == NULL)) + if ((bBuildErr) || (params == NULL)) { ERROR_MSG("Could not build RSA key parameters"); return; @@ -363,25 +399,47 @@ void OSSLRSAPrivateKey::createOSSLKey() return; } OSSL_PARAM_free(params); - EVP_PKEY_CTX_free(ctx); + EVP_PKEY_CTX_free(ctx); #else + RSA *rsa1 = RSA_new(); + if (rsa1 == NULL) + { + 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 + // 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 - // 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); -#endif } diff --git a/src/lib/crypto/OSSLRSAPublicKey.cpp b/src/lib/crypto/OSSLRSAPublicKey.cpp index 63be0ff2..8cb8264f 100644 --- a/src/lib/crypto/OSSLRSAPublicKey.cpp +++ b/src/lib/crypto/OSSLRSAPublicKey.cpp @@ -39,6 +39,8 @@ #include #if OPENSSL_VERSION_NUMBER >= 0x30000000L #include +#else +#include #endif #ifdef WITH_FIPS #include @@ -75,24 +77,36 @@ bool OSSLRSAPublicKey::isOfType(const char *inType) // Set from OpenSSL representation void OSSLRSAPublicKey::setFromOSSL(const EVP_PKEY *inRSA) { - BIGNUM *bn_n = NULL; - BIGNUM *bn_e = NULL; #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); -#endif 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)); + 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 @@ -177,6 +191,12 @@ void OSSLRSAPublicKey::createOSSLKey() EVP_PKEY_CTX_free(ctx); #else + RSA *rsa1 = RSA_new(); + if (rsa1 == NULL) + { + 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 @@ -189,7 +209,23 @@ void OSSLRSAPublicKey::createOSSLKey() #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 } From bb1623645835bab710677b249452ae714f137e16 Mon Sep 17 00:00:00 2001 From: Golikov Pavel Evgenevich Date: Fri, 26 Dec 2025 14:05:03 +0300 Subject: [PATCH 08/15] Remove legacy code --- src/lib/crypto/OSSLRSA.cpp | 157 +------------------------------------ 1 file changed, 2 insertions(+), 155 deletions(-) diff --git a/src/lib/crypto/OSSLRSA.cpp b/src/lib/crypto/OSSLRSA.cpp index 32e93e91..86de8c32 100644 --- a/src/lib/crypto/OSSLRSA.cpp +++ b/src/lib/crypto/OSSLRSA.cpp @@ -99,13 +99,6 @@ bool OSSLRSA::sign(PrivateKey *privateKey, const ByteString &dataToSign, EVP_PKEY *rsa = osslKey->getOSSLKey(); - // if (!RSA_blinding_on(rsa, NULL)) - //{ - // ERROR_MSG("Failed to turn on blinding for OpenSSL RSA key"); - - // return false; - //} - //-------- EVP_PKEY_CTX *ctx = EVP_PKEY_CTX_new(rsa, NULL); if (ctx == NULL) { @@ -129,13 +122,7 @@ bool OSSLRSA::sign(PrivateKey *privateKey, const ByteString &dataToSign, return false; } EVP_PKEY_CTX_free(ctx); - //-------- - // int sigLen = RSA_private_encrypt(dataToSign.size(), (unsigned char*) dataToSign.const_byte_str(), &signature[0], rsa, RSA_PKCS1_PADDING); - - // RSA_blinding_off(rsa); - signature.resize(sigLen); - return true; } else if (mechanism == AsymMech::RSA_PKCS_PSS) @@ -229,24 +216,6 @@ bool OSSLRSA::sign(PrivateKey *privateKey, const ByteString &dataToSign, 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) - //{ - // ERROR_MSG("Error in RSA PSS padding generation"); - - // return false; - //} - - // if (!RSA_blinding_on(rsa, NULL)) - //{ - // ERROR_MSG("Failed to turn on blinding for OpenSSL RSA key"); - - // return false; - //} - // Perform the signature operation size_t sigLen = osslKey->getN().size(); //-------- @@ -276,12 +245,6 @@ bool OSSLRSA::sign(PrivateKey *privateKey, const ByteString &dataToSign, return false; } EVP_PKEY_CTX_free(ctx); - //-------- - - // int sigLen = RSA_private_encrypt(osslKey->getN().size(), &em[0], &signature[0], rsa, RSA_NO_PADDING); - - // RSA_blinding_off(rsa); - signature.resize(sigLen); return true; @@ -311,13 +274,6 @@ bool OSSLRSA::sign(PrivateKey *privateKey, const ByteString &dataToSign, // Perform the signature operation EVP_PKEY *rsa = osslKey->getOSSLKey(); - - // if (!RSA_blinding_on(rsa, NULL)) - //{ - // ERROR_MSG("Failed to turn on blinding for OpenSSL RSA key"); - - // return false; - //} //-------- EVP_PKEY_CTX *ctx = EVP_PKEY_CTX_new(rsa, NULL); if (ctx == NULL) @@ -336,9 +292,6 @@ bool OSSLRSA::sign(PrivateKey *privateKey, const ByteString &dataToSign, } EVP_PKEY_CTX_free(ctx); //-------- - // int sigLen = RSA_private_encrypt(dataToSign.size(), (unsigned char*) dataToSign.const_byte_str(), &signature[0], rsa, RSA_NO_PADDING); - - // RSA_blinding_off(rsa); signature.resize(sigLen); return true; @@ -684,13 +637,6 @@ bool OSSLRSA::signFinal(ByteString &signature) // Perform the signature operation EVP_PKEY *rsa = pk->getOSSLKey(); - // if (!RSA_blinding_on(rsa, NULL)) - //{ - // ERROR_MSG("Failed to turn blinding on for OpenSSL RSA key"); - - // return false; - //} - //-------- EVP_PKEY_CTX *ctx = EVP_PKEY_CTX_new(rsa, NULL); if (ctx == NULL) @@ -725,9 +671,6 @@ bool OSSLRSA::signFinal(ByteString &signature) } EVP_PKEY_CTX_free(ctx); //-------- - - // RSA_blinding_off(rsa); - signature.resize(sigLen); return true; @@ -756,13 +699,7 @@ 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()); - EVP_PKEY *rsa = osslKey->getOSSLKey(); - - //-------- EVP_PKEY_CTX *ctx = EVP_PKEY_CTX_new(rsa, NULL); if (ctx == NULL) { @@ -784,19 +721,7 @@ bool OSSLRSA::verify(PublicKey *publicKey, const ByteString &originalData, return false; } EVP_PKEY_CTX_free(ctx); - return (status == 1); - // int retLen = RSA_public_decrypt(signature.size(), (unsigned char*) signature.const_byte_str(), &recoveredData[0], rsa, RSA_PKCS1_PADDING); - - // if (retLen == -1) - //{ - // ERROR_MSG("Public key operation failed"); - - // return false; - //} - - // recoveredData.resize(retLen); - - // return (originalData == recoveredData); + return (status == 1); } else if (mechanism == AsymMech::RSA_PKCS_PSS) { @@ -819,24 +744,8 @@ 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()); - EVP_PKEY *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); - size_t allowedLen; const EVP_MD *hash = NULL; const EVP_MD *mgf = NULL; @@ -899,8 +808,6 @@ bool OSSLRSA::verify(PublicKey *publicKey, const ByteString &originalData, 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) { @@ -944,13 +851,7 @@ 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()); - EVP_PKEY *rsa = osslKey->getOSSLKey(); - - //-------- EVP_PKEY_CTX *ctx = EVP_PKEY_CTX_new(rsa, NULL); if (ctx == NULL) { @@ -974,19 +875,6 @@ bool OSSLRSA::verify(PublicKey *publicKey, const ByteString &originalData, } EVP_PKEY_CTX_free(ctx); return (status == 1); - - // 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); - - // return (originalData == recoveredData); } else { @@ -1355,47 +1243,6 @@ bool OSSLRSA::verifyFinal(const ByteString &signature) } EVP_PKEY_CTX_free(ctx); return (status == 1); - - /* - 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 - { - 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()); - } - } - } - else - { - 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()); - } - - return rv; */ } // Encryption functions @@ -1549,7 +1396,7 @@ bool OSSLRSA::encrypt(PublicKey *publicKey, const ByteString &data, { OPENSSL_free(labelData); EVP_PKEY_CTX_free(ctx); - ERROR_MSG("Set OAEP label for RSA decryption failed (0x%08X)", ERR_get_error()); + ERROR_MSG("Set OAEP label for RSA encryption failed (0x%08X)", ERR_get_error()); return false; } } From 69d3118ea683afba49926767e6057cc9181ed65c Mon Sep 17 00:00:00 2001 From: Golikov Pavel Evgenevich Date: Fri, 26 Dec 2025 14:05:40 +0300 Subject: [PATCH 09/15] Fix RSA_set_method call --- src/lib/crypto/OSSLRSAPublicKey.cpp | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/lib/crypto/OSSLRSAPublicKey.cpp b/src/lib/crypto/OSSLRSAPublicKey.cpp index 8cb8264f..1373fb5d 100644 --- a/src/lib/crypto/OSSLRSAPublicKey.cpp +++ b/src/lib/crypto/OSSLRSAPublicKey.cpp @@ -201,11 +201,11 @@ void OSSLRSAPublicKey::createOSSLKey() // 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 From 6c1e1d01ebdfad078a4993a84853426b0aefd5da Mon Sep 17 00:00:00 2001 From: Golikov Pavel Evgenevich Date: Fri, 26 Dec 2025 14:50:49 +0300 Subject: [PATCH 10/15] Add PSS salt length setting in VerifyFinal --- src/lib/crypto/OSSLRSA.cpp | 53 +++++++++++++++++++------------------- 1 file changed, 27 insertions(+), 26 deletions(-) diff --git a/src/lib/crypto/OSSLRSA.cpp b/src/lib/crypto/OSSLRSA.cpp index 86de8c32..7c43f127 100644 --- a/src/lib/crypto/OSSLRSA.cpp +++ b/src/lib/crypto/OSSLRSA.cpp @@ -105,7 +105,7 @@ bool OSSLRSA::sign(PrivateKey *privateKey, const ByteString &dataToSign, ERROR_MSG("An error occurred while creating sign context"); return false; } - + if ((EVP_PKEY_sign_init(ctx) <= 0) || (EVP_PKEY_CTX_set_rsa_padding(ctx, RSA_PKCS1_PADDING) <= 0)) { @@ -113,7 +113,7 @@ bool OSSLRSA::sign(PrivateKey *privateKey, const ByteString &dataToSign, ERROR_MSG("An error occurred while set PKCS #1 signature parameters"); return false; } - + signature.resize(sigLen); if (EVP_PKEY_sign(ctx, signature.byte_str(), &sigLen, (unsigned char *)dataToSign.const_byte_str(), dataToSign.size()) <= 0) { @@ -236,7 +236,7 @@ bool OSSLRSA::sign(PrivateKey *privateKey, const ByteString &dataToSign, ERROR_MSG("An error occurred while performing the RSA-PSS signature"); return false; } - + signature.resize(sigLen); if (EVP_PKEY_sign(ctx, &signature[0], &sigLen, dataToSign.const_byte_str(), dataToSign.size()) <= 0) { @@ -654,7 +654,7 @@ bool OSSLRSA::signFinal(ByteString &signature) } if (rsaPadding == RSA_PKCS1_PSS_PADDING) { - if ((EVP_PKEY_CTX_set_rsa_mgf1_md(ctx, hash) <= 0) || + if ((EVP_PKEY_CTX_set_rsa_mgf1_md(ctx, hash) <= 0) || (EVP_PKEY_CTX_set_rsa_pss_saltlen(ctx, sLen) <= 0)) { EVP_PKEY_CTX_free(ctx); @@ -721,7 +721,7 @@ bool OSSLRSA::verify(PublicKey *publicKey, const ByteString &originalData, return false; } EVP_PKEY_CTX_free(ctx); - return (status == 1); + return (status == 1); } else if (mechanism == AsymMech::RSA_PKCS_PSS) { @@ -1227,12 +1227,13 @@ bool OSSLRSA::verifyFinal(const ByteString &signature) } if (rsaPadding == RSA_PKCS1_PSS_PADDING) { - if (EVP_PKEY_CTX_set_rsa_mgf1_md(ctx, hash) <= 0) - { - EVP_PKEY_CTX_free(ctx); - ERROR_MSG("RSA verify set mgf1 failed (0x%08X)", ERR_get_error()); - return false; - } + if ((EVP_PKEY_CTX_set_rsa_mgf1_md(ctx, hash) <= 0) || + (EVP_PKEY_CTX_set_rsa_pss_saltlen(ctx, sLen) <= 0)) + { + EVP_PKEY_CTX_free(ctx); + ERROR_MSG("RSA verify set mgf1 failed (0x%08X)", ERR_get_error()); + return false; + } } int status = EVP_PKEY_verify(ctx, signature.const_byte_str(), signature.size(), digest.const_byte_str(), digest.size()); if (status < 0) @@ -1281,7 +1282,7 @@ bool OSSLRSA::encrypt(PublicKey *publicKey, const ByteString &data, } else if (padding == AsymMech::RSA_PKCS_OAEP) { - if ((param == NULL)||(paramLen != sizeof(RSA_PKCS_OAEP_PARAMS))) + if ((param == NULL) || (paramLen != sizeof(RSA_PKCS_OAEP_PARAMS))) { ERROR_MSG("Invalid RSA encryption OAEP parameter supplied"); return false; @@ -1335,7 +1336,7 @@ bool OSSLRSA::encrypt(PublicKey *publicKey, const ByteString &data, } // The size of the input data cannot be more than the modulus // length of the key - (2 * hashLen + 1) - if (data.size() > (size_t)(EVP_PKEY_size(rsa) - (2 * hashLen + 1))) + if (data.size() > (size_t)(EVP_PKEY_size(rsa) - (2 * hashLen + 1))) { ERROR_MSG("Too much data supplied for RSA OAEP encryption"); @@ -1380,9 +1381,9 @@ bool OSSLRSA::encrypt(PublicKey *publicKey, const ByteString &data, } if (osslPadding == RSA_PKCS1_OAEP_PADDING) { - void *labelData=NULL; + void *labelData = NULL; if (oaepParam->sourceDataLen != 0) - labelData = OPENSSL_memdup(oaepParam->sourceData,oaepParam->sourceDataLen); + labelData = OPENSSL_memdup(oaepParam->sourceData, oaepParam->sourceDataLen); if ((EVP_PKEY_CTX_set_rsa_oaep_md(ctx, hash) <= 0) || (EVP_PKEY_CTX_set_rsa_mgf1_md(ctx, mgf) <= 0)) @@ -1448,7 +1449,7 @@ bool OSSLRSA::decrypt(PrivateKey *privateKey, const ByteString &encryptedData, else if (padding == AsymMech::RSA_PKCS_OAEP) { osslPadding = RSA_PKCS1_OAEP_PADDING; - if ((param == NULL)||(paramLen != sizeof(RSA_PKCS_OAEP_PARAMS))) + if ((param == NULL) || (paramLen != sizeof(RSA_PKCS_OAEP_PARAMS))) { ERROR_MSG("Invalid RSA decryption OAEP parameter supplied"); return false; @@ -1523,20 +1524,20 @@ bool OSSLRSA::decrypt(PrivateKey *privateKey, const ByteString &encryptedData, } if (osslPadding == RSA_PKCS1_OAEP_PADDING) { - void *labelData=NULL; + void *labelData = NULL; if (oaepParam->sourceDataLen != 0) - labelData = OPENSSL_memdup(oaepParam->sourceData,oaepParam->sourceDataLen); + labelData = OPENSSL_memdup(oaepParam->sourceData, oaepParam->sourceDataLen); if ((EVP_PKEY_CTX_set_rsa_oaep_md(ctx, hash) <= 0) || (EVP_PKEY_CTX_set_rsa_mgf1_md(ctx, mgf) <= 0)) { - OPENSSL_free(labelData); + 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->sourceDataLen) <= 0) { - OPENSSL_free(labelData); + OPENSSL_free(labelData); EVP_PKEY_CTX_free(ctx); ERROR_MSG("Set OAEP label for RSA decryption failed (0x%08X)", ERR_get_error()); return false; @@ -1599,7 +1600,7 @@ bool OSSLRSA::generateKeyPair(AsymmetricKeyPair **ppKeyPair, AsymmetricParameter } // Generate the key-pair - EVP_PKEY *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); @@ -1615,27 +1616,27 @@ bool OSSLRSA::generateKeyPair(AsymmetricKeyPair **ppKeyPair, AsymmetricParameter (EVP_PKEY_CTX_set1_rsa_keygen_pubexp(ctx, bn_e) <= 0)) #else (EVP_PKEY_CTX_set_rsa_keygen_pubexp(ctx, bn_e) <= 0)) -#endif +#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) + 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 +#if OPENSSL_VERSION_NUMBER >= 0x30000000L BN_free(bn_e); #endif return false; } EVP_PKEY_CTX_free(ctx); -#if OPENSSL_VERSION_NUMBER >= 0x30000000L +#if OPENSSL_VERSION_NUMBER >= 0x30000000L BN_free(bn_e); -#endif +#endif // Create an asymmetric key-pair object to return OSSLRSAKeyPair *kp = new OSSLRSAKeyPair(); From 530cba7ef3362b90275a592b11fc6722820769f4 Mon Sep 17 00:00:00 2001 From: Golikov Pavel Evgenevich Date: Fri, 26 Dec 2025 15:22:56 +0300 Subject: [PATCH 11/15] Add salt length setting in one-stage verify --- src/lib/crypto/OSSLRSA.cpp | 21 +++++++++++---------- 1 file changed, 11 insertions(+), 10 deletions(-) diff --git a/src/lib/crypto/OSSLRSA.cpp b/src/lib/crypto/OSSLRSA.cpp index 7c43f127..9204639c 100644 --- a/src/lib/crypto/OSSLRSA.cpp +++ b/src/lib/crypto/OSSLRSA.cpp @@ -233,7 +233,7 @@ bool OSSLRSA::sign(PrivateKey *privateKey, const ByteString &dataToSign, (EVP_PKEY_CTX_set_rsa_pss_saltlen(ctx, sParamLen) <= 0)) { EVP_PKEY_CTX_free(ctx); - ERROR_MSG("An error occurred while performing the RSA-PSS signature"); + ERROR_MSG("An error occurred while set the RSA-PSS signature parameters"); return false; } @@ -817,10 +817,11 @@ bool OSSLRSA::verify(PublicKey *publicKey, const ByteString &originalData, 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_mgf1_md(ctx, mgf) <= 0) || + (EVP_PKEY_CTX_set_rsa_pss_saltlen(ctx, sParamLen) <= 0)) { EVP_PKEY_CTX_free(ctx); - ERROR_MSG("RSA sign verify failed (0x%08X)", ERR_get_error()); + 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(), @@ -1222,18 +1223,18 @@ bool OSSLRSA::verifyFinal(const ByteString &signature) (EVP_PKEY_CTX_set_signature_md(ctx, hash) <= 0)) { EVP_PKEY_CTX_free(ctx); - ERROR_MSG("RSA sign verify failed (0x%08X)", ERR_get_error()); + 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)) - { - EVP_PKEY_CTX_free(ctx); - ERROR_MSG("RSA verify set mgf1 failed (0x%08X)", ERR_get_error()); - return false; - } + (EVP_PKEY_CTX_set_rsa_pss_saltlen(ctx, sLen) <= 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(), digest.const_byte_str(), digest.size()); if (status < 0) From 65c04231179cea7c6bb150b440e14ba4313fd74d Mon Sep 17 00:00:00 2001 From: Golikov Pavel Evgenevich Date: Tue, 30 Dec 2025 13:30:09 +0300 Subject: [PATCH 12/15] Add OAEP encrypt-decrypt parameters for Botan --- src/lib/crypto/BotanRSA.cpp | 103 +++++++++++++++++++++++++++++++++--- src/lib/crypto/BotanRSA.h | 7 ++- 2 files changed, 101 insertions(+), 9 deletions(-) diff --git a/src/lib/crypto/BotanRSA.cpp b/src/lib/crypto/BotanRSA.cpp index 3ed450ef..6ecfe599 100644 --- a/src/lib/crypto/BotanRSA.cpp +++ b/src/lib/crypto/BotanRSA.cpp @@ -744,7 +744,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 void* param, const size_t paramLen) { // Check if the public key is the right type if (!publicKey->isOfType(BotanRSAPublicKey::type)) @@ -762,7 +763,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"; @@ -775,14 +776,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(), param, paramLen); + if (eme.empty()) + return false; + } Botan::PK_Encryptor_EME* encryptor = NULL; try { @@ -792,7 +798,6 @@ bool BotanRSA::encrypt(PublicKey* publicKey, const ByteString& data, catch (...) { ERROR_MSG("Could not create the encryptor token"); - return false; } @@ -823,7 +828,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 void* param, const size_t paramLen) { // Check if the private key is the right type if (!privateKey->isOfType(BotanRSAPrivateKey::type)) @@ -841,7 +847,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"; @@ -862,6 +868,13 @@ bool BotanRSA::decrypt(PrivateKey* privateKey, const ByteString& encryptedData, return false; } + if (padding == AsymMech::RSA_PKCS_OAEP) + { + eme = getCipherOaep(privateKey->getBitLength(), 0, param, paramLen); + if (eme.empty()) + return false; + } + Botan::PK_Decryptor_EME* decryptor = NULL; try { @@ -1163,3 +1176,79 @@ 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 void* param, const size_t paramLen) +{ + if (param == NULL || paramLen != sizeof(RSA_PKCS_OAEP_PARAMS)) + { + ERROR_MSG("Invalid parameters"); + return ""; + } + const RSA_PKCS_OAEP_PARAMS *oaepParam = (RSA_PKCS_OAEP_PARAMS*)param; + std::string hashStr = ""; + std::string mgfStr = ""; + size_t hashLen = 0; + switch (oaepParam->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 (oaepParam->mgf) + { + 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 + 1) + if (dataSize > (size_t)(bitLength/8 - (2 * hashLen + 1))) + { + ERROR_MSG("Too much data supplied for RSA OAEP encryption"); + return ""; + } + + std::ostringstream request; + request << "OAEP(" << hashStr << ",MGF1(" << mgfStr << ")"; + if (oaepParam->sourceDataLen != 0) + { + request <<"," << std::string((const char*)oaepParam->sourceData,oaepParam->sourceDataLen); + } + 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 f9b65541..304d12ec 100644 --- a/src/lib/crypto/BotanRSA.h +++ b/src/lib/crypto/BotanRSA.h @@ -60,10 +60,12 @@ class BotanRSA : public AsymmetricAlgorithm 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 void* param = NULL, const size_t paramLen = 0); // 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 void* param = NULL, const size_t paramLen = 0); // Key factory virtual bool generateKeyPair(AsymmetricKeyPair** ppKeyPair, AsymmetricParameters* parameters, RNG* rng = NULL); @@ -84,6 +86,7 @@ class BotanRSA : public AsymmetricAlgorithm #ifdef WITH_RAW_PSS std::string getCipherRawPss(size_t bitLength, size_t dataSize, const void* param, const size_t paramLen); #endif + std::string getCipherOaep(size_t bitLength, size_t dataSize, const void* param, const size_t paramLen); }; #endif // !_SOFTHSM_V2_BOTANRSA_H From dd25216726f4231b1bfa5cd68b838d1cef20adeb Mon Sep 17 00:00:00 2001 From: Golikov Pavel Evgenevich Date: Tue, 30 Dec 2025 13:31:51 +0300 Subject: [PATCH 13/15] Add asymmetric encrypt-decrypt parameters passing --- src/lib/crypto/BotanDH.cpp | 6 +++-- src/lib/crypto/BotanDH.h | 6 +++-- src/lib/crypto/BotanDSA.cpp | 6 +++-- src/lib/crypto/BotanDSA.h | 6 +++-- src/lib/crypto/BotanECDH.cpp | 6 +++-- src/lib/crypto/BotanECDH.h | 6 +++-- src/lib/crypto/BotanECDSA.cpp | 6 +++-- src/lib/crypto/BotanECDSA.h | 42 ++++++++++++++++++----------------- src/lib/crypto/BotanEDDSA.cpp | 6 +++-- src/lib/crypto/BotanEDDSA.h | 6 +++-- src/lib/crypto/BotanGOST.cpp | 6 +++-- src/lib/crypto/BotanGOST.h | 6 +++-- 12 files changed, 66 insertions(+), 42 deletions(-) diff --git a/src/lib/crypto/BotanDH.cpp b/src/lib/crypto/BotanDH.cpp index 82b7aec0..2bcfca6b 100644 --- a/src/lib/crypto/BotanDH.cpp +++ b/src/lib/crypto/BotanDH.cpp @@ -93,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 void* /* param = NULL */, const size_t /* paramLen = 0 */) { ERROR_MSG("DH does not support encryption"); @@ -102,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 void* /* param = NULL */, const size_t /* paramLen = 0 */) { ERROR_MSG("DH does not support decryption"); diff --git a/src/lib/crypto/BotanDH.h b/src/lib/crypto/BotanDH.h index af2ac598..f0c6b9ea 100644 --- a/src/lib/crypto/BotanDH.h +++ b/src/lib/crypto/BotanDH.h @@ -54,10 +54,12 @@ class BotanDH : public AsymmetricAlgorithm 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 void* param = NULL, const size_t paramLen = 0); // 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 void* param = NULL, const size_t paramLen = 0); // 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 a26001b4..fcf5d558 100644 --- a/src/lib/crypto/BotanDSA.cpp +++ b/src/lib/crypto/BotanDSA.cpp @@ -485,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 void* /* param = NULL */, const size_t /* paramLen = 0 */) { ERROR_MSG("DSA does not support encryption"); @@ -494,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 void* /*param = NULL */, const size_t /* paramLen = 0 */) { ERROR_MSG("DSA does not support decryption"); diff --git a/src/lib/crypto/BotanDSA.h b/src/lib/crypto/BotanDSA.h index dd100165..6846c068 100644 --- a/src/lib/crypto/BotanDSA.h +++ b/src/lib/crypto/BotanDSA.h @@ -59,10 +59,12 @@ class BotanDSA : public AsymmetricAlgorithm 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 void* param = NULL, const size_t paramLen = 0); // 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 void* param = NULL, const size_t paramLen = 0); // 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 8f45f43a..209db675 100644 --- a/src/lib/crypto/BotanECDH.cpp +++ b/src/lib/crypto/BotanECDH.cpp @@ -94,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 void* /* param = NULL */, const size_t /* paramLen = 0 */) { ERROR_MSG("ECDH does not support encryption"); @@ -103,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 void* /* param = NULL */, const size_t /* paramLen = 0 */) { ERROR_MSG("ECDH does not support decryption"); diff --git a/src/lib/crypto/BotanECDH.h b/src/lib/crypto/BotanECDH.h index 3fac507e..47fd42f6 100644 --- a/src/lib/crypto/BotanECDH.h +++ b/src/lib/crypto/BotanECDH.h @@ -54,10 +54,12 @@ class BotanECDH : public AsymmetricAlgorithm 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 void* param = NULL, const size_t paramLen = 0); // 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 void* param = NULL, const size_t paramLen = 0); // 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 4fffa4ec..f279d652 100644 --- a/src/lib/crypto/BotanECDSA.cpp +++ b/src/lib/crypto/BotanECDSA.cpp @@ -321,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 void* /* param = NULL */, const size_t /* paramLen = 0 */) { ERROR_MSG("ECDSA does not support encryption"); @@ -330,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 void* /* param = NULL */, const size_t /* paramLen = 0 */) { ERROR_MSG("ECDSA does not support decryption"); diff --git a/src/lib/crypto/BotanECDSA.h b/src/lib/crypto/BotanECDSA.h index 826d318d..97e18477 100644 --- a/src/lib/crypto/BotanECDSA.h +++ b/src/lib/crypto/BotanECDSA.h @@ -47,38 +47,40 @@ 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); - virtual bool signInit(PrivateKey* privateKey, const AsymMech::Type mechanism, const void* param = NULL, const size_t paramLen = 0); - virtual bool signUpdate(const ByteString& dataToSign); - virtual bool signFinal(ByteString& signature); + virtual bool sign(PrivateKey *privateKey, const ByteString &dataToSign, ByteString &signature, const AsymMech::Type mechanism, const void *param = NULL, const size_t paramLen = 0); + virtual bool signInit(PrivateKey *privateKey, const AsymMech::Type mechanism, const void *param = NULL, const size_t paramLen = 0); + 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); - virtual bool verifyInit(PublicKey* publicKey, const AsymMech::Type mechanism, const void* param = NULL, const size_t paramLen = 0); - virtual bool verifyUpdate(const ByteString& originalData); - virtual bool verifyFinal(const ByteString& signature); + virtual bool verify(PublicKey *publicKey, const ByteString &originalData, const ByteString &signature, const AsymMech::Type mechanism, const void *param = NULL, const size_t paramLen = 0); + virtual bool verifyInit(PublicKey *publicKey, const AsymMech::Type mechanism, const void *param = NULL, const size_t paramLen = 0); + 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 void *param = NULL, const size_t paramLen = 0); // 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 void *param = NULL, const size_t paramLen = 0); // Key factory - virtual bool generateKeyPair(AsymmetricKeyPair** ppKeyPair, AsymmetricParameters* parameters, RNG* rng = NULL); + virtual bool generateKeyPair(AsymmetricKeyPair **ppKeyPair, AsymmetricParameters *parameters, RNG *rng = NULL); virtual unsigned long getMinKeySize(); virtual unsigned long getMaxKeySize(); - virtual bool reconstructKeyPair(AsymmetricKeyPair** ppKeyPair, ByteString& serialisedData); - virtual bool reconstructPublicKey(PublicKey** ppPublicKey, ByteString& serialisedData); - virtual bool reconstructPrivateKey(PrivateKey** ppPrivateKey, ByteString& serialisedData); - virtual bool reconstructParameters(AsymmetricParameters** ppParams, ByteString& serialisedData); - virtual PublicKey* newPublicKey(); - virtual PrivateKey* newPrivateKey(); - virtual AsymmetricParameters* newParameters(); + virtual bool reconstructKeyPair(AsymmetricKeyPair **ppKeyPair, ByteString &serialisedData); + virtual bool reconstructPublicKey(PublicKey **ppPublicKey, ByteString &serialisedData); + virtual bool reconstructPrivateKey(PrivateKey **ppPrivateKey, ByteString &serialisedData); + virtual bool reconstructParameters(AsymmetricParameters **ppParams, ByteString &serialisedData); + virtual PublicKey *newPublicKey(); + virtual PrivateKey *newPrivateKey(); + virtual AsymmetricParameters *newParameters(); private: - Botan::PK_Signer* signer; - Botan::PK_Verifier* verifier; + Botan::PK_Signer *signer; + Botan::PK_Verifier *verifier; }; #endif // !_SOFTHSM_V2_BOTANECDSA_H diff --git a/src/lib/crypto/BotanEDDSA.cpp b/src/lib/crypto/BotanEDDSA.cpp index f2b1b232..904f588d 100644 --- a/src/lib/crypto/BotanEDDSA.cpp +++ b/src/lib/crypto/BotanEDDSA.cpp @@ -256,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 void* /* param = NULL */, const size_t /* paramLen = 0 */) { ERROR_MSG("EDDSA does not support encryption"); @@ -265,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 void* /* param = NULL */, const size_t /* paramLen = 0 */) { ERROR_MSG("EDDSA does not support decryption"); diff --git a/src/lib/crypto/BotanEDDSA.h b/src/lib/crypto/BotanEDDSA.h index 552bca46..52d3c9f3 100644 --- a/src/lib/crypto/BotanEDDSA.h +++ b/src/lib/crypto/BotanEDDSA.h @@ -59,10 +59,12 @@ class BotanEDDSA : public AsymmetricAlgorithm 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 void* param = NULL, const size_t paramLen = 0); // 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 void* param = NULL, const size_t paramLen = 0); // 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 4ae0d13b..3272e4c0 100644 --- a/src/lib/crypto/BotanGOST.cpp +++ b/src/lib/crypto/BotanGOST.cpp @@ -326,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 void* /* param = NULL */, const size_t /* paramLen = 0 */) { ERROR_MSG("GOST does not support encryption"); @@ -335,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 void* /* param = NULL */, const size_t /* paramLen = 0 */) { ERROR_MSG("GOST does not support decryption"); diff --git a/src/lib/crypto/BotanGOST.h b/src/lib/crypto/BotanGOST.h index a8085ab1..a3b9c212 100644 --- a/src/lib/crypto/BotanGOST.h +++ b/src/lib/crypto/BotanGOST.h @@ -57,10 +57,12 @@ class BotanGOST : public AsymmetricAlgorithm 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 void* param = NULL, const size_t paramLen = 0); // 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 void* param = NULL, const size_t paramLen = 0); // Key factory virtual bool generateKeyPair(AsymmetricKeyPair** ppKeyPair, AsymmetricParameters* parameters, RNG* rng = NULL); From 2f850fc929fe1cd52c25ab2184d4e2bea575f4c8 Mon Sep 17 00:00:00 2001 From: Golikov Pavel Evgenevich Date: Tue, 30 Dec 2025 14:20:14 +0300 Subject: [PATCH 14/15] Fix sourceData pointer check --- src/lib/crypto/BotanRSA.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/lib/crypto/BotanRSA.cpp b/src/lib/crypto/BotanRSA.cpp index 6ecfe599..4f2f7167 100644 --- a/src/lib/crypto/BotanRSA.cpp +++ b/src/lib/crypto/BotanRSA.cpp @@ -1245,7 +1245,7 @@ std::string BotanRSA::getCipherOaep(size_t bitLength, size_t dataSize, const voi std::ostringstream request; request << "OAEP(" << hashStr << ",MGF1(" << mgfStr << ")"; - if (oaepParam->sourceDataLen != 0) + if ((oaepParam->sourceData != NULL)&&(oaepParam->sourceDataLen != 0)) { request <<"," << std::string((const char*)oaepParam->sourceData,oaepParam->sourceDataLen); } From 51450edec92c6c596fe56b2fa26adcafe7537c39 Mon Sep 17 00:00:00 2001 From: Golikov Pavel Evgenevich Date: Tue, 30 Dec 2025 16:02:56 +0300 Subject: [PATCH 15/15] Fix maximum length validation for RSA encryption --- src/lib/crypto/BotanRSA.cpp | 4 ++-- src/lib/crypto/OSSLRSA.cpp | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/src/lib/crypto/BotanRSA.cpp b/src/lib/crypto/BotanRSA.cpp index 4f2f7167..1426ab65 100644 --- a/src/lib/crypto/BotanRSA.cpp +++ b/src/lib/crypto/BotanRSA.cpp @@ -1236,8 +1236,8 @@ std::string BotanRSA::getCipherOaep(size_t bitLength, size_t dataSize, const voi return ""; } // The size of the input data cannot be more than the modulus - // length of the key - (2 * hashLen + 1) - if (dataSize > (size_t)(bitLength/8 - (2 * hashLen + 1))) + // 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 ""; diff --git a/src/lib/crypto/OSSLRSA.cpp b/src/lib/crypto/OSSLRSA.cpp index 9204639c..0c1985fa 100644 --- a/src/lib/crypto/OSSLRSA.cpp +++ b/src/lib/crypto/OSSLRSA.cpp @@ -1336,8 +1336,8 @@ bool OSSLRSA::encrypt(PublicKey *publicKey, const ByteString &data, return false; } // The size of the input data cannot be more than the modulus - // length of the key - (2 * hashLen + 1) - if (data.size() > (size_t)(EVP_PKEY_size(rsa) - (2 * hashLen + 1))) + // 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");