diff options
Diffstat (limited to 'SoftHSMv2/src/lib/SoftHSM.cpp')
| -rw-r--r-- | SoftHSMv2/src/lib/SoftHSM.cpp | 11178 |
1 files changed, 11178 insertions, 0 deletions
diff --git a/SoftHSMv2/src/lib/SoftHSM.cpp b/SoftHSMv2/src/lib/SoftHSM.cpp new file mode 100644 index 0000000..b06efc2 --- /dev/null +++ b/SoftHSMv2/src/lib/SoftHSM.cpp @@ -0,0 +1,11178 @@ +/* + * Copyright (c) 2010 SURFnet bv + * Copyright (c) 2010 .SE (The Internet Infrastructure Foundation) + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE + * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER + * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR + * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN + * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/***************************************************************************** + SoftHSM.cpp + + The implementation of the SoftHSM's main class + *****************************************************************************/ + +#include "config.h" +#include "log.h" +#include "access.h" +#include "Configuration.h" +#include "SimpleConfigLoader.h" +#include "MutexFactory.h" +#include "SecureMemoryRegistry.h" +#include "CryptoFactory.h" +#include "AsymmetricAlgorithm.h" +#include "SymmetricAlgorithm.h" +#include "AESKey.h" +#include "DESKey.h" +#include "RNG.h" +#include "RSAParameters.h" +#include "RSAPublicKey.h" +#include "RSAPrivateKey.h" +#include "DSAParameters.h" +#include "DSAPublicKey.h" +#include "DSAPrivateKey.h" +#include "ECPublicKey.h" +#include "ECPrivateKey.h" +#include "ECParameters.h" +#include "DHParameters.h" +#include "DHPublicKey.h" +#include "DHPrivateKey.h" +#include "GOSTPublicKey.h" +#include "GOSTPrivateKey.h" +#include "cryptoki.h" +#include "SoftHSM.h" +#include "osmutex.h" +#include "SessionManager.h" +#include "SessionObjectStore.h" +#include "HandleManager.h" +#include "P11Objects.h" +#include "odd.h" + +#if defined(WITH_OPENSSL) +#include "OSSLCryptoFactory.h" +#else +#include "BotanCryptoFactory.h" +#endif + +#include <stdlib.h> + +// Initialise the one-and-only instance + +#ifdef HAVE_CXX11 + +std::unique_ptr<MutexFactory> MutexFactory::instance(nullptr); +std::unique_ptr<SecureMemoryRegistry> SecureMemoryRegistry::instance(nullptr); +#if defined(WITH_OPENSSL) +std::unique_ptr<OSSLCryptoFactory> OSSLCryptoFactory::instance(nullptr); +#else +std::unique_ptr<BotanCryptoFactory> BotanCryptoFactory::instance(nullptr); +#endif +std::unique_ptr<SoftHSM> SoftHSM::instance(nullptr); + +#else + +std::auto_ptr<MutexFactory> MutexFactory::instance(NULL); +std::auto_ptr<SecureMemoryRegistry> SecureMemoryRegistry::instance(NULL); +#if defined(WITH_OPENSSL) +std::auto_ptr<OSSLCryptoFactory> OSSLCryptoFactory::instance(NULL); +#else +std::auto_ptr<BotanCryptoFactory> BotanCryptoFactory::instance(NULL); +#endif +std::auto_ptr<SoftHSM> SoftHSM::instance(NULL); + +#endif + +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 + 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 + 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 + } + 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) +{ + bool bHasClass = false; + bool bHasKeyType = false; + bool bHasCertType = false; + bool bHasPrivate = false; + + // Extract object information + for (CK_ULONG i = 0; i < ulCount; ++i) + { + 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; + } + } + + if (bImplicit) + { + return CKR_OK; + } + + if (!bHasClass) + { + return CKR_TEMPLATE_INCOMPLETE; + } + + bool bKeyTypeRequired = (objClass == CKO_PUBLIC_KEY || objClass == CKO_PRIVATE_KEY || objClass == CKO_SECRET_KEY); + if (bKeyTypeRequired && !bHasKeyType) + { + return CKR_TEMPLATE_INCOMPLETE; + } + + if (objClass == CKO_CERTIFICATE) + { + if (!bHasCertType) + { + return CKR_TEMPLATE_INCOMPLETE; + } + if (!bHasPrivate) + { + // Change default value for certificates + isPrivate = CK_FALSE; + } + } + + if (objClass == CKO_PUBLIC_KEY && !bHasPrivate) + { + // Change default value for public keys + isPrivate = CK_FALSE; + } + + return CKR_OK; +} + +static CK_RV newP11Object(OSObject *object, P11Object **p11object) +{ + CK_OBJECT_CLASS objClass = object->getUnsignedLongValue(CKA_CLASS, CKO_VENDOR_DEFINED); + CK_KEY_TYPE keyType = CKK_RSA; + CK_CERTIFICATE_TYPE certType = CKC_X_509; + if (object->attributeExists(CKA_KEY_TYPE)) + 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); + if (rv != CKR_OK) + return rv; + if (!(*p11object)->init(object)) + return CKR_GENERAL_ERROR; // something went wrong that shouldn't have. + return CKR_OK; +} + +#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() }; + return attr; +} +#endif + +/***************************************************************************** + Implementation of SoftHSM class specific functions + *****************************************************************************/ + +// Return the one-and-only instance +SoftHSM* SoftHSM::i() +{ + if (!instance.get()) + { + instance.reset(new SoftHSM()); + } + + return instance.get(); +} + +void SoftHSM::reset() +{ + if (instance.get()) + instance.reset(); +} + +// Constructor +SoftHSM::SoftHSM() +{ + isInitialised = false; + isRemovable = false; + sessionObjectStore = NULL; + objectStore = NULL; + slotManager = NULL; + sessionManager = NULL; + handleManager = NULL; +} + +// Destructor +SoftHSM::~SoftHSM() +{ + if (handleManager != NULL) delete handleManager; + if (sessionManager != NULL) delete sessionManager; + if (slotManager != NULL) delete slotManager; + if (objectStore != NULL) delete objectStore; + if (sessionObjectStore != NULL) delete sessionObjectStore; +} + +/***************************************************************************** + Implementation of PKCS #11 functions + *****************************************************************************/ + +// PKCS #11 initialisation function +CK_RV SoftHSM::C_Initialize(CK_VOID_PTR pInitArgs) +{ + CK_C_INITIALIZE_ARGS_PTR args; + + // Check if PKCS#11 is already initialized + if (isInitialised) + { + ERROR_MSG("SoftHSM is already initialized"); + return CKR_CRYPTOKI_ALREADY_INITIALIZED; + } + + // Do we have any arguments? + if (pInitArgs != NULL_PTR) + { + args = (CK_C_INITIALIZE_ARGS_PTR)pInitArgs; + + // Must be set to NULL_PTR in this version of PKCS#11 + if (args->pReserved != NULL_PTR) + { + ERROR_MSG("pReserved must be set to NULL_PTR"); + return CKR_ARGUMENTS_BAD; + } + + // Can we spawn our own threads? + // if (args->flags & CKF_LIBRARY_CANT_CREATE_OS_THREADS) + // { + // DEBUG_MSG("Cannot create threads if CKF_LIBRARY_CANT_CREATE_OS_THREADS is set"); + // return CKR_NEED_TO_CREATE_THREADS; + // } + + // Are we not supplied with mutex functions? + if + ( + args->CreateMutex == NULL_PTR && + args->DestroyMutex == NULL_PTR && + args->LockMutex == NULL_PTR && + args->UnlockMutex == NULL_PTR + ) + { + // Can we use our own mutex functions? + if (args->flags & CKF_OS_LOCKING_OK) + { + // Use our own mutex functions. + MutexFactory::i()->setCreateMutex(OSCreateMutex); + MutexFactory::i()->setDestroyMutex(OSDestroyMutex); + MutexFactory::i()->setLockMutex(OSLockMutex); + MutexFactory::i()->setUnlockMutex(OSUnlockMutex); + MutexFactory::i()->enable(); + } + else + { + // The external application is not using threading + MutexFactory::i()->disable(); + } + } + else + { + // We must have all mutex functions + if + ( + args->CreateMutex == NULL_PTR || + args->DestroyMutex == NULL_PTR || + args->LockMutex == NULL_PTR || + args->UnlockMutex == NULL_PTR + ) + { + ERROR_MSG("Not all mutex functions are supplied"); + return CKR_ARGUMENTS_BAD; + } + + // We could use our own mutex functions if the flag is set, + // but we use the external functions in both cases. + + // Load the external mutex functions + MutexFactory::i()->setCreateMutex(args->CreateMutex); + MutexFactory::i()->setDestroyMutex(args->DestroyMutex); + MutexFactory::i()->setLockMutex(args->LockMutex); + MutexFactory::i()->setUnlockMutex(args->UnlockMutex); + MutexFactory::i()->enable(); + } + } + else + { + // No concurrent access by multiple threads + MutexFactory::i()->disable(); + } + + // Initiate SecureMemoryRegistry + if (SecureMemoryRegistry::i() == NULL) + { + ERROR_MSG("Could not load the SecureMemoryRegistry"); + return CKR_GENERAL_ERROR; + } + + // Build the CryptoFactory + if (CryptoFactory::i() == NULL) + { + ERROR_MSG("Could not load the CryptoFactory"); + return CKR_GENERAL_ERROR; + } + +#ifdef WITH_FIPS + // Check the FIPS status + if (!CryptoFactory::i()->getFipsSelfTestStatus()) + { + ERROR_MSG("The FIPS self test failed"); + return CKR_FIPS_SELF_TEST_FAILED; + } +#endif + + // (Re)load the configuration + if (!Configuration::i()->reload(SimpleConfigLoader::i())) + { + ERROR_MSG("Could not load the configuration"); + return CKR_GENERAL_ERROR; + } + + // Configure the log level + if (!setLogLevel(Configuration::i()->getString("log.level", DEFAULT_LOG_LEVEL))) + { + ERROR_MSG("Could not set the log level"); + return CKR_GENERAL_ERROR; + } + + // Configure object store storage backend used by all tokens. + if (!ObjectStoreToken::selectBackend(Configuration::i()->getString("objectstore.backend", DEFAULT_OBJECTSTORE_BACKEND))) + { + ERROR_MSG("Could not set the storage backend"); + return CKR_GENERAL_ERROR; + } + + sessionObjectStore = new SessionObjectStore(); + + // Load the object store + objectStore = new ObjectStore(Configuration::i()->getString("directories.tokendir", DEFAULT_TOKENDIR)); + if (!objectStore->isValid()) + { + WARNING_MSG("Could not load the object store"); + delete objectStore; + objectStore = NULL; + delete sessionObjectStore; + sessionObjectStore = NULL; + return CKR_GENERAL_ERROR; + } + + isRemovable = Configuration::i()->getBool("slots.removable", false); + + // Load the slot manager + slotManager = new SlotManager(objectStore); + + // Load the session manager + sessionManager = new SessionManager(); + + // Load the handle manager + handleManager = new HandleManager(); + + // Set the state to initialised + isInitialised = true; + + return CKR_OK; +} + +// PKCS #11 finalisation function +CK_RV SoftHSM::C_Finalize(CK_VOID_PTR pReserved) +{ + 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 (handleManager != NULL) delete handleManager; + handleManager = NULL; + if (sessionManager != NULL) delete sessionManager; + sessionManager = NULL; + if (slotManager != NULL) delete slotManager; + slotManager = NULL; + if (objectStore != NULL) delete objectStore; + objectStore = NULL; + if (sessionObjectStore != NULL) delete sessionObjectStore; + sessionObjectStore = NULL; + CryptoFactory::reset(); + SecureMemoryRegistry::reset(); + + isInitialised = false; + + SoftHSM::reset(); + return CKR_OK; +} + +// 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; + + pInfo->cryptokiVersion.major = CRYPTOKI_VERSION_MAJOR; + pInfo->cryptokiVersion.minor = CRYPTOKI_VERSION_MINOR; + memset(pInfo->manufacturerID, ' ', 32); + memcpy(pInfo->manufacturerID, "SoftHSM", 7); + pInfo->flags = 0; + memset(pInfo->libraryDescription, ' ', 32); +#ifdef WITH_FIPS + memcpy(pInfo->libraryDescription, "Implementation of PKCS11+FIPS", 29); +#else + memcpy(pInfo->libraryDescription, "Implementation of PKCS11", 24); +#endif + pInfo->libraryVersion.major = VERSION_MAJOR; + pInfo->libraryVersion.minor = VERSION_MINOR; + + return CKR_OK; +} + +// 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; + + return slotManager->getSlotList(objectStore, tokenPresent, pSlotList, pulCount); +} + +// Return information about a slot +CK_RV SoftHSM::C_GetSlotInfo(CK_SLOT_ID slotID, CK_SLOT_INFO_PTR pInfo) +{ + CK_RV rv; + if (!isInitialised) return CKR_CRYPTOKI_NOT_INITIALIZED; + + Slot* slot = slotManager->getSlot(slotID); + if (slot == NULL) + { + return CKR_SLOT_ID_INVALID; + } + + rv = slot->getSlotInfo(pInfo); + if (rv != CKR_OK) { + return rv; + } + + if (isRemovable) { + pInfo->flags |= CKF_REMOVABLE_DEVICE; + } + + return CKR_OK; +} + +// 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; + + Slot* slot = slotManager->getSlot(slotID); + if (slot == NULL) + { + return CKR_SLOT_ID_INVALID; + } + + Token* token = slot->getToken(); + if (token == NULL) + { + return CKR_TOKEN_NOT_PRESENT; + } + + return token->getTokenInfo(pInfo); +} + +// Return the list of supported mechanisms for a given slot +CK_RV SoftHSM::C_GetMechanismList(CK_SLOT_ID slotID, CK_MECHANISM_TYPE_PTR pMechanismList, CK_ULONG_PTR pulCount) +{ + // A list with the supported mechanisms + CK_ULONG nrSupportedMechanisms = 61; +#ifdef WITH_ECC + nrSupportedMechanisms += 3; +#endif +#ifdef WITH_FIPS + nrSupportedMechanisms -= 9; +#endif +#ifdef WITH_GOST + nrSupportedMechanisms += 5; +#endif +#ifdef HAVE_AES_KEY_WRAP_PAD + nrSupportedMechanisms += 1; +#endif +#ifdef WITH_RAW_PSS + nrSupportedMechanisms += 1; // CKM_RSA_PKCS_PSS +#endif +#ifdef WITH_AES_GCM + nrSupportedMechanisms += 1; +#endif + + CK_MECHANISM_TYPE supportedMechanisms[] = + { +#ifndef WITH_FIPS + CKM_MD5, +#endif + CKM_SHA_1, + CKM_SHA224, + CKM_SHA256, + CKM_SHA384, + CKM_SHA512, +#ifndef WITH_FIPS + CKM_MD5_HMAC, +#endif + CKM_SHA_1_HMAC, + CKM_SHA224_HMAC, + CKM_SHA256_HMAC, + CKM_SHA384_HMAC, + CKM_SHA512_HMAC, + CKM_RSA_PKCS_KEY_PAIR_GEN, + CKM_RSA_PKCS, + CKM_RSA_X_509, +#ifndef WITH_FIPS + CKM_MD5_RSA_PKCS, +#endif + CKM_SHA1_RSA_PKCS, + CKM_RSA_PKCS_OAEP, + CKM_SHA224_RSA_PKCS, + CKM_SHA256_RSA_PKCS, + CKM_SHA384_RSA_PKCS, + CKM_SHA512_RSA_PKCS, +#ifdef WITH_RAW_PSS + CKM_RSA_PKCS_PSS, +#endif + CKM_SHA1_RSA_PKCS_PSS, + CKM_SHA224_RSA_PKCS_PSS, + CKM_SHA256_RSA_PKCS_PSS, + CKM_SHA384_RSA_PKCS_PSS, + CKM_SHA512_RSA_PKCS_PSS, +#ifndef WITH_FIPS + CKM_DES_KEY_GEN, +#endif + CKM_DES2_KEY_GEN, + CKM_DES3_KEY_GEN, +#ifndef WITH_FIPS + CKM_DES_ECB, + CKM_DES_CBC, + CKM_DES_CBC_PAD, + CKM_DES_ECB_ENCRYPT_DATA, + CKM_DES_CBC_ENCRYPT_DATA, +#endif + CKM_DES3_ECB, + CKM_DES3_CBC, + CKM_DES3_CBC_PAD, + CKM_DES3_ECB_ENCRYPT_DATA, + CKM_DES3_CBC_ENCRYPT_DATA, + CKM_DES3_CMAC, + CKM_AES_KEY_GEN, + CKM_AES_ECB, + CKM_AES_CBC, + CKM_AES_CBC_PAD, + CKM_AES_CTR, +#ifdef WITH_AES_GCM + CKM_AES_GCM, +#endif + CKM_AES_KEY_WRAP, +#ifdef HAVE_AES_KEY_WRAP_PAD + CKM_AES_KEY_WRAP_PAD, +#endif + CKM_AES_ECB_ENCRYPT_DATA, + CKM_AES_CBC_ENCRYPT_DATA, + CKM_AES_CMAC, + CKM_DSA_PARAMETER_GEN, + CKM_DSA_KEY_PAIR_GEN, + CKM_DSA, + CKM_DSA_SHA1, + CKM_DSA_SHA224, + CKM_DSA_SHA256, + CKM_DSA_SHA384, + CKM_DSA_SHA512, + CKM_DH_PKCS_KEY_PAIR_GEN, + CKM_DH_PKCS_PARAMETER_GEN, + CKM_DH_PKCS_DERIVE, +#ifdef WITH_ECC + CKM_EC_KEY_PAIR_GEN, + CKM_ECDSA, + CKM_ECDH1_DERIVE, +#endif +#ifdef WITH_GOST + CKM_GOSTR3411, + CKM_GOSTR3411_HMAC, + CKM_GOSTR3410_KEY_PAIR_GEN, + CKM_GOSTR3410, + CKM_GOSTR3410_WITH_GOSTR3411 +#endif + }; + + if (!isInitialised) return CKR_CRYPTOKI_NOT_INITIALIZED; + if (pulCount == NULL_PTR) return CKR_ARGUMENTS_BAD; + + Slot* slot = slotManager->getSlot(slotID); + if (slot == NULL) + { + return CKR_SLOT_ID_INVALID; + } + + if (pMechanismList == NULL_PTR) + { + *pulCount = nrSupportedMechanisms; + + return CKR_OK; + } + + if (*pulCount < nrSupportedMechanisms) + { + *pulCount = nrSupportedMechanisms; + + return CKR_BUFFER_TOO_SMALL; + } + + *pulCount = nrSupportedMechanisms; + + for (CK_ULONG i = 0; i < nrSupportedMechanisms; i ++) + { + pMechanismList[i] = supportedMechanisms[i]; + } + + return CKR_OK; +} + +// Return more information about a mechanism for a given slot +CK_RV SoftHSM::C_GetMechanismInfo(CK_SLOT_ID slotID, CK_MECHANISM_TYPE type, CK_MECHANISM_INFO_PTR pInfo) +{ + unsigned long rsaMinSize, rsaMaxSize; + unsigned long dsaMinSize, dsaMaxSize; + unsigned long dhMinSize, dhMaxSize; +#ifdef WITH_ECC + unsigned long ecdsaMinSize, ecdsaMaxSize; + unsigned long ecdhMinSize, ecdhMaxSize; +#endif + + if (!isInitialised) return CKR_CRYPTOKI_NOT_INITIALIZED; + if (pInfo == NULL_PTR) return CKR_ARGUMENTS_BAD; + + Slot* slot = slotManager->getSlot(slotID); + if (slot == NULL) + { + return CKR_SLOT_ID_INVALID; + } + + AsymmetricAlgorithm* rsa = CryptoFactory::i()->getAsymmetricAlgorithm(AsymAlgo::RSA); + if (rsa != NULL) + { + rsaMinSize = rsa->getMinKeySize(); + rsaMaxSize = rsa->getMaxKeySize(); + } + else + { + return CKR_GENERAL_ERROR; + } + CryptoFactory::i()->recycleAsymmetricAlgorithm(rsa); + + AsymmetricAlgorithm* dsa = CryptoFactory::i()->getAsymmetricAlgorithm(AsymAlgo::DSA); + if (dsa != NULL) + { + dsaMinSize = dsa->getMinKeySize(); + // Limitation in PKCS#11 + if (dsaMinSize < 512) + { + dsaMinSize = 512; + } + + dsaMaxSize = dsa->getMaxKeySize(); + // Limitation in PKCS#11 + if (dsaMaxSize > 1024) + { + dsaMaxSize = 1024; + } + } + else + { + return CKR_GENERAL_ERROR; + } + CryptoFactory::i()->recycleAsymmetricAlgorithm(dsa); + + AsymmetricAlgorithm* dh = CryptoFactory::i()->getAsymmetricAlgorithm(AsymAlgo::DH); + if (dh != NULL) + { + dhMinSize = dh->getMinKeySize(); + dhMaxSize = dh->getMaxKeySize(); + } + else + { + return CKR_GENERAL_ERROR; + } + CryptoFactory::i()->recycleAsymmetricAlgorithm(dh); + +#ifdef WITH_ECC + AsymmetricAlgorithm* ecdsa = CryptoFactory::i()->getAsymmetricAlgorithm(AsymAlgo::ECDSA); + if (ecdsa != NULL) + { + ecdsaMinSize = ecdsa->getMinKeySize(); + ecdsaMaxSize = ecdsa->getMaxKeySize(); + } + else + { + return CKR_GENERAL_ERROR; + } + CryptoFactory::i()->recycleAsymmetricAlgorithm(ecdsa); + + AsymmetricAlgorithm* ecdh = CryptoFactory::i()->getAsymmetricAlgorithm(AsymAlgo::ECDH); + if (ecdh != NULL) + { + ecdhMinSize = ecdh->getMinKeySize(); + ecdhMaxSize = ecdh->getMaxKeySize(); + } + else + { + return CKR_GENERAL_ERROR; + } + CryptoFactory::i()->recycleAsymmetricAlgorithm(ecdh); +#endif + + switch (type) + { +#ifndef WITH_FIPS + 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; +#ifndef WITH_FIPS + 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; +#ifndef WITH_FIPS + 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: +#ifdef WITH_RAW_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; +#ifndef WITH_FIPS + 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; +#ifndef WITH_FIPS + case CKM_DES_ECB: + case CKM_DES_CBC: + case CKM_DES_CBC_PAD: +#endif + case CKM_DES3_ECB: + case CKM_DES3_CBC: + case CKM_DES3_CBC_PAD: + // 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_ECB: + case CKM_AES_CBC: + case CKM_AES_CBC_PAD: + case CKM_AES_CTR: +#ifdef WITH_AES_GCM + case CKM_AES_GCM: +#endif + 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; +#endif +#ifndef WITH_FIPS + 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; +#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: + pInfo->ulMinKeySize = ecdsaMinSize; + pInfo->ulMaxKeySize = ecdsaMaxSize; + pInfo->flags = CKF_SIGN | CKF_VERIFY | CKF_EC_COMMOM; + break; + case CKM_ECDH1_DERIVE: + pInfo->ulMinKeySize = ecdhMinSize; + pInfo->ulMaxKeySize = ecdhMaxSize; + 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; +#endif + default: + DEBUG_MSG("The selected mechanism is not supported"); + return CKR_MECHANISM_INVALID; + break; + } + + return CKR_OK; +} + +// 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; + + Slot* slot = slotManager->getSlot(slotID); + if (slot == NULL) + { + return CKR_SLOT_ID_INVALID; + } + + // Check if any session is open with this token. + if (sessionManager->haveSession(slotID)) + { + return CKR_SESSION_EXISTS; + } + + // Check the PIN + 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); + + return slot->initToken(soPIN, pLabel); +} + +// 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; + + // Get the session + 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; + + // Get the token + 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; + + ByteString userPIN(pPin, ulPinLen); + + return token->initUserPIN(userPIN); +} + +// Change the PIN +CK_RV SoftHSM::C_SetPIN(CK_SESSION_HANDLE hSession, CK_UTF8CHAR_PTR pOldPin, CK_ULONG ulOldLen, CK_UTF8CHAR_PTR pNewPin, CK_ULONG ulNewLen) +{ + CK_RV rv = CKR_OK; + + if (!isInitialised) return CKR_CRYPTOKI_NOT_INITIALIZED; + + // Get the session + 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; + + ByteString oldPIN(pOldPin, ulOldLen); + ByteString newPIN(pNewPin, ulNewLen); + + // Get the token + 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; + } + + return rv; +} + +// 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; + + 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); + + return CKR_OK; +} + +// Close the given session +CK_RV SoftHSM::C_CloseSession(CK_SESSION_HANDLE hSession) +{ + if (!isInitialised) return CKR_CRYPTOKI_NOT_INITIALIZED; + + // Get the session + 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); + + // Tell the session manager the session has been closed. + return sessionManager->closeSession(session->getHandle()); +} + +// Close all open sessions +CK_RV SoftHSM::C_CloseAllSessions(CK_SLOT_ID slotID) +{ + if (!isInitialised) return CKR_CRYPTOKI_NOT_INITIALIZED; + + // Get the slot + 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; + + // 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. + handleManager->allSessionsClosed(slotID); + + // Tell the session object store that all sessions were closed for the given slotID. + // The session object store should then remove all session objects for this slot. + sessionObjectStore->allSessionsClosed(slotID); + + // Finally tell the session manager tho close all sessions for the given slot. + // This will also trigger a logout on the associated token to occur. + return sessionManager->closeAllSessions(slot); +} + +// 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; + + // Get the session + Session* session = (Session*)handleManager->getSession(hSession); + if (session == NULL) return CKR_SESSION_HANDLE_INVALID; + + return session->getInfo(pInfo); +} + +// 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; + + // Get the session + Session* session = (Session*)handleManager->getSession(hSession); + if (session == NULL) return CKR_SESSION_HANDLE_INVALID; + + return CKR_FUNCTION_NOT_SUPPORTED; +} + +// 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; + + // Get the session + Session* session = (Session*)handleManager->getSession(hSession); + if (session == NULL) return CKR_SESSION_HANDLE_INVALID; + + return CKR_FUNCTION_NOT_SUPPORTED; +} + +// Login on the token in the specified session +CK_RV SoftHSM::C_Login(CK_SESSION_HANDLE hSession, CK_USER_TYPE userType, CK_UTF8CHAR_PTR pPin, CK_ULONG ulPinLen) +{ + CK_RV rv = CKR_OK; + + if (!isInitialised) return CKR_CRYPTOKI_NOT_INITIALIZED; + + // Get the session + 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; + ByteString pin(pPin, ulPinLen); + + // Get the token + 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; + + // 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; + } + + return rv; +} + +// 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; + + // Get the session + 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; + + // Logout + token->logout(); + + // [PKCS#11 v2.40, C_Logout] When logout is successful... + // a. Any of the application's handles to private objects become invalid. + // b. Even if a user is later logged back into the token those handles remain invalid. + // c. All private session objects from sessions belonging to the application are destroyed. + + // Have the handle manager remove all handles pointing to private objects for this slot. + CK_SLOT_ID slotID = session->getSlot()->getSlotID(); + handleManager->tokenLoggedOut(slotID); + sessionObjectStore->tokenLoggedOut(slotID); + + return CKR_OK; +} + +// 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); +} + +// 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 (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; + + // Get the slot + 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; + + // Check the object handle. + OSObject *object = (OSObject *)handleManager->getObject(hObject); + 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); + + // Check read user credentials + CK_RV rv = haveRead(session->getState(), wasOnToken, wasPrivate); + if (rv != CKR_OK) + { + if (rv == CKR_USER_NOT_LOGGED_IN) + INFO_MSG("User is not authorized"); + + return rv; + } + + // Check if the object is copyable + CK_BBOOL isCopyable = object->getBooleanValue(CKA_COPYABLE, true); + if (!isCopyable) return CKR_ACTION_PROHIBITED; + + // Extract critical information from the template + CK_BBOOL isOnToken = wasOnToken; + CK_BBOOL isPrivate = wasPrivate; + + for (CK_ULONG i = 0; i < ulCount; i++) + { + if ((pTemplate[i].type == CKA_TOKEN) && (pTemplate[i].ulValueLen == sizeof(CK_BBOOL))) + { + 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; + continue; + } + } + + // Check privacy does not downgrade + if (wasPrivate && !isPrivate) return CKR_TEMPLATE_INCONSISTENT; + + // Check write user credentials + rv = haveWrite(session->getState(), isOnToken, isPrivate); + if (rv != CKR_OK) + { + if (rv == CKR_USER_NOT_LOGGED_IN) + INFO_MSG("User is not authorized"); + if (rv == CKR_SESSION_READ_ONLY) + INFO_MSG("Session is read-only"); + + return rv; + } + + // Create the object in session or on the token + OSObject *newobject = NULL_PTR; + if (isOnToken) + { + newobject = (OSObject*) token->createObject(); + } + else + { + newobject = sessionObjectStore->createObject(slot->getSlotID(), hSession, isPrivate != CK_FALSE); + } + if (newobject == NULL) return CKR_GENERAL_ERROR; + + // Copy attributes from object class (CKA_CLASS=0 so the first) + if (!newobject->startTransaction()) + { + newobject->destroyObject(); + return CKR_FUNCTION_FAILED; + } + + CK_ATTRIBUTE_TYPE attrType = CKA_CLASS; + do + { + if (!object->attributeExists(attrType)) + { + rv = CKR_FUNCTION_FAILED; + break; + } + + OSAttribute attr = object->getAttribute(attrType); + + // Upgrade privacy has to encrypt byte strings + if (!wasPrivate && isPrivate && + attr.isByteStringAttribute() && + attr.getByteStringValue().size() != 0) + { + ByteString value; + if (!token->encrypt(attr.getByteStringValue(), value) || + !newobject->setAttribute(attrType, value)) + { + rv = CKR_FUNCTION_FAILED; + break; + } + } + else + { + if (!newobject->setAttribute(attrType, attr)) + { + rv = CKR_FUNCTION_FAILED; + break; + } + } + attrType = object->nextAttributeType(attrType); + } + while (attrType != CKA_CLASS); + + if (rv != CKR_OK) + { + newobject->abortTransaction(); + } + else if (!newobject->commitTransaction()) + { + rv = CKR_FUNCTION_FAILED; + } + + if (rv != CKR_OK) + { + newobject->destroyObject(); + return rv; + } + + // Get the new P11 object + P11Object* newp11object = NULL; + rv = newP11Object(newobject,&newp11object); + if (rv != CKR_OK) + { + newobject->destroyObject(); + return rv; + } + + // Apply the template + rv = newp11object->saveTemplate(token, isPrivate != CK_FALSE, pTemplate, ulCount, OBJECT_OP_COPY); + delete newp11object; + + if (rv != CKR_OK) + { + newobject->destroyObject(); + return rv; + } + + // Set handle + if (isOnToken) + { + *phNewObject = handleManager->addTokenObject(slot->getSlotID(), isPrivate != CK_FALSE, newobject); + } + else + { + *phNewObject = handleManager->addSessionObject(slot->getSlotID(), hSession, isPrivate != CK_FALSE, newobject); + } + + return CKR_OK; +} + +// Destroy the specified object +CK_RV SoftHSM::C_DestroyObject(CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE hObject) +{ + if (!isInitialised) return CKR_CRYPTOKI_NOT_INITIALIZED; + + // Get the session + 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; + + // Check the object handle. + OSObject *object = (OSObject *)handleManager->getObject(hObject); + 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); + + // Check user credentials + CK_RV rv = haveWrite(session->getState(), isOnToken, isPrivate); + if (rv != CKR_OK) + { + if (rv == CKR_USER_NOT_LOGGED_IN) + INFO_MSG("User is not authorized"); + if (rv == CKR_SESSION_READ_ONLY) + INFO_MSG("Session is read-only"); + + return rv; + } + + // Check if the object is destroyable + CK_BBOOL isDestroyable = object->getBooleanValue(CKA_DESTROYABLE, true); + if (!isDestroyable) return CKR_ACTION_PROHIBITED; + + // Tell the handleManager to forget about the object. + handleManager->destroyObject(hObject); + + // Destroy the object + if (!object->destroyObject()) + return CKR_FUNCTION_FAILED; + + return CKR_OK; +} + +// 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 (pulSize == NULL) return CKR_ARGUMENTS_BAD; + + // Get the session + 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; + + // Check the object handle. + OSObject *object = (OSObject *)handleManager->getObject(hObject); + if (object == NULL_PTR || !object->isValid()) return CKR_OBJECT_HANDLE_INVALID; + + *pulSize = CK_UNAVAILABLE_INFORMATION; + + return CKR_OK; +} + +// 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 (pTemplate == NULL) return CKR_ARGUMENTS_BAD; + + // Get the session + 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; + + // Check the object handle. + OSObject *object = (OSObject *)handleManager->getObject(hObject); + 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); + + // Check read user credentials + CK_RV rv = haveRead(session->getState(), isOnToken, isPrivate); + if (rv != CKR_OK) + { + if (rv == CKR_USER_NOT_LOGGED_IN) + INFO_MSG("User is not authorized"); + + // CKR_USER_NOT_LOGGED_IN is not a valid return code for this function, + // so we use CKR_GENERAL_ERROR. + return CKR_GENERAL_ERROR; + } + + // 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); + if (rv != CKR_OK) + return rv; + + // Ask the P11Object to fill the template with attribute values. + rv = p11object->loadTemplate(token, pTemplate,ulCount); + delete p11object; + return rv; +} + +// 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 (pTemplate == NULL) return CKR_ARGUMENTS_BAD; + + // Get the session + 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; + + // Check the object handle. + OSObject *object = (OSObject *)handleManager->getObject(hObject); + 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); + + // Check user credentials + CK_RV rv = haveWrite(session->getState(), isOnToken, isPrivate); + if (rv != CKR_OK) + { + if (rv == CKR_USER_NOT_LOGGED_IN) + INFO_MSG("User is not authorized"); + if (rv == CKR_SESSION_READ_ONLY) + INFO_MSG("Session is read-only"); + + return rv; + } + + // Check if the object is modifiable + CK_BBOOL isModifiable = object->getBooleanValue(CKA_MODIFIABLE, true); + 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); + 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); + delete p11object; + return rv; +} + +// 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; + + // Get the session + 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; + + // 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; + } + + // Get the token + 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; + + session->setOpType(SESSION_OP_FIND); + FindOperation *findOp = FindOperation::create(); + + // Check if we are out of memory + if (findOp == NULL_PTR) return CKR_HOST_MEMORY; + + std::set<OSObject*> allObjects; + token->getObjects(allObjects); + sessionObjectStore->getObjects(slot->getSlotID(),allObjects); + + std::set<CK_OBJECT_HANDLE> handles; + std::set<OSObject*>::iterator it; + for (it=allObjects.begin(); it != allObjects.end(); ++it) + { + // Refresh object and check if it is valid + if (!(*it)->isValid()) { + DEBUG_MSG("Object is not valid, skipping"); + continue; + } + + // Determine if the object has CKA_PRIVATE set to CK_TRUE + bool isPrivateObject = (*it)->getBooleanValue(CKA_PRIVATE, true); + + // If the object is private, and we are in a public session then skip it ! + if (isPublicSession && isPrivateObject) + continue; // skip object + + // Perform the actual attribute matching. + bool bAttrMatch = true; // We let an empty template match everything. + for (CK_ULONG i=0; i<ulCount; ++i) + { + bAttrMatch = false; + + if (!(*it)->attributeExists(pTemplate[i].type)) + break; + + OSAttribute attr = (*it)->getAttribute(pTemplate[i].type); + + if (attr.isBooleanAttribute()) + { + if (sizeof(CK_BBOOL) != pTemplate[i].ulValueLen) + break; + bool bTemplateValue = (*(CK_BBOOL*)pTemplate[i].pValue == CK_TRUE); + if (attr.getBooleanValue() != bTemplateValue) + break; + } + else + { + if (attr.isUnsignedLongAttribute()) + { + if (sizeof(CK_ULONG) != pTemplate[i].ulValueLen) + break; + CK_ULONG ulTemplateValue = *(CK_ULONG_PTR)pTemplate[i].pValue; + if (attr.getUnsignedLongValue() != ulTemplateValue) + break; + } + else + { + if (attr.isByteStringAttribute()) + { + ByteString bsAttrValue; + if (isPrivateObject && attr.getByteStringValue().size() != 0) + { + if (!token->decrypt(attr.getByteStringValue(), bsAttrValue)) + { + delete findOp; + return CKR_GENERAL_ERROR; + } + } + else + bsAttrValue = attr.getByteStringValue(); + + if (bsAttrValue.size() != pTemplate[i].ulValueLen) + break; + if (pTemplate[i].ulValueLen != 0) + { + ByteString bsTemplateValue((const unsigned char*)pTemplate[i].pValue, pTemplate[i].ulValueLen); + if (bsAttrValue != bsTemplateValue) + break; + } + } + else + break; + } + } + // The attribute matched ! + bAttrMatch = true; + } + + if (bAttrMatch) + { + CK_SLOT_ID slotID = slot->getSlotID(); + bool isOnToken = (*it)->getBooleanValue(CKA_TOKEN, false); + bool isPrivate = (*it)->getBooleanValue(CKA_PRIVATE, true); + // Create an object handle for every returned object. + CK_OBJECT_HANDLE hObject; + if (isOnToken) + hObject = handleManager->addTokenObject(slotID,isPrivate,*it); + else + hObject = handleManager->addSessionObject(slotID,hSession,isPrivate,*it); + if (hObject == CK_INVALID_HANDLE) + { + delete findOp; + return CKR_GENERAL_ERROR; + } + handles.insert(hObject); + } + } + + // Storing the object handles for the find will protect the library + // whenever a stale object handle is used to access the library. + findOp->setHandles(handles); + + session->setFindOp(findOp); + + return CKR_OK; +} + +// 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; + + // Get the session + 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; + + // return the object handles that have been added to the find operation. + FindOperation *findOp = session->getFindOp(); + if (findOp == NULL) return CKR_GENERAL_ERROR; + + // Ask the find operation to retrieve the object handles + *pulObjectCount = findOp->retrieveHandles(phObject,ulMaxObjectCount); + + // Erase the object handles from the find operation. + findOp->eraseHandles(0,*pulObjectCount); + + return CKR_OK; +} + +// Finish searching for objects +CK_RV SoftHSM::C_FindObjectsFinal(CK_SESSION_HANDLE hSession) +{ + if (!isInitialised) return CKR_CRYPTOKI_NOT_INITIALIZED; + + // Get the session + 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; + + session->resetOp(); + return CKR_OK; +} + +// 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; + } +} + +// 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 (pMechanism == NULL_PTR) return CKR_ARGUMENTS_BAD; + + // Get the session + 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; + + // Get the token + 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; + + CK_BBOOL isOnToken = key->getBooleanValue(CKA_TOKEN, false); + CK_BBOOL isPrivate = key->getBooleanValue(CKA_PRIVATE, true); + + // Check read user credentials + CK_RV rv = haveRead(session->getState(), isOnToken, isPrivate); + if (rv != CKR_OK) + { + if (rv == CKR_USER_NOT_LOGGED_IN) + INFO_MSG("User is not authorized"); + + return rv; + } + + // Check if key can be used for encryption + if (!key->getBooleanValue(CKA_ENCRYPT, false)) + return CKR_KEY_FUNCTION_NOT_PERMITTED; + + // Check if the specified mechanism is allowed for the key + if (!isMechanismPermitted(key, pMechanism)) + return CKR_MECHANISM_INVALID; + + // Get the symmetric algorithm matching the mechanism + SymAlgo::Type algo = SymAlgo::Unknown; + SymMode::Type mode = SymMode::Unknown; + bool padding = false; + ByteString iv; + size_t bb = 8; + size_t counterBits = 0; + ByteString aad; + size_t tagBytes = 0; + switch(pMechanism->mechanism) { +#ifndef WITH_FIPS + case CKM_DES_ECB: + algo = SymAlgo::DES; + mode = SymMode::ECB; + bb = 7; + break; + case CKM_DES_CBC: + 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: + 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: + algo = SymAlgo::DES3; + mode = SymMode::ECB; + bb = 7; + break; + case CKM_DES3_CBC: + 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: + 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: + algo = SymAlgo::AES; + mode = SymMode::ECB; + break; + case CKM_AES_CBC: + 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: + 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: + 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; +#ifdef WITH_AES_GCM + case CKM_AES_GCM: + 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); + 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; +#endif + default: + return CKR_MECHANISM_INVALID; + } + SymmetricAlgorithm* cipher = CryptoFactory::i()->getSymmetricAlgorithm(algo); + if (cipher == NULL) return CKR_MECHANISM_INVALID; + + SymmetricKey* secretkey = new SymmetricKey(); + + if (getSymmetricKey(secretkey, token, key) != 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, counterBits, aad, tagBytes)) + { + cipher->recycleKey(secretkey); + CryptoFactory::i()->recycleSymmetricAlgorithm(cipher); + return CKR_MECHANISM_INVALID; + } + + session->setOpType(SESSION_OP_ENCRYPT); + session->setSymmetricCryptoOp(cipher); + session->setAllowMultiPartOp(true); + session->setAllowSinglePartOp(true); + session->setSymmetricKey(secretkey); + + return CKR_OK; +} + +// 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 (pMechanism == NULL_PTR) return CKR_ARGUMENTS_BAD; + + // Get the session + 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; + + // Get the token + 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; + + CK_BBOOL isOnToken = key->getBooleanValue(CKA_TOKEN, false); + CK_BBOOL isPrivate = key->getBooleanValue(CKA_PRIVATE, true); + + // Check read user credentials + CK_RV rv = haveRead(session->getState(), isOnToken, isPrivate); + if (rv != CKR_OK) + { + if (rv == CKR_USER_NOT_LOGGED_IN) + INFO_MSG("User is not authorized"); + + return rv; + } + + // Check if key can be used for encryption + if (!key->getBooleanValue(CKA_ENCRYPT, false)) + return CKR_KEY_FUNCTION_NOT_PERMITTED; + + // Get the asymmetric algorithm matching the mechanism + AsymMech::Type mechanism; + bool isRSA = false; + switch(pMechanism->mechanism) { + case CKM_RSA_PKCS: + mechanism = AsymMech::RSA_PKCS; + isRSA = true; + break; + case CKM_RSA_X_509: + mechanism = AsymMech::RSA; + isRSA = true; + break; + case CKM_RSA_PKCS_OAEP: + rv = MechParamCheckRSAPKCSOAEP(pMechanism); + if (rv != CKR_OK) + return rv; + + mechanism = AsymMech::RSA_PKCS_OAEP; + isRSA = true; + break; + default: + return CKR_MECHANISM_INVALID; + } + + AsymmetricAlgorithm* asymCrypto = NULL; + PublicKey* publicKey = NULL; + if (isRSA) + { + asymCrypto = CryptoFactory::i()->getAsymmetricAlgorithm(AsymAlgo::RSA); + if (asymCrypto == NULL) return CKR_MECHANISM_INVALID; + + publicKey = asymCrypto->newPublicKey(); + if (publicKey == NULL) + { + CryptoFactory::i()->recycleAsymmetricAlgorithm(asymCrypto); + return CKR_HOST_MEMORY; + } + + if (getRSAPublicKey((RSAPublicKey*)publicKey, token, key) != CKR_OK) + { + asymCrypto->recyclePublicKey(publicKey); + CryptoFactory::i()->recycleAsymmetricAlgorithm(asymCrypto); + return CKR_GENERAL_ERROR; + } + } + else + { + return CKR_MECHANISM_INVALID; + } + + session->setOpType(SESSION_OP_ENCRYPT); + session->setAsymmetricCryptoOp(asymCrypto); + session->setMechanism(mechanism); + session->setAllowMultiPartOp(false); + session->setAllowSinglePartOp(true); + session->setPublicKey(publicKey); + + return CKR_OK; +} + +// Initialise encryption using the specified object and mechanism +CK_RV SoftHSM::C_EncryptInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechanism, CK_OBJECT_HANDLE hKey) +{ + if (isSymMechanism(pMechanism)) + return SymEncryptInit(hSession, pMechanism, hKey); + else + return AsymEncryptInit(hSession, pMechanism, hKey); +} + +// 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) +{ + SymmetricAlgorithm* cipher = session->getSymmetricCryptoOp(); + if (cipher == NULL || !session->getAllowSinglePartOp()) + { + session->resetOp(); + return CKR_OPERATION_NOT_INITIALIZED; + } + + // Check data size + CK_ULONG maxSize = ulDataLen + cipher->getTagBytes(); + if (cipher->isBlockCipher()) + { + CK_ULONG remainder = ulDataLen % cipher->getBlockSize(); + if (cipher->getPaddingMode() == false && remainder != 0) + { + session->resetOp(); + return CKR_DATA_LEN_RANGE; + } + + // Round up to block size + if (remainder != 0) + { + maxSize = ulDataLen + cipher->getBlockSize() - remainder; + } + else if (cipher->getPaddingMode() == true) + { + maxSize = ulDataLen + cipher->getBlockSize(); + } + } + if (!cipher->checkMaximumBytes(ulDataLen)) + { + session->resetOp(); + return CKR_DATA_LEN_RANGE; + } + + if (pEncryptedData == NULL_PTR) + { + *pulEncryptedDataLen = maxSize; + return CKR_OK; + } + + // Check buffer size + if (*pulEncryptedDataLen < maxSize) + { + *pulEncryptedDataLen = maxSize; + return CKR_BUFFER_TOO_SMALL; + } + + // Get the data + ByteString data(pData, ulDataLen); + ByteString encryptedData; + + // Encrypt the data + if (!cipher->encryptUpdate(data, encryptedData)) + { + session->resetOp(); + return CKR_GENERAL_ERROR; + } + + // Finalize encryption + ByteString encryptedFinal; + if (!cipher->encryptFinal(encryptedFinal)) + { + session->resetOp(); + return CKR_GENERAL_ERROR; + } + encryptedData += encryptedFinal; + encryptedData.resize(maxSize); + + memcpy(pEncryptedData, encryptedData.byte_str(), encryptedData.size()); + *pulEncryptedDataLen = encryptedData.size(); + + session->resetOp(); + return CKR_OK; +} + +// 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) +{ + AsymmetricAlgorithm* asymCrypto = session->getAsymmetricCryptoOp(); + AsymMech::Type mechanism = session->getMechanism(); + PublicKey* publicKey = session->getPublicKey(); + if (asymCrypto == NULL || !session->getAllowSinglePartOp() || publicKey == NULL) + { + session->resetOp(); + return CKR_OPERATION_NOT_INITIALIZED; + } + + // Size of the encrypted data + CK_ULONG size = publicKey->getOutputLength(); + + if (pEncryptedData == NULL_PTR) + { + *pulEncryptedDataLen = size; + return CKR_OK; + } + + // Check buffer size + if (*pulEncryptedDataLen < size) + { + *pulEncryptedDataLen = size; + return CKR_BUFFER_TOO_SMALL; + } + + // Get the data + ByteString data; + 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); + } + + data += ByteString(pData, ulDataLen); + + // Encrypt the data + if (!asymCrypto->encrypt(publicKey,data,encryptedData,mechanism)) + { + session->resetOp(); + return CKR_GENERAL_ERROR; + } + + // Check size + if (encryptedData.size() != size) + { + ERROR_MSG("The size of the encrypted data differs from the size of the mechanism"); + session->resetOp(); + return CKR_GENERAL_ERROR; + } + memcpy(pEncryptedData, encryptedData.byte_str(), size); + *pulEncryptedDataLen = size; + + session->resetOp(); + return CKR_OK; +} + +// 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 (pData == NULL_PTR) return CKR_ARGUMENTS_BAD; + if (pulEncryptedDataLen == NULL_PTR) return CKR_ARGUMENTS_BAD; + + // Get the session + 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_ENCRYPT) + return CKR_OPERATION_NOT_INITIALIZED; + + if (session->getSymmetricCryptoOp() != NULL) + return SymEncrypt(session, pData, ulDataLen, + pEncryptedData, pulEncryptedDataLen); + else + return AsymEncrypt(session, pData, ulDataLen, + 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) +{ + SymmetricAlgorithm* cipher = session->getSymmetricCryptoOp(); + if (cipher == NULL || !session->getAllowMultiPartOp()) + { + session->resetOp(); + return CKR_OPERATION_NOT_INITIALIZED; + } + + // Check data size + size_t blockSize = cipher->getBlockSize(); + size_t remainingSize = cipher->getBufferSize(); + CK_ULONG maxSize = ulDataLen + remainingSize; + if (cipher->isBlockCipher()) + { + int nrOfBlocks = (ulDataLen + remainingSize) / blockSize; + maxSize = nrOfBlocks * blockSize; + } + if (!cipher->checkMaximumBytes(ulDataLen)) + { + session->resetOp(); + return CKR_DATA_LEN_RANGE; + } + + // Check data size + if (pEncryptedData == NULL_PTR) + { + *pulEncryptedDataLen = maxSize; + return CKR_OK; + } + + // Check output buffer size + if (*pulEncryptedDataLen < maxSize) + { + DEBUG_MSG("ulDataLen: %#5x output buffer size: %#5x blockSize: %#3x remainingSize: %#4x maxSize: %#5x", + ulDataLen, *pulEncryptedDataLen, blockSize, remainingSize, maxSize); + *pulEncryptedDataLen = maxSize; + return CKR_BUFFER_TOO_SMALL; + } + + // Get the data + ByteString data(pData, ulDataLen); + ByteString encryptedData; + + // Encrypt the data + if (!cipher->encryptUpdate(data, encryptedData)) + { + session->resetOp(); + 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()); + + // 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()); + return CKR_GENERAL_ERROR; + } + + if (encryptedData.size() > 0) + { + memcpy(pEncryptedData, encryptedData.byte_str(), encryptedData.size()); + } + *pulEncryptedDataLen = encryptedData.size(); + + return CKR_OK; +} + +// 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 (pData == NULL_PTR) return CKR_ARGUMENTS_BAD; + if (pulEncryptedDataLen == NULL_PTR) return CKR_ARGUMENTS_BAD; + + // Get the session + 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_ENCRYPT) + return CKR_OPERATION_NOT_INITIALIZED; + + if (session->getSymmetricCryptoOp() != NULL) + return SymEncryptUpdate(session, pData, ulDataLen, + 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) +{ + SymmetricAlgorithm* cipher = session->getSymmetricCryptoOp(); + if (cipher == NULL || !session->getAllowMultiPartOp()) + { + session->resetOp(); + return CKR_OPERATION_NOT_INITIALIZED; + } + + // Check data size + size_t remainingSize = cipher->getBufferSize() + cipher->getTagBytes(); + CK_ULONG size = remainingSize; + if (cipher->isBlockCipher()) + { + size_t blockSize = cipher->getBlockSize(); + bool isPadding = cipher->getPaddingMode(); + if ((remainingSize % blockSize) != 0 && !isPadding) + { + session->resetOp(); + DEBUG_MSG("Remaining buffer size is not an integral of the block size. Block size: %#2x Remaining size: %#2x", + blockSize, remainingSize); + return CKR_DATA_LEN_RANGE; + } + // when padding: an integral of the block size that is longer than the remaining data. + size = isPadding ? ((remainingSize + blockSize) / blockSize) * blockSize : remainingSize; + } + + // Give required output buffer size. + if (pEncryptedData == NULL_PTR) + { + *pulEncryptedDataLen = size; + return CKR_OK; + } + + // Check output buffer size + if (*pulEncryptedDataLen < size) + { + DEBUG_MSG("output buffer size: %#5x size: %#5x", + *pulEncryptedDataLen, size); + *pulEncryptedDataLen = size; + return CKR_BUFFER_TOO_SMALL; + } + + // Finalize encryption + ByteString encryptedFinal; + if (!cipher->encryptFinal(encryptedFinal)) + { + session->resetOp(); + return CKR_GENERAL_ERROR; + } + DEBUG_MSG("output buffer size: %#2x size: %#2x encryptedFinal.size(): %#2x", + *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()); + return CKR_GENERAL_ERROR; + } + + if (encryptedFinal.size() > 0) + { + memcpy(pEncryptedData, encryptedFinal.byte_str(), encryptedFinal.size()); + } + *pulEncryptedDataLen = encryptedFinal.size(); + + session->resetOp(); + return CKR_OK; +} + +// 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; + + // Get the session + 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_ENCRYPT) return CKR_OPERATION_NOT_INITIALIZED; + + if (session->getSymmetricCryptoOp() != NULL) + return SymEncryptFinal(session, pEncryptedData, pulEncryptedDataLen); + else + return CKR_FUNCTION_NOT_SUPPORTED; +} + +// 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 (pMechanism == NULL_PTR) return CKR_ARGUMENTS_BAD; + + // Get the session + 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; + + // Check if we have another operation + 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; + + CK_BBOOL isOnToken = key->getBooleanValue(CKA_TOKEN, false); + CK_BBOOL isPrivate = key->getBooleanValue(CKA_PRIVATE, true); + + // Check read user credentials + CK_RV rv = haveRead(session->getState(), isOnToken, isPrivate); + if (rv != CKR_OK) + { + if (rv == CKR_USER_NOT_LOGGED_IN) + INFO_MSG("User is not authorized"); + + return rv; + } + + // Check if key can be used for decryption + 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)) + return CKR_MECHANISM_INVALID; + + // Get the symmetric algorithm matching the mechanism + SymAlgo::Type algo = SymAlgo::Unknown; + SymMode::Type mode = SymMode::Unknown; + bool padding = false; + ByteString iv; + size_t bb = 8; + size_t counterBits = 0; + ByteString aad; + size_t tagBytes = 0; + switch(pMechanism->mechanism) { +#ifndef WITH_FIPS + case CKM_DES_ECB: + algo = SymAlgo::DES; + mode = SymMode::ECB; + bb = 7; + break; + case CKM_DES_CBC: + 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: + 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: + algo = SymAlgo::DES3; + mode = SymMode::ECB; + bb = 7; + break; + case CKM_DES3_CBC: + 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: + 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: + algo = SymAlgo::AES; + mode = SymMode::ECB; + break; + case CKM_AES_CBC: + 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: + 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: + 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; +#ifdef WITH_AES_GCM + case CKM_AES_GCM: + 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); + 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; +#endif + default: + return CKR_MECHANISM_INVALID; + } + SymmetricAlgorithm* cipher = CryptoFactory::i()->getSymmetricAlgorithm(algo); + if (cipher == NULL) return CKR_MECHANISM_INVALID; + + SymmetricKey* secretkey = new SymmetricKey(); + + if (getSymmetricKey(secretkey, token, key) != CKR_OK) + { + cipher->recycleKey(secretkey); + CryptoFactory::i()->recycleSymmetricAlgorithm(cipher); + return CKR_GENERAL_ERROR; + } + + // adjust key bit length + secretkey->setBitLen(secretkey->getKeyBits().size() * bb); + + // Initialize decryption + if (!cipher->decryptInit(secretkey, mode, iv, padding, counterBits, aad, tagBytes)) + { + cipher->recycleKey(secretkey); + CryptoFactory::i()->recycleSymmetricAlgorithm(cipher); + return CKR_MECHANISM_INVALID; + } + + session->setOpType(SESSION_OP_DECRYPT); + session->setSymmetricCryptoOp(cipher); + session->setAllowMultiPartOp(true); + session->setAllowSinglePartOp(true); + session->setSymmetricKey(secretkey); + + return CKR_OK; +} + +// 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 (pMechanism == NULL_PTR) return CKR_ARGUMENTS_BAD; + + // Get the session + 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; + + // Check if we have another operation + 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; + + CK_BBOOL isOnToken = key->getBooleanValue(CKA_TOKEN, false); + CK_BBOOL isPrivate = key->getBooleanValue(CKA_PRIVATE, true); + + // Check read user credentials + CK_RV rv = haveRead(session->getState(), isOnToken, isPrivate); + if (rv != CKR_OK) + { + if (rv == CKR_USER_NOT_LOGGED_IN) + INFO_MSG("User is not authorized"); + + return rv; + } + + // Check if key can be used for decryption + 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)) + return CKR_MECHANISM_INVALID; + + // Get the asymmetric algorithm matching the mechanism + AsymMech::Type mechanism = AsymMech::Unknown; + bool isRSA = false; + switch(pMechanism->mechanism) { + case CKM_RSA_PKCS: + mechanism = AsymMech::RSA_PKCS; + isRSA = true; + break; + case CKM_RSA_X_509: + mechanism = AsymMech::RSA; + isRSA = true; + break; + case CKM_RSA_PKCS_OAEP: + 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; + } + + mechanism = AsymMech::RSA_PKCS_OAEP; + isRSA = true; + break; + default: + return CKR_MECHANISM_INVALID; + } + + AsymmetricAlgorithm* asymCrypto = NULL; + PrivateKey* privateKey = NULL; + if (isRSA) + { + asymCrypto = CryptoFactory::i()->getAsymmetricAlgorithm(AsymAlgo::RSA); + if (asymCrypto == NULL) return CKR_MECHANISM_INVALID; + + privateKey = asymCrypto->newPrivateKey(); + if (privateKey == NULL) + { + CryptoFactory::i()->recycleAsymmetricAlgorithm(asymCrypto); + return CKR_HOST_MEMORY; + } + + if (getRSAPrivateKey((RSAPrivateKey*)privateKey, token, key) != CKR_OK) + { + asymCrypto->recyclePrivateKey(privateKey); + CryptoFactory::i()->recycleAsymmetricAlgorithm(asymCrypto); + return CKR_GENERAL_ERROR; + } + } + else + { + return CKR_MECHANISM_INVALID; + } + + // Check if re-authentication is required + if (key->getBooleanValue(CKA_ALWAYS_AUTHENTICATE, false)) + { + session->setReAuthentication(true); + } + + session->setOpType(SESSION_OP_DECRYPT); + session->setAsymmetricCryptoOp(asymCrypto); + session->setMechanism(mechanism); + session->setAllowMultiPartOp(false); + session->setAllowSinglePartOp(true); + session->setPrivateKey(privateKey); + + return CKR_OK; +} + +// Initialise decryption using the specified object +CK_RV SoftHSM::C_DecryptInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechanism, CK_OBJECT_HANDLE hKey) +{ + if (isSymMechanism(pMechanism)) + return SymDecryptInit(hSession, pMechanism, hKey); + else + return AsymDecryptInit(hSession, pMechanism, hKey); +} + +// 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) +{ + SymmetricAlgorithm* cipher = session->getSymmetricCryptoOp(); + if (cipher == NULL || !session->getAllowSinglePartOp()) + { + session->resetOp(); + return CKR_OPERATION_NOT_INITIALIZED; + } + + // Check encrypted data size + if (cipher->isBlockCipher() && ulEncryptedDataLen % cipher->getBlockSize() != 0) + { + session->resetOp(); + return CKR_ENCRYPTED_DATA_LEN_RANGE; + } + if (!cipher->checkMaximumBytes(ulEncryptedDataLen)) + { + session->resetOp(); + return CKR_ENCRYPTED_DATA_LEN_RANGE; + } + + if (pData == NULL_PTR) + { + *pulDataLen = ulEncryptedDataLen; + return CKR_OK; + } + + // Check buffer size + if (*pulDataLen < ulEncryptedDataLen) + { + *pulDataLen = ulEncryptedDataLen; + return CKR_BUFFER_TOO_SMALL; + } + + // Get the data + ByteString encryptedData(pEncryptedData, ulEncryptedDataLen); + ByteString data; + + // Decrypt the data + if (!cipher->decryptUpdate(encryptedData,data)) + { + session->resetOp(); + return CKR_GENERAL_ERROR; + } + + // Finalize decryption + ByteString dataFinal; + if (!cipher->decryptFinal(dataFinal)) + { + session->resetOp(); + return CKR_GENERAL_ERROR; + } + data += dataFinal; + if (data.size() > ulEncryptedDataLen) + { + data.resize(ulEncryptedDataLen); + } + + if (data.size() != 0) + { + memcpy(pData, data.byte_str(), data.size()); + } + *pulDataLen = data.size(); + + 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) +{ + AsymmetricAlgorithm* asymCrypto = session->getAsymmetricCryptoOp(); + AsymMech::Type mechanism = session->getMechanism(); + PrivateKey* privateKey = session->getPrivateKey(); + if (asymCrypto == NULL || !session->getAllowSinglePartOp() || privateKey == NULL) + { + session->resetOp(); + return CKR_OPERATION_NOT_INITIALIZED; + } + + // Check if re-authentication is required + if (session->getReAuthentication()) + { + session->resetOp(); + return CKR_USER_NOT_LOGGED_IN; + } + + // Size of the data + CK_ULONG size = privateKey->getOutputLength(); + if (pData == NULL_PTR) + { + *pulDataLen = size; + return CKR_OK; + } + + // Check buffer size + if (*pulDataLen < size) + { + *pulDataLen = size; + return CKR_BUFFER_TOO_SMALL; + } + + // Get the data + ByteString encryptedData(pEncryptedData, ulEncryptedDataLen); + ByteString data; + + // Decrypt the data + if (!asymCrypto->decrypt(privateKey,encryptedData,data,mechanism)) + { + session->resetOp(); + return CKR_GENERAL_ERROR; + } + + // Check size + if (data.size() > size) + { + ERROR_MSG("The size of the decrypted data exceeds the size of the mechanism"); + session->resetOp(); + return CKR_GENERAL_ERROR; + } + if (data.size() != 0) + { + memcpy(pData, data.byte_str(), data.size()); + } + *pulDataLen = data.size(); + + 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 (pEncryptedData == NULL_PTR) return CKR_ARGUMENTS_BAD; + if (pulDataLen == NULL_PTR) return CKR_ARGUMENTS_BAD; + + // Get the session + 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_DECRYPT) + return CKR_OPERATION_NOT_INITIALIZED; + + if (session->getSymmetricCryptoOp() != NULL) + return SymDecrypt(session, pEncryptedData, ulEncryptedDataLen, + pData, pulDataLen); + else + return AsymDecrypt(session, pEncryptedData, ulEncryptedDataLen, + 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) +{ + SymmetricAlgorithm* cipher = session->getSymmetricCryptoOp(); + if (cipher == NULL || !session->getAllowMultiPartOp()) + { + session->resetOp(); + return CKR_OPERATION_NOT_INITIALIZED; + } + + // Check encrypted data size + size_t blockSize = cipher->getBlockSize(); + size_t remainingSize = cipher->getBufferSize(); + CK_ULONG maxSize = ulEncryptedDataLen + remainingSize; + if (cipher->isBlockCipher()) + { + // There must always be one block left in padding mode if next operation is DecryptFinal. + // To guarantee that one byte is removed in padding mode when the number of blocks is calculated. + size_t paddingAdjustByte = cipher->getPaddingMode() ? 1 : 0; + int nrOfBlocks = (ulEncryptedDataLen + remainingSize - paddingAdjustByte) / blockSize; + maxSize = nrOfBlocks * blockSize; + } + if (!cipher->checkMaximumBytes(ulEncryptedDataLen)) + { + session->resetOp(); + return CKR_ENCRYPTED_DATA_LEN_RANGE; + } + + // Give required output buffer size. + if (pData == NULL_PTR) + { + *pDataLen = maxSize; + return CKR_OK; + } + + // Check output buffer size + 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); + *pDataLen = maxSize; + return CKR_BUFFER_TOO_SMALL; + } + + // Get the data + ByteString data(pEncryptedData, ulEncryptedDataLen); + ByteString decryptedData; + + // Encrypt the data + if (!cipher->decryptUpdate(data, decryptedData)) + { + session->resetOp(); + return CKR_GENERAL_ERROR; + } + DEBUG_MSG("ulEncryptedDataLen: %#5x output buffer size: %#5x blockSize: %#3x remainingSize: %#4x maxSize: %#5x decryptedData.size(): %#5x", + ulEncryptedDataLen, *pDataLen, blockSize, remainingSize, maxSize, decryptedData.size()); + + // Check output size from crypto. Unrecoverable error if to 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()); + return CKR_GENERAL_ERROR; + } + + if (decryptedData.size() > 0) + { + memcpy(pData, decryptedData.byte_str(), decryptedData.size()); + } + *pDataLen = decryptedData.size(); + + 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 (pEncryptedData == NULL_PTR) return CKR_ARGUMENTS_BAD; + if (pDataLen == NULL_PTR) return CKR_ARGUMENTS_BAD; + + // Get the session + 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_DECRYPT) + return CKR_OPERATION_NOT_INITIALIZED; + + if (session->getSymmetricCryptoOp() != NULL) + return SymDecryptUpdate(session, pEncryptedData, ulEncryptedDataLen, + pData, pDataLen); + else + return CKR_FUNCTION_NOT_SUPPORTED; +} + +static CK_RV SymDecryptFinal(Session* session, CK_BYTE_PTR pDecryptedData, CK_ULONG_PTR pulDecryptedDataLen) +{ + SymmetricAlgorithm* cipher = session->getSymmetricCryptoOp(); + if (cipher == NULL || !session->getAllowMultiPartOp()) + { + session->resetOp(); + return CKR_OPERATION_NOT_INITIALIZED; + } + + // Check encrypted data size + size_t remainingSize = cipher->getBufferSize(); + CK_ULONG size = remainingSize; + if (cipher->isBlockCipher()) + { + size_t blockSize = cipher->getBlockSize(); + if (remainingSize % blockSize != 0) + { + session->resetOp(); + DEBUG_MSG("Remaining data length is not an integral of the block size. Block size: %#2x Remaining size: %#2x", + blockSize, remainingSize); + return CKR_ENCRYPTED_DATA_LEN_RANGE; + } + // It is at least one padding byte. If no padding the all remains will be returned. + size_t paddingAdjustByte = cipher->getPaddingMode() ? 1 : 0; + size = remainingSize - paddingAdjustByte; + } + + // Give required output buffer size. + if (pDecryptedData == NULL_PTR) + { + *pulDecryptedDataLen = size; + return CKR_OK; + } + + // Check output buffer size + if (*pulDecryptedDataLen < size) + { + DEBUG_MSG("output buffer size: %#5x size: %#5x", + *pulDecryptedDataLen, size); + *pulDecryptedDataLen = size; + return CKR_BUFFER_TOO_SMALL; + } + + // Finalize decryption + ByteString decryptedFinal; + if (!cipher->decryptFinal(decryptedFinal)) + { + session->resetOp(); + return CKR_GENERAL_ERROR; + } + DEBUG_MSG("output buffer size: %#2x size: %#2x decryptedFinal.size(): %#2x", + *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()); + return CKR_GENERAL_ERROR; + } + + if (decryptedFinal.size() > 0) + { + memcpy(pDecryptedData, decryptedFinal.byte_str(), decryptedFinal.size()); + } + *pulDecryptedDataLen = decryptedFinal.size(); + + session->resetOp(); + return CKR_OK; +} + +// 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; + + // Get the session + 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_DECRYPT) return CKR_OPERATION_NOT_INITIALIZED; + + if (session->getSymmetricCryptoOp() != NULL) + return SymDecryptFinal(session, pData, pDataLen); + else + return CKR_FUNCTION_NOT_SUPPORTED; +} + +// 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 (pMechanism == NULL_PTR) return CKR_ARGUMENTS_BAD; + + // Get the session + 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; + + // Get the mechanism + HashAlgo::Type algo = HashAlgo::Unknown; + switch(pMechanism->mechanism) { +#ifndef WITH_FIPS + 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; +#ifdef WITH_GOST + case CKM_GOSTR3411: + algo = HashAlgo::GOST; + break; +#endif + default: + return CKR_MECHANISM_INVALID; + } + HashAlgorithm* hash = CryptoFactory::i()->getHashAlgorithm(algo); + if (hash == NULL) return CKR_MECHANISM_INVALID; + + // Initialize hashing + if (hash->hashInit() == false) + { + CryptoFactory::i()->recycleHashAlgorithm(hash); + return CKR_GENERAL_ERROR; + } + + session->setOpType(SESSION_OP_DIGEST); + session->setDigestOp(hash); + session->setHashAlgo(algo); + + return CKR_OK; +} + +// 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 (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; + + // Check if we are doing the correct operation + if (session->getOpType() != SESSION_OP_DIGEST) return CKR_OPERATION_NOT_INITIALIZED; + + // Return size + CK_ULONG size = session->getDigestOp()->getHashSize(); + if (pDigest == NULL_PTR) + { + *pulDigestLen = size; + return CKR_OK; + } + + // Check buffer size + if (*pulDigestLen < size) + { + *pulDigestLen = size; + return CKR_BUFFER_TOO_SMALL; + } + + // Get the data + ByteString data(pData, ulDataLen); + + // Digest the data + if (session->getDigestOp()->hashUpdate(data) == false) + { + session->resetOp(); + return CKR_GENERAL_ERROR; + } + + // Get the digest + ByteString digest; + if (session->getDigestOp()->hashFinal(digest) == false) + { + session->resetOp(); + return CKR_GENERAL_ERROR; + } + + // Check size + if (digest.size() != size) + { + ERROR_MSG("The size of the digest differ from the size of the mechanism"); + session->resetOp(); + return CKR_GENERAL_ERROR; + } + memcpy(pDigest, digest.byte_str(), size); + *pulDigestLen = size; + + session->resetOp(); + + return CKR_OK; +} + +// 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 (pPart == NULL_PTR) return CKR_ARGUMENTS_BAD; + + // Get the session + 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; + + // Get the data + ByteString data(pPart, ulPartLen); + + // Digest the data + if (session->getDigestOp()->hashUpdate(data) == false) + { + session->resetOp(); + return CKR_GENERAL_ERROR; + } + + return CKR_OK; +} + +// 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; + + // Get the session + 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; + + // Get the token + 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; + + CK_BBOOL isOnToken = key->getBooleanValue(CKA_TOKEN, false); + CK_BBOOL isPrivate = key->getBooleanValue(CKA_PRIVATE, true); + + // Check read user credentials + CK_RV rv = haveRead(session->getState(), isOnToken, isPrivate); + if (rv != CKR_OK) + { + if (rv == CKR_USER_NOT_LOGGED_IN) + INFO_MSG("User is not authorized"); + + // CKR_USER_NOT_LOGGED_IN is not a valid return code for this function, + // so we use CKR_GENERAL_ERROR. + return CKR_GENERAL_ERROR; + } + + // Whitelist + HashAlgo::Type algo = session->getHashAlgo(); + if (algo != HashAlgo::SHA1 && + algo != HashAlgo::SHA224 && + algo != HashAlgo::SHA256 && + algo != HashAlgo::SHA384 && + algo != HashAlgo::SHA512) + { + // Parano... + if (!key->getBooleanValue(CKA_EXTRACTABLE, false)) + return CKR_KEY_INDIGESTIBLE; + if (key->getBooleanValue(CKA_SENSITIVE, false)) + return CKR_KEY_INDIGESTIBLE; + } + + // Get value + if (!key->attributeExists(CKA_VALUE)) + return CKR_KEY_INDIGESTIBLE; + ByteString keybits; + if (isPrivate) + { + if (!token->decrypt(key->getByteStringValue(CKA_VALUE), keybits)) + return CKR_GENERAL_ERROR; + } + else + { + keybits = key->getByteStringValue(CKA_VALUE); + } + + // Digest the value + if (session->getDigestOp()->hashUpdate(keybits) == false) + { + session->resetOp(); + return CKR_GENERAL_ERROR; + } + + return CKR_OK; +} + +// 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 (pulDigestLen == NULL_PTR) return CKR_ARGUMENTS_BAD; + + // Get the session + 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; + + // Return size + CK_ULONG size = session->getDigestOp()->getHashSize(); + if (pDigest == NULL_PTR) + { + *pulDigestLen = size; + return CKR_OK; + } + + // Check buffer size + if (*pulDigestLen < size) + { + *pulDigestLen = size; + return CKR_BUFFER_TOO_SMALL; + } + + // Get the digest + ByteString digest; + if (session->getDigestOp()->hashFinal(digest) == false) + { + session->resetOp(); + return CKR_GENERAL_ERROR; + } + + // Check size + if (digest.size() != size) + { + ERROR_MSG("The size of the digest differ from the size of the mechanism"); + session->resetOp(); + return CKR_GENERAL_ERROR; + } + memcpy(pDigest, digest.byte_str(), size); + *pulDigestLen = size; + + session->resetOp(); + + return CKR_OK; +} + +// Sign*/Verify*() is for MACs too +static bool isMacMechanism(CK_MECHANISM_PTR pMechanism) +{ + 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: +#ifdef WITH_GOST + case CKM_GOSTR3411_HMAC: +#endif + 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 (pMechanism == NULL_PTR) return CKR_ARGUMENTS_BAD; + + // Get the session + 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; + + // Get the token + 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; + + CK_BBOOL isOnToken = key->getBooleanValue(CKA_TOKEN, false); + CK_BBOOL isPrivate = key->getBooleanValue(CKA_PRIVATE, true); + + // Check read user credentials + CK_RV rv = haveRead(session->getState(), isOnToken, isPrivate); + if (rv != CKR_OK) + { + if (rv == CKR_USER_NOT_LOGGED_IN) + INFO_MSG("User is not authorized"); + + return rv; + } + + // Check if key can be used for signing + if (!key->getBooleanValue(CKA_SIGN, false)) + return CKR_KEY_FUNCTION_NOT_PERMITTED; + + // Check if the specified mechanism is allowed for the key + if (!isMechanismPermitted(key, pMechanism)) + return CKR_MECHANISM_INVALID; + + // Get key info + CK_KEY_TYPE keyType = key->getUnsignedLongValue(CKA_KEY_TYPE, CKK_VENDOR_DEFINED); + + // Get the MAC algorithm matching the mechanism + // Also check mechanism constraints + MacAlgo::Type algo = MacAlgo::Unknown; + size_t bb = 8; + size_t minSize = 0; + 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; +#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) + { + mac->recycleKey(privkey); + CryptoFactory::i()->recycleMacAlgorithm(mac); + return CKR_GENERAL_ERROR; + } + + // Adjust key bit length + privkey->setBitLen(privkey->getKeyBits().size() * bb); + + // Check key size + if (privkey->getBitLen() < (minSize*8)) + { + mac->recycleKey(privkey); + CryptoFactory::i()->recycleMacAlgorithm(mac); + return CKR_KEY_SIZE_RANGE; + } + + // Initialize signing + if (!mac->signInit(privkey)) + { + mac->recycleKey(privkey); + CryptoFactory::i()->recycleMacAlgorithm(mac); + return CKR_MECHANISM_INVALID; + } + + session->setOpType(SESSION_OP_SIGN); + session->setMacOp(mac); + session->setAllowMultiPartOp(true); + session->setAllowSinglePartOp(true); + session->setSymmetricKey(privkey); + + return CKR_OK; +} + +// 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 (pMechanism == NULL_PTR) return CKR_ARGUMENTS_BAD; + + // Get the session + 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; + + // Get the token + 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; + + CK_BBOOL isOnToken = key->getBooleanValue(CKA_TOKEN, false); + CK_BBOOL isPrivate = key->getBooleanValue(CKA_PRIVATE, true); + + // Check read user credentials + CK_RV rv = haveRead(session->getState(), isOnToken, isPrivate); + if (rv != CKR_OK) + { + if (rv == CKR_USER_NOT_LOGGED_IN) + INFO_MSG("User is not authorized"); + + return rv; + } + + // Check if key can be used for signing + if (!key->getBooleanValue(CKA_SIGN, false)) + return CKR_KEY_FUNCTION_NOT_PERMITTED; + + // Check if the specified mechanism is allowed for the key + if (!isMechanismPermitted(key, pMechanism)) + return CKR_MECHANISM_INVALID; + + // Get the asymmetric algorithm matching the mechanism + AsymMech::Type mechanism = AsymMech::Unknown; + void* param = NULL; + size_t paramLen = 0; + RSA_PKCS_PSS_PARAMS pssParam; + bool bAllowMultiPartOp; + bool isRSA = false; + bool isDSA = false; + bool isECDSA = false; + 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; +#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; +#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; + } + + 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; +#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; +#endif + default: + return CKR_MECHANISM_INVALID; + } + + AsymmetricAlgorithm* asymCrypto = NULL; + PrivateKey* privateKey = NULL; + if (isRSA) + { + asymCrypto = CryptoFactory::i()->getAsymmetricAlgorithm(AsymAlgo::RSA); + if (asymCrypto == NULL) return CKR_MECHANISM_INVALID; + + privateKey = asymCrypto->newPrivateKey(); + if (privateKey == NULL) + { + CryptoFactory::i()->recycleAsymmetricAlgorithm(asymCrypto); + return CKR_HOST_MEMORY; + } + + if (getRSAPrivateKey((RSAPrivateKey*)privateKey, token, key) != CKR_OK) + { + asymCrypto->recyclePrivateKey(privateKey); + CryptoFactory::i()->recycleAsymmetricAlgorithm(asymCrypto); + return CKR_GENERAL_ERROR; + } + } + else if (isDSA) + { + asymCrypto = CryptoFactory::i()->getAsymmetricAlgorithm(AsymAlgo::DSA); + if (asymCrypto == NULL) return CKR_MECHANISM_INVALID; + + privateKey = asymCrypto->newPrivateKey(); + if (privateKey == NULL) + { + CryptoFactory::i()->recycleAsymmetricAlgorithm(asymCrypto); + return CKR_HOST_MEMORY; + } + + 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; + + privateKey = asymCrypto->newPrivateKey(); + if (privateKey == NULL) + { + CryptoFactory::i()->recycleAsymmetricAlgorithm(asymCrypto); + return CKR_HOST_MEMORY; + } + + if (getECPrivateKey((ECPrivateKey*)privateKey, token, key) != CKR_OK) + { + asymCrypto->recyclePrivateKey(privateKey); + CryptoFactory::i()->recycleAsymmetricAlgorithm(asymCrypto); + return CKR_GENERAL_ERROR; + } + } +#endif + else + { +#ifdef WITH_GOST + asymCrypto = CryptoFactory::i()->getAsymmetricAlgorithm(AsymAlgo::GOST); + if (asymCrypto == NULL) return CKR_MECHANISM_INVALID; + + privateKey = asymCrypto->newPrivateKey(); + if (privateKey == NULL) + { + CryptoFactory::i()->recycleAsymmetricAlgorithm(asymCrypto); + return CKR_HOST_MEMORY; + } + + if (getGOSTPrivateKey((GOSTPrivateKey*)privateKey, token, key) != CKR_OK) + { + asymCrypto->recyclePrivateKey(privateKey); + CryptoFactory::i()->recycleAsymmetricAlgorithm(asymCrypto); + return CKR_GENERAL_ERROR; + } +#else + return CKR_MECHANISM_INVALID; +#endif + } + + // Initialize signing + if (bAllowMultiPartOp && !asymCrypto->signInit(privateKey,mechanism,param,paramLen)) + { + asymCrypto->recyclePrivateKey(privateKey); + CryptoFactory::i()->recycleAsymmetricAlgorithm(asymCrypto); + return CKR_MECHANISM_INVALID; + } + + // Check if re-authentication is required + if (key->getBooleanValue(CKA_ALWAYS_AUTHENTICATE, false)) + { + session->setReAuthentication(true); + } + + session->setOpType(SESSION_OP_SIGN); + session->setAsymmetricCryptoOp(asymCrypto); + session->setMechanism(mechanism); + session->setParameters(param, paramLen); + session->setAllowMultiPartOp(bAllowMultiPartOp); + session->setAllowSinglePartOp(true); + session->setPrivateKey(privateKey); + + return CKR_OK; +} + +// Initialise a signing operation using the specified key and mechanism +CK_RV SoftHSM::C_SignInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechanism, CK_OBJECT_HANDLE hKey) +{ + if (isMacMechanism(pMechanism)) + return MacSignInit(hSession, pMechanism, hKey); + else + return AsymSignInit(hSession, pMechanism, hKey); +} + +// 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) +{ + MacAlgorithm* mac = session->getMacOp(); + if (mac == NULL || !session->getAllowSinglePartOp()) + { + session->resetOp(); + return CKR_OPERATION_NOT_INITIALIZED; + } + + // Size of the signature + CK_ULONG size = mac->getMacSize(); + if (pSignature == NULL_PTR) + { + *pulSignatureLen = size; + return CKR_OK; + } + + // Check buffer size + if (*pulSignatureLen < size) + { + *pulSignatureLen = size; + return CKR_BUFFER_TOO_SMALL; + } + + // Get the data + ByteString data(pData, ulDataLen); + + // Sign the data + if (!mac->signUpdate(data)) + { + session->resetOp(); + return CKR_GENERAL_ERROR; + } + + // Get the signature + ByteString signature; + if (!mac->signFinal(signature)) + { + session->resetOp(); + return CKR_GENERAL_ERROR; + } + + // Check size + if (signature.size() != size) + { + ERROR_MSG("The size of the signature differs from the size of the mechanism"); + session->resetOp(); + return CKR_GENERAL_ERROR; + } + memcpy(pSignature, signature.byte_str(), size); + *pulSignatureLen = size; + + session->resetOp(); + return CKR_OK; +} + +// 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) +{ + AsymmetricAlgorithm* asymCrypto = session->getAsymmetricCryptoOp(); + AsymMech::Type mechanism = session->getMechanism(); + PrivateKey* privateKey = session->getPrivateKey(); + size_t paramLen; + void* param = session->getParameters(paramLen); + if (asymCrypto == NULL || !session->getAllowSinglePartOp() || privateKey == NULL) + { + session->resetOp(); + return CKR_OPERATION_NOT_INITIALIZED; + } + + // Check if re-authentication is required + if (session->getReAuthentication()) + { + session->resetOp(); + return CKR_USER_NOT_LOGGED_IN; + } + + // Size of the signature + CK_ULONG size = privateKey->getOutputLength(); + if (pSignature == NULL_PTR) + { + *pulSignatureLen = size; + return CKR_OK; + } + + // Check buffer size + if (*pulSignatureLen < size) + { + *pulSignatureLen = size; + return CKR_BUFFER_TOO_SMALL; + } + + // Get the data + 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); + } + + data += ByteString(pData, ulDataLen); + ByteString signature; + + // Sign the data + if (session->getAllowMultiPartOp()) + { + if (!asymCrypto->signUpdate(data) || + !asymCrypto->signFinal(signature)) + { + session->resetOp(); + return CKR_GENERAL_ERROR; + } + } + else if (!asymCrypto->sign(privateKey,data,signature,mechanism,param,paramLen)) + { + session->resetOp(); + return CKR_GENERAL_ERROR; + } + + // Check size + if (signature.size() != size) + { + ERROR_MSG("The size of the signature differs from the size of the mechanism"); + session->resetOp(); + return CKR_GENERAL_ERROR; + } + memcpy(pSignature, signature.byte_str(), size); + *pulSignatureLen = size; + + session->resetOp(); + return CKR_OK; +} + +// 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 (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; + + // Check if we are doing the correct operation + if (session->getOpType() != SESSION_OP_SIGN) + return CKR_OPERATION_NOT_INITIALIZED; + + if (session->getMacOp() != NULL) + return MacSign(session, pData, ulDataLen, + pSignature, pulSignatureLen); + else + return AsymSign(session, pData, ulDataLen, + pSignature, pulSignatureLen); +} + +// MacAlgorithm version of C_SignUpdate +static CK_RV MacSignUpdate(Session* session, CK_BYTE_PTR pPart, CK_ULONG ulPartLen) +{ + MacAlgorithm* mac = session->getMacOp(); + if (mac == NULL || !session->getAllowMultiPartOp()) + { + session->resetOp(); + return CKR_OPERATION_NOT_INITIALIZED; + } + + // Get the part + ByteString part(pPart, ulPartLen); + + // Sign the data + if (!mac->signUpdate(part)) + { + session->resetOp(); + return CKR_GENERAL_ERROR; + } + + session->setAllowSinglePartOp(false); + return CKR_OK; +} + +// AsymmetricAlgorithm version of C_SignUpdate +static CK_RV AsymSignUpdate(Session* session, CK_BYTE_PTR pPart, CK_ULONG ulPartLen) +{ + AsymmetricAlgorithm* asymCrypto = session->getAsymmetricCryptoOp(); + if (asymCrypto == NULL || !session->getAllowMultiPartOp()) + { + session->resetOp(); + return CKR_OPERATION_NOT_INITIALIZED; + } + + // Check if re-authentication is required + if (session->getReAuthentication()) + { + session->resetOp(); + return CKR_USER_NOT_LOGGED_IN; + } + + // Get the part + ByteString part(pPart, ulPartLen); + + // Sign the data + if (!asymCrypto->signUpdate(part)) + { + session->resetOp(); + return CKR_GENERAL_ERROR; + } + + session->setAllowSinglePartOp(false); + return CKR_OK; +} + +// 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 (pPart == NULL_PTR) return CKR_ARGUMENTS_BAD; + + // Get the session + 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) + return CKR_OPERATION_NOT_INITIALIZED; + + if (session->getMacOp() != NULL) + return MacSignUpdate(session, pPart, ulPartLen); + else + return AsymSignUpdate(session, pPart, ulPartLen); +} + +// MacAlgorithm version of C_SignFinal +static CK_RV MacSignFinal(Session* session, CK_BYTE_PTR pSignature, CK_ULONG_PTR pulSignatureLen) +{ + MacAlgorithm* mac = session->getMacOp(); + if (mac == NULL) + { + session->resetOp(); + return CKR_OPERATION_NOT_INITIALIZED; + } + + // Size of the signature + CK_ULONG size = mac->getMacSize(); + if (pSignature == NULL_PTR) + { + *pulSignatureLen = size; + return CKR_OK; + } + + // Check buffer size + if (*pulSignatureLen < size) + { + *pulSignatureLen = size; + return CKR_BUFFER_TOO_SMALL; + } + + // Get the signature + ByteString signature; + if (!mac->signFinal(signature)) + { + session->resetOp(); + return CKR_GENERAL_ERROR; + } + + // Check size + if (signature.size() != size) + { + ERROR_MSG("The size of the signature differs from the size of the mechanism"); + session->resetOp(); + return CKR_GENERAL_ERROR; + } + memcpy(pSignature, signature.byte_str(), size); + *pulSignatureLen = size; + + session->resetOp(); + return CKR_OK; +} + +// AsymmetricAlgorithm version of C_SignFinal +static CK_RV AsymSignFinal(Session* session, CK_BYTE_PTR pSignature, CK_ULONG_PTR pulSignatureLen) +{ + AsymmetricAlgorithm* asymCrypto = session->getAsymmetricCryptoOp(); + PrivateKey* privateKey = session->getPrivateKey(); + if (asymCrypto == NULL || privateKey == NULL) + { + session->resetOp(); + return CKR_OPERATION_NOT_INITIALIZED; + } + + // Check if re-authentication is required + if (session->getReAuthentication()) + { + session->resetOp(); + return CKR_USER_NOT_LOGGED_IN; + } + + // Size of the signature + CK_ULONG size = privateKey->getOutputLength(); + if (pSignature == NULL_PTR) + { + *pulSignatureLen = size; + return CKR_OK; + } + + // Check buffer size + if (*pulSignatureLen < size) + { + *pulSignatureLen = size; + return CKR_BUFFER_TOO_SMALL; + } + + // Get the signature + ByteString signature; + if (!asymCrypto->signFinal(signature)) + { + session->resetOp(); + return CKR_GENERAL_ERROR; + } + + // Check size + if (signature.size() != size) + { + ERROR_MSG("The size of the signature differs from the size of the mechanism"); + session->resetOp(); + return CKR_GENERAL_ERROR; + } + memcpy(pSignature, signature.byte_str(), size); + *pulSignatureLen = size; + + session->resetOp(); + return CKR_OK; +} + +// 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 (pulSignatureLen == NULL_PTR) return CKR_ARGUMENTS_BAD; + + // Get the session + 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()) + return CKR_OPERATION_NOT_INITIALIZED; + + if (session->getMacOp() != NULL) + return MacSignFinal(session, pSignature, pulSignatureLen); + else + return AsymSignFinal(session, pSignature, pulSignatureLen); +} + +// 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; + + // Get the session + 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; + + return CKR_FUNCTION_NOT_SUPPORTED; +} + +// 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; + + // Get the session + Session* session = (Session*)handleManager->getSession(hSession); + if (session == NULL) return CKR_SESSION_HANDLE_INVALID; + + return CKR_FUNCTION_NOT_SUPPORTED; +} + +// 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 (pMechanism == NULL_PTR) return CKR_ARGUMENTS_BAD; + + // Get the session + 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; + + // Get the token + 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; + + CK_BBOOL isOnToken = key->getBooleanValue(CKA_TOKEN, false); + CK_BBOOL isPrivate = key->getBooleanValue(CKA_PRIVATE, true); + + // Check read user credentials + CK_RV rv = haveRead(session->getState(), isOnToken, isPrivate); + if (rv != CKR_OK) + { + if (rv == CKR_USER_NOT_LOGGED_IN) + INFO_MSG("User is not authorized"); + + return rv; + } + + // Check if key can be used for verifying + if (!key->getBooleanValue(CKA_VERIFY, false)) + return CKR_KEY_FUNCTION_NOT_PERMITTED; + + // Check if the specified mechanism is allowed for the key + if (!isMechanismPermitted(key, pMechanism)) + return CKR_MECHANISM_INVALID; + + // Get key info + CK_KEY_TYPE keyType = key->getUnsignedLongValue(CKA_KEY_TYPE, CKK_VENDOR_DEFINED); + + // Get the MAC algorithm matching the mechanism + // Also check mechanism constraints + MacAlgo::Type algo = MacAlgo::Unknown; + size_t bb = 8; + size_t minSize = 0; + 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; +#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* pubkey = new SymmetricKey(); + + if (getSymmetricKey(pubkey, token, key) != CKR_OK) + { + mac->recycleKey(pubkey); + CryptoFactory::i()->recycleMacAlgorithm(mac); + return CKR_GENERAL_ERROR; + } + + // Adjust key bit length + pubkey->setBitLen(pubkey->getKeyBits().size() * bb); + + // Check key size + if (pubkey->getBitLen() < (minSize*8)) + { + mac->recycleKey(pubkey); + CryptoFactory::i()->recycleMacAlgorithm(mac); + return CKR_KEY_SIZE_RANGE; + } + + // Initialize verifying + if (!mac->verifyInit(pubkey)) + { + mac->recycleKey(pubkey); + CryptoFactory::i()->recycleMacAlgorithm(mac); + return CKR_MECHANISM_INVALID; + } + + session->setOpType(SESSION_OP_VERIFY); + session->setMacOp(mac); + session->setAllowMultiPartOp(true); + session->setAllowSinglePartOp(true); + session->setSymmetricKey(pubkey); + + return CKR_OK; +} + +// 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 (pMechanism == NULL_PTR) return CKR_ARGUMENTS_BAD; + + // Get the session + 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; + + // Get the token + 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; + + CK_BBOOL isOnToken = key->getBooleanValue(CKA_TOKEN, false); + CK_BBOOL isPrivate = key->getBooleanValue(CKA_PRIVATE, true); + + // Check read user credentials + CK_RV rv = haveRead(session->getState(), isOnToken, isPrivate); + if (rv != CKR_OK) + { + if (rv == CKR_USER_NOT_LOGGED_IN) + INFO_MSG("User is not authorized"); + + return rv; + } + + // Check if key can be used for verifying + if (!key->getBooleanValue(CKA_VERIFY, false)) + return CKR_KEY_FUNCTION_NOT_PERMITTED; + + // Check if the specified mechanism is allowed for the key + if (!isMechanismPermitted(key, pMechanism)) + return CKR_MECHANISM_INVALID; + + // Get the asymmetric algorithm matching the mechanism + AsymMech::Type mechanism = AsymMech::Unknown; + void* param = NULL; + size_t paramLen = 0; + RSA_PKCS_PSS_PARAMS pssParam; + bool bAllowMultiPartOp; + bool isRSA = false; + bool isDSA = false; + bool isECDSA = false; + 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; +#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; +#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; + 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; +#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; +#endif + default: + return CKR_MECHANISM_INVALID; + } + + AsymmetricAlgorithm* asymCrypto = NULL; + PublicKey* publicKey = NULL; + if (isRSA) + { + asymCrypto = CryptoFactory::i()->getAsymmetricAlgorithm(AsymAlgo::RSA); + if (asymCrypto == NULL) return CKR_MECHANISM_INVALID; + + publicKey = asymCrypto->newPublicKey(); + if (publicKey == NULL) + { + CryptoFactory::i()->recycleAsymmetricAlgorithm(asymCrypto); + return CKR_HOST_MEMORY; + } + + if (getRSAPublicKey((RSAPublicKey*)publicKey, token, key) != CKR_OK) + { + asymCrypto->recyclePublicKey(publicKey); + CryptoFactory::i()->recycleAsymmetricAlgorithm(asymCrypto); + return CKR_GENERAL_ERROR; + } + } + else if (isDSA) + { + asymCrypto = CryptoFactory::i()->getAsymmetricAlgorithm(AsymAlgo::DSA); + if (asymCrypto == NULL) return CKR_MECHANISM_INVALID; + + publicKey = asymCrypto->newPublicKey(); + if (publicKey == NULL) + { + CryptoFactory::i()->recycleAsymmetricAlgorithm(asymCrypto); + return CKR_HOST_MEMORY; + } + + 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; + + publicKey = asymCrypto->newPublicKey(); + if (publicKey == NULL) + { + CryptoFactory::i()->recycleAsymmetricAlgorithm(asymCrypto); + return CKR_HOST_MEMORY; + } + + if (getECPublicKey((ECPublicKey*)publicKey, token, key) != CKR_OK) + { + asymCrypto->recyclePublicKey(publicKey); + CryptoFactory::i()->recycleAsymmetricAlgorithm(asymCrypto); + return CKR_GENERAL_ERROR; + } + } +#endif + else + { +#ifdef WITH_GOST + asymCrypto = CryptoFactory::i()->getAsymmetricAlgorithm(AsymAlgo::GOST); + if (asymCrypto == NULL) return CKR_MECHANISM_INVALID; + + publicKey = asymCrypto->newPublicKey(); + if (publicKey == NULL) + { + CryptoFactory::i()->recycleAsymmetricAlgorithm(asymCrypto); + return CKR_HOST_MEMORY; + } + + if (getGOSTPublicKey((GOSTPublicKey*)publicKey, token, key) != CKR_OK) + { + asymCrypto->recyclePublicKey(publicKey); + CryptoFactory::i()->recycleAsymmetricAlgorithm(asymCrypto); + return CKR_GENERAL_ERROR; + } +#else + return CKR_MECHANISM_INVALID; +#endif + } + + // Initialize verifying + if (bAllowMultiPartOp && !asymCrypto->verifyInit(publicKey,mechanism,param,paramLen)) + { + asymCrypto->recyclePublicKey(publicKey); + CryptoFactory::i()->recycleAsymmetricAlgorithm(asymCrypto); + return CKR_MECHANISM_INVALID; + } + + session->setOpType(SESSION_OP_VERIFY); + session->setAsymmetricCryptoOp(asymCrypto); + session->setMechanism(mechanism); + session->setParameters(param, paramLen); + session->setAllowMultiPartOp(bAllowMultiPartOp); + session->setAllowSinglePartOp(true); + session->setPublicKey(publicKey); + + return CKR_OK; +} + +// Initialise a verification operation using the specified key and mechanism +CK_RV SoftHSM::C_VerifyInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechanism, CK_OBJECT_HANDLE hKey) +{ + if (isMacMechanism(pMechanism)) + return MacVerifyInit(hSession, pMechanism, hKey); + else + return AsymVerifyInit(hSession, pMechanism, hKey); +} + +// 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) +{ + MacAlgorithm* mac = session->getMacOp(); + if (mac == NULL || !session->getAllowSinglePartOp()) + { + session->resetOp(); + return CKR_OPERATION_NOT_INITIALIZED; + } + + // Size of the signature + CK_ULONG size = mac->getMacSize(); + + // Check buffer size + if (ulSignatureLen != size) + { + ERROR_MSG("The size of the signature differs from the size of the mechanism"); + session->resetOp(); + return CKR_SIGNATURE_LEN_RANGE; + } + + // Get the data + ByteString data(pData, ulDataLen); + + // Verify the data + if (!mac->verifyUpdate(data)) + { + session->resetOp(); + return CKR_GENERAL_ERROR; + } + + // Get the signature + ByteString signature(pSignature, ulSignatureLen); + + // Verify the signature + if (!mac->verifyFinal(signature)) + { + session->resetOp(); + return CKR_SIGNATURE_INVALID; + } + + session->resetOp(); + return CKR_OK; +} + +// 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) +{ + AsymmetricAlgorithm* asymCrypto = session->getAsymmetricCryptoOp(); + AsymMech::Type mechanism = session->getMechanism(); + PublicKey* publicKey = session->getPublicKey(); + size_t paramLen; + void* param = session->getParameters(paramLen); + if (asymCrypto == NULL || !session->getAllowSinglePartOp() || publicKey == NULL) + { + session->resetOp(); + return CKR_OPERATION_NOT_INITIALIZED; + } + + // Size of the signature + CK_ULONG size = publicKey->getOutputLength(); + + // Check buffer size + if (ulSignatureLen != size) + { + ERROR_MSG("The size of the signature differs from the size of the mechanism"); + session->resetOp(); + return CKR_SIGNATURE_LEN_RANGE; + } + + // Get the data + 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); + } + + data += ByteString(pData, ulDataLen); + ByteString signature(pSignature, ulSignatureLen); + + // Verify the data + if (session->getAllowMultiPartOp()) + { + if (!asymCrypto->verifyUpdate(data) || + !asymCrypto->verifyFinal(signature)) + { + session->resetOp(); + return CKR_SIGNATURE_INVALID; + } + } + else if (!asymCrypto->verify(publicKey,data,signature,mechanism,param,paramLen)) + { + session->resetOp(); + return CKR_SIGNATURE_INVALID; + } + + session->resetOp(); + return CKR_OK; +} + +// 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 (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; + + // Check if we are doing the correct operation + if (session->getOpType() != SESSION_OP_VERIFY) + return CKR_OPERATION_NOT_INITIALIZED; + + if (session->getMacOp() != NULL) + return MacVerify(session, pData, ulDataLen, + pSignature, ulSignatureLen); + else + return AsymVerify(session, pData, ulDataLen, + pSignature, ulSignatureLen); +} + +// MacAlgorithm version of C_VerifyUpdate +static CK_RV MacVerifyUpdate(Session* session, CK_BYTE_PTR pPart, CK_ULONG ulPartLen) +{ + MacAlgorithm* mac = session->getMacOp(); + if (mac == NULL || !session->getAllowMultiPartOp()) + { + session->resetOp(); + return CKR_OPERATION_NOT_INITIALIZED; + } + + // Get the part + ByteString part(pPart, ulPartLen); + + // Verify the data + if (!mac->verifyUpdate(part)) + { + // verifyUpdate can't fail for a logical reason, so we assume total breakdown. + session->resetOp(); + return CKR_GENERAL_ERROR; + } + + session->setAllowSinglePartOp(false); + return CKR_OK; +} + +// AsymmetricAlgorithm version of C_VerifyUpdate +static CK_RV AsymVerifyUpdate(Session* session, CK_BYTE_PTR pPart, CK_ULONG ulPartLen) +{ + AsymmetricAlgorithm* asymCrypto = session->getAsymmetricCryptoOp(); + if (asymCrypto == NULL || !session->getAllowMultiPartOp()) + { + session->resetOp(); + return CKR_OPERATION_NOT_INITIALIZED; + } + + // Get the part + ByteString part(pPart, ulPartLen); + + // Verify the data + if (!asymCrypto->verifyUpdate(part)) + { + // verifyUpdate can't fail for a logical reason, so we assume total breakdown. + session->resetOp(); + return CKR_GENERAL_ERROR; + } + + session->setAllowSinglePartOp(false); + return CKR_OK; +} + +// 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 (pPart == NULL_PTR) return CKR_ARGUMENTS_BAD; + + // Get the session + 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) + return CKR_OPERATION_NOT_INITIALIZED; + + if (session->getMacOp() != NULL) + return MacVerifyUpdate(session, pPart, ulPartLen); + else + return AsymVerifyUpdate(session, pPart, ulPartLen); +} + +// MacAlgorithm version of C_SignFinal +static CK_RV MacVerifyFinal(Session* session, CK_BYTE_PTR pSignature, CK_ULONG ulSignatureLen) +{ + MacAlgorithm* mac = session->getMacOp(); + if (mac == NULL) + { + session->resetOp(); + return CKR_OPERATION_NOT_INITIALIZED; + } + + // Size of the signature + CK_ULONG size = mac->getMacSize(); + + // Check buffer size + if (ulSignatureLen != size) + { + ERROR_MSG("The size of the signature differs from the size of the mechanism"); + session->resetOp(); + return CKR_SIGNATURE_LEN_RANGE; + } + + // Get the signature + ByteString signature(pSignature, ulSignatureLen); + + // Verify the data + if (!mac->verifyFinal(signature)) + { + session->resetOp(); + return CKR_SIGNATURE_INVALID; + } + + session->resetOp(); + return CKR_OK; +} + +// AsymmetricAlgorithm version of C_VerifyFinal +static CK_RV AsymVerifyFinal(Session* session, CK_BYTE_PTR pSignature, CK_ULONG ulSignatureLen) +{ + AsymmetricAlgorithm* asymCrypto = session->getAsymmetricCryptoOp(); + PublicKey* publicKey = session->getPublicKey(); + if (asymCrypto == NULL || publicKey == NULL) + { + session->resetOp(); + return CKR_OPERATION_NOT_INITIALIZED; + } + + // Size of the signature + CK_ULONG size = publicKey->getOutputLength(); + + // Check buffer size + if (ulSignatureLen != size) + { + ERROR_MSG("The size of the signature differs from the size of the mechanism"); + session->resetOp(); + return CKR_SIGNATURE_LEN_RANGE; + } + + // Get the data + ByteString signature(pSignature, ulSignatureLen); + + // Verify the data + if (!asymCrypto->verifyFinal(signature)) + { + session->resetOp(); + return CKR_SIGNATURE_INVALID; + } + + session->resetOp(); + return CKR_OK; +} + +// 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 (pSignature == NULL_PTR) return CKR_ARGUMENTS_BAD; + + // Get the session + 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()) + return CKR_OPERATION_NOT_INITIALIZED; + + if (session->getMacOp() != NULL) + return MacVerifyFinal(session, pSignature, ulSignatureLen); + else + return AsymVerifyFinal(session, pSignature, ulSignatureLen); +} + +// 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; + + // Get the session + 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; + + return CKR_FUNCTION_NOT_SUPPORTED; +} + +// 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; + + // Get the session + Session* session = (Session*)handleManager->getSession(hSession); + if (session == NULL) return CKR_SESSION_HANDLE_INVALID; + + return CKR_FUNCTION_NOT_SUPPORTED; +} + +// 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; + + // Get the session + Session* session = (Session*)handleManager->getSession(hSession); + if (session == NULL) return CKR_SESSION_HANDLE_INVALID; + + return CKR_FUNCTION_NOT_SUPPORTED; +} + +// 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; + + // Get the session + Session* session = (Session*)handleManager->getSession(hSession); + if (session == NULL) return CKR_SESSION_HANDLE_INVALID; + + return CKR_FUNCTION_NOT_SUPPORTED; +} + +// 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; + + // Get the session + Session* session = (Session*)handleManager->getSession(hSession); + if (session == NULL) return CKR_SESSION_HANDLE_INVALID; + + return CKR_FUNCTION_NOT_SUPPORTED; +} + +// 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; + + // Get the session + Session* session = (Session*)handleManager->getSession(hSession); + if (session == NULL) return CKR_SESSION_HANDLE_INVALID; + + return CKR_FUNCTION_NOT_SUPPORTED; +} + +// 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 (pMechanism == 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; + + // Check the mechanism, only accept DSA and DH parameters + // and symmetric ciphers + CK_OBJECT_CLASS objClass; + 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; +#ifndef WITH_FIPS + 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; + default: + return CKR_MECHANISM_INVALID; + } + + // Extract information from the template that is needed to create the object. + CK_BBOOL isOnToken = CK_FALSE; + CK_BBOOL isPrivate = CK_TRUE; + CK_CERTIFICATE_TYPE dummy; + bool isImplicit = true; + extractObjectInformation(pTemplate, ulCount, objClass, keyType, dummy, isOnToken, isPrivate, isImplicit); + + // Report errors and/or unexpected usage. + 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)) + return CKR_TEMPLATE_INCONSISTENT; + if (pMechanism->mechanism == CKM_DH_PKCS_PARAMETER_GEN && + (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)) + return CKR_TEMPLATE_INCONSISTENT; + if (pMechanism->mechanism == CKM_DES2_KEY_GEN && + (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)) + return CKR_TEMPLATE_INCONSISTENT; + if (pMechanism->mechanism == CKM_AES_KEY_GEN && + (objClass != CKO_SECRET_KEY || keyType != CKK_AES)) + return CKR_TEMPLATE_INCONSISTENT; + + // Check authorization + CK_RV rv = haveWrite(session->getState(), isOnToken, isPrivate); + if (rv != CKR_OK) + { + if (rv == CKR_USER_NOT_LOGGED_IN) + INFO_MSG("User is not authorized"); + if (rv == CKR_SESSION_READ_ONLY) + INFO_MSG("Session is read-only"); + + return rv; + } + + // Generate DSA domain parameters + if (pMechanism->mechanism == CKM_DSA_PARAMETER_GEN) + { + return this->generateDSAParameters(hSession, pTemplate, ulCount, phKey, isOnToken, isPrivate); + } + + // Generate DH domain parameters + if (pMechanism->mechanism == CKM_DH_PKCS_PARAMETER_GEN) + { + return this->generateDHParameters(hSession, pTemplate, ulCount, phKey, isOnToken, isPrivate); + } + + // Generate DES secret key + if (pMechanism->mechanism == CKM_DES_KEY_GEN) + { + return this->generateDES(hSession, pTemplate, ulCount, phKey, isOnToken, isPrivate); + } + + // Generate DES2 secret key + if (pMechanism->mechanism == CKM_DES2_KEY_GEN) + { + return this->generateDES2(hSession, pTemplate, ulCount, phKey, isOnToken, isPrivate); + } + + // Generate DES3 secret key + if (pMechanism->mechanism == CKM_DES3_KEY_GEN) + { + return this->generateDES3(hSession, pTemplate, ulCount, phKey, isOnToken, isPrivate); + } + + // Generate AES secret key + if (pMechanism->mechanism == CKM_AES_KEY_GEN) + { + return this->generateAES(hSession, pTemplate, ulCount, phKey, isOnToken, isPrivate); + } + + return CKR_GENERAL_ERROR; +} + +// Generate a key-pair using the specified mechanism +CK_RV SoftHSM::C_GenerateKeyPair +( + CK_SESSION_HANDLE hSession, + CK_MECHANISM_PTR pMechanism, + CK_ATTRIBUTE_PTR pPublicKeyTemplate, + CK_ULONG ulPublicKeyAttributeCount, + CK_ATTRIBUTE_PTR pPrivateKeyTemplate, + CK_ULONG ulPrivateKeyAttributeCount, + CK_OBJECT_HANDLE_PTR phPublicKey, + CK_OBJECT_HANDLE_PTR phPrivateKey +) +{ + if (!isInitialised) return CKR_CRYPTOKI_NOT_INITIALIZED; + + if (pMechanism == NULL_PTR) 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; + + // 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; +#ifdef WITH_ECC + case CKM_EC_KEY_PAIR_GEN: + keyType = CKK_EC; + break; +#endif +#ifdef WITH_GOST + case CKM_GOSTR3410_KEY_PAIR_GEN: + keyType = CKK_GOSTR3410; + break; +#endif + default: + return CKR_MECHANISM_INVALID; + } + CK_CERTIFICATE_TYPE dummy; + + // Extract information from the public key template that is needed to create the object. + CK_OBJECT_CLASS publicKeyClass = CKO_PUBLIC_KEY; + CK_BBOOL ispublicKeyToken = CK_FALSE; + CK_BBOOL ispublicKeyPrivate = CK_FALSE; + bool isPublicKeyImplicit = true; + extractObjectInformation(pPublicKeyTemplate, ulPublicKeyAttributeCount, publicKeyClass, keyType, dummy, ispublicKeyToken, ispublicKeyPrivate, isPublicKeyImplicit); + + // Report errors caused by accidental template mix-ups in the application using this cryptoki lib. + if (publicKeyClass != CKO_PUBLIC_KEY) + return CKR_ATTRIBUTE_VALUE_INVALID; + if (pMechanism->mechanism == CKM_RSA_PKCS_KEY_PAIR_GEN && keyType != CKK_RSA) + return CKR_TEMPLATE_INCONSISTENT; + if (pMechanism->mechanism == CKM_DSA_KEY_PAIR_GEN && keyType != CKK_DSA) + return CKR_TEMPLATE_INCONSISTENT; + if (pMechanism->mechanism == CKM_EC_KEY_PAIR_GEN && keyType != CKK_EC) + return CKR_TEMPLATE_INCONSISTENT; + if (pMechanism->mechanism == CKM_DH_PKCS_KEY_PAIR_GEN && keyType != CKK_DH) + return CKR_TEMPLATE_INCONSISTENT; + if (pMechanism->mechanism == CKM_GOSTR3410_KEY_PAIR_GEN && keyType != CKK_GOSTR3410) + return CKR_TEMPLATE_INCONSISTENT; + + // Extract information from the private key template that is needed to create the object. + CK_OBJECT_CLASS privateKeyClass = CKO_PRIVATE_KEY; + CK_BBOOL isprivateKeyToken = CK_FALSE; + CK_BBOOL isprivateKeyPrivate = CK_TRUE; + bool isPrivateKeyImplicit = true; + extractObjectInformation(pPrivateKeyTemplate, ulPrivateKeyAttributeCount, privateKeyClass, keyType, dummy, isprivateKeyToken, isprivateKeyPrivate, isPrivateKeyImplicit); + + // Report errors caused by accidental template mix-ups in the application using this cryptoki lib. + if (privateKeyClass != CKO_PRIVATE_KEY) + return CKR_ATTRIBUTE_VALUE_INVALID; + if (pMechanism->mechanism == CKM_RSA_PKCS_KEY_PAIR_GEN && keyType != CKK_RSA) + return CKR_TEMPLATE_INCONSISTENT; + if (pMechanism->mechanism == CKM_DSA_KEY_PAIR_GEN && keyType != CKK_DSA) + return CKR_TEMPLATE_INCONSISTENT; + if (pMechanism->mechanism == CKM_EC_KEY_PAIR_GEN && keyType != CKK_EC) + return CKR_TEMPLATE_INCONSISTENT; + if (pMechanism->mechanism == CKM_DH_PKCS_KEY_PAIR_GEN && keyType != CKK_DH) + return CKR_TEMPLATE_INCONSISTENT; + if (pMechanism->mechanism == CKM_GOSTR3410_KEY_PAIR_GEN && keyType != CKK_GOSTR3410) + return CKR_TEMPLATE_INCONSISTENT; + + // Check user credentials + CK_RV rv = haveWrite(session->getState(), ispublicKeyToken || isprivateKeyToken, ispublicKeyPrivate || isprivateKeyPrivate); + if (rv != CKR_OK) + { + if (rv == CKR_USER_NOT_LOGGED_IN) + INFO_MSG("User is not authorized"); + if (rv == CKR_SESSION_READ_ONLY) + INFO_MSG("Session is read-only"); + + return rv; + } + + // 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); + } + + // 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); + } + + // 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); + } + + // 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); + } + + // 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 CKR_GENERAL_ERROR; +} + +// Internal: Wrap blob using symmetric key +CK_RV SoftHSM::WrapKeySym +( + CK_MECHANISM_PTR pMechanism, + Token* token, + OSObject* wrapKey, + ByteString& keydata, + ByteString& wrapped +) +{ + // Get the symmetric algorithm matching the mechanism + SymAlgo::Type algo = SymAlgo::Unknown; + SymWrap::Type mode = SymWrap::Unknown; + size_t bb = 8; +#ifdef HAVE_AES_KEY_WRAP + CK_ULONG wrappedlen = keydata.size(); + + // [PKCS#11 v2.40, 2.14.3 AES Key Wrap] + // A key whose length is not a multiple of the AES Key Wrap block + // size (8 bytes) will be zero padded to fit. + CK_ULONG alignment = wrappedlen % 8; + if (alignment != 0) + { + keydata.resize(wrappedlen + 8 - alignment); + memset(&keydata[wrappedlen], 0, 8 - alignment); + wrappedlen = keydata.size(); + } +#endif + switch(pMechanism->mechanism) { +#ifdef HAVE_AES_KEY_WRAP + case CKM_AES_KEY_WRAP: + 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; +#endif + default: + return CKR_MECHANISM_INVALID; + } + SymmetricAlgorithm* cipher = CryptoFactory::i()->getSymmetricAlgorithm(algo); + if (cipher == NULL) return CKR_MECHANISM_INVALID; + + SymmetricKey* wrappingkey = new SymmetricKey(); + + if (getSymmetricKey(wrappingkey, token, wrapKey) != CKR_OK) + { + cipher->recycleKey(wrappingkey); + CryptoFactory::i()->recycleSymmetricAlgorithm(cipher); + return CKR_GENERAL_ERROR; + } + + // adjust key bit length + wrappingkey->setBitLen(wrappingkey->getKeyBits().size() * bb); + + // 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 +) +{ + const size_t bb = 8; + AsymAlgo::Type algo = AsymAlgo::Unknown; + AsymMech::Type mech = AsymMech::Unknown; + + 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; + + 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; + + case CKM_RSA_PKCS_OAEP: + mech = AsymMech::RSA_PKCS_OAEP; + // SHA-1 is the only supported option + // PKCS#11 2.40 draft 2 section 2.1.8: input length <= k-2-2hashLen + if (keydata.size() > modulus_length - 2 - 2 * 160 / 8) + return CKR_KEY_SIZE_RANGE; + break; + + default: + return CKR_MECHANISM_INVALID; + } + + AsymmetricAlgorithm* cipher = CryptoFactory::i()->getAsymmetricAlgorithm(algo); + if (cipher == NULL) return CKR_MECHANISM_INVALID; + + 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; + + default: + return CKR_MECHANISM_INVALID; + } + // Wrap the key + if (!cipher->wrapKey(publicKey, keydata, wrapped, mech)) + { + cipher->recyclePublicKey(publicKey); + CryptoFactory::i()->recycleAsymmetricAlgorithm(cipher); + return CKR_GENERAL_ERROR; + } + + cipher->recyclePublicKey(publicKey); + CryptoFactory::i()->recycleAsymmetricAlgorithm(cipher); + + return CKR_OK; +} + + +// Wrap the specified key using the specified wrapping key and mechanism +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 +) +{ + if (!isInitialised) return CKR_CRYPTOKI_NOT_INITIALIZED; + + 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; + + CK_RV rv; + // Check the mechanism, only accept advanced AES key wrapping and RSA + switch(pMechanism->mechanism) + { +#ifdef HAVE_AES_KEY_WRAP + case CKM_AES_KEY_WRAP: +#endif +#ifdef HAVE_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; + + default: + return CKR_MECHANISM_INVALID; + } + + // Get the token + 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; + + CK_BBOOL isWrapKeyOnToken = wrapKey->getBooleanValue(CKA_TOKEN, false); + CK_BBOOL isWrapKeyPrivate = wrapKey->getBooleanValue(CKA_PRIVATE, true); + + // Check user credentials for the wrapping key + rv = haveRead(session->getState(), isWrapKeyOnToken, isWrapKeyPrivate); + if (rv != CKR_OK) + { + if (rv == CKR_USER_NOT_LOGGED_IN) + INFO_MSG("User is not authorized"); + + return rv; + } + + // Check wrapping key class and type + if ((pMechanism->mechanism == CKM_AES_KEY_WRAP || pMechanism->mechanism == CKM_AES_KEY_WRAP_PAD) && wrapKey->getUnsignedLongValue(CKA_CLASS, CKO_VENDOR_DEFINED) != CKO_SECRET_KEY) + return CKR_WRAPPING_KEY_TYPE_INCONSISTENT; + if ((pMechanism->mechanism == CKM_RSA_PKCS || pMechanism->mechanism == CKM_RSA_PKCS_OAEP) && wrapKey->getUnsignedLongValue(CKA_CLASS, CKO_VENDOR_DEFINED) != CKO_PUBLIC_KEY) + return CKR_WRAPPING_KEY_TYPE_INCONSISTENT; + if (pMechanism->mechanism == CKM_AES_KEY_WRAP && wrapKey->getUnsignedLongValue(CKA_KEY_TYPE, CKK_VENDOR_DEFINED) != CKK_AES) + return CKR_WRAPPING_KEY_TYPE_INCONSISTENT; + if (pMechanism->mechanism == CKM_AES_KEY_WRAP_PAD && wrapKey->getUnsignedLongValue(CKA_KEY_TYPE, CKK_VENDOR_DEFINED) != CKK_AES) + return CKR_WRAPPING_KEY_TYPE_INCONSISTENT; + if ((pMechanism->mechanism == CKM_RSA_PKCS || pMechanism->mechanism == CKM_RSA_PKCS_OAEP) && wrapKey->getUnsignedLongValue(CKA_KEY_TYPE, CKK_VENDOR_DEFINED) != CKK_RSA) + return CKR_WRAPPING_KEY_TYPE_INCONSISTENT; + + // Check if the wrapping key can be used for wrapping + if (wrapKey->getBooleanValue(CKA_WRAP, false) == false) + return CKR_KEY_FUNCTION_NOT_PERMITTED; + + // Check if the specified mechanism is allowed for the wrapping key + if (!isMechanismPermitted(wrapKey, pMechanism)) + return CKR_MECHANISM_INVALID; + + // Check the to be wrapped key handle. + OSObject *key = (OSObject *)handleManager->getObject(hKey); + 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); + + // Check user credentials for the to be wrapped key + rv = haveRead(session->getState(), isKeyOnToken, isKeyPrivate); + if (rv != CKR_OK) + { + if (rv == CKR_USER_NOT_LOGGED_IN) + INFO_MSG("User is not authorized"); + + return rv; + } + + // Check if the to be wrapped key can be wrapped + if (key->getBooleanValue(CKA_EXTRACTABLE, false) == false) + return CKR_KEY_UNEXTRACTABLE; + if (key->getBooleanValue(CKA_WRAP_WITH_TRUSTED, false) && wrapKey->getBooleanValue(CKA_TRUSTED, false) == false) + return CKR_KEY_NOT_WRAPPABLE; + + // Check the class + CK_OBJECT_CLASS keyClass = key->getUnsignedLongValue(CKA_CLASS, CKO_VENDOR_DEFINED); + if (keyClass != CKO_SECRET_KEY && keyClass != CKO_PRIVATE_KEY) + return CKR_KEY_NOT_WRAPPABLE; + // CKM_RSA_PKCS and CKM_RSA_PKCS_OAEP can be used only on SECRET keys: PKCS#11 2.40 draft 2 section 2.1.6 PKCS #1 v1.5 RSA & section 2.1.8 PKCS #1 RSA OAEP + if ((pMechanism->mechanism == CKM_RSA_PKCS || pMechanism->mechanism == CKM_RSA_PKCS_OAEP) && keyClass != CKO_SECRET_KEY) + return CKR_KEY_NOT_WRAPPABLE; + + // Verify the wrap template attribute + if (wrapKey->attributeExists(CKA_WRAP_TEMPLATE)) + { + OSAttribute attr = wrapKey->getAttribute(CKA_WRAP_TEMPLATE); + + if (attr.isAttributeMapAttribute()) + { + typedef std::map<CK_ATTRIBUTE_TYPE,OSAttribute> attrmap_type; + + const attrmap_type& map = attr.getAttributeMapValue(); + + for (attrmap_type::const_iterator it = map.begin(); it != map.end(); ++it) + { + if (!key->attributeExists(it->first)) + { + return CKR_KEY_NOT_WRAPPABLE; + } + + OSAttribute keyAttr = key->getAttribute(it->first); + ByteString v1, v2; + if (!keyAttr.peekValue(v1) || !it->second.peekValue(v2) || (v1 != v2)) + { + return CKR_KEY_NOT_WRAPPABLE; + } + } + } + } + + // Get the key data to encrypt + ByteString keydata; + if (keyClass == CKO_SECRET_KEY) + { + if (isKeyPrivate) + { + bool bOK = token->decrypt(key->getByteStringValue(CKA_VALUE), keydata); + if (!bOK) return CKR_GENERAL_ERROR; + } + else + { + keydata = key->getByteStringValue(CKA_VALUE); + } + } + else + { + 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; +#ifdef WITH_ECC + case CKK_EC: + // can be ecdh too but it doesn't matter + alg = AsymAlgo::ECDSA; + break; +#endif + default: + return CKR_KEY_NOT_WRAPPABLE; + } + AsymmetricAlgorithm* asymCrypto = NULL; + PrivateKey* privateKey = NULL; + asymCrypto = CryptoFactory::i()->getAsymmetricAlgorithm(alg); + if (asymCrypto == NULL) + return CKR_GENERAL_ERROR; + privateKey = asymCrypto->newPrivateKey(); + if (privateKey == NULL) + { + 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; +#ifdef WITH_ECC + case CKK_EC: + rv = getECPrivateKey((ECPrivateKey*)privateKey, token, key); + break; +#endif + } + if (rv != CKR_OK) + { + asymCrypto->recyclePrivateKey(privateKey); + CryptoFactory::i()->recycleAsymmetricAlgorithm(asymCrypto); + return CKR_GENERAL_ERROR; + } + keydata = privateKey->PKCS8Encode(); + asymCrypto->recyclePrivateKey(privateKey); + CryptoFactory::i()->recycleAsymmetricAlgorithm(asymCrypto); + } + if (keydata.size() == 0) + return CKR_KEY_NOT_WRAPPABLE; + + keyClass = wrapKey->getUnsignedLongValue(CKA_CLASS, CKO_VENDOR_DEFINED); + ByteString wrapped; + if (keyClass == CKO_SECRET_KEY) + rv = SoftHSM::WrapKeySym(pMechanism, token, wrapKey, keydata, wrapped); + else + rv = SoftHSM::WrapKeyAsym(pMechanism, token, wrapKey, keydata, wrapped); + if (rv != CKR_OK) + return rv; + + if (pWrappedKey != NULL) { + if (*pulWrappedKeyLen >= wrapped.size()) + memcpy(pWrappedKey, wrapped.byte_str(), wrapped.size()); + else + rv = CKR_BUFFER_TOO_SMALL; + } + + *pulWrappedKeyLen = wrapped.size(); + return rv; +} + +// Internal: Unwrap blob using symmetric key +CK_RV SoftHSM::UnwrapKeySym +( + CK_MECHANISM_PTR pMechanism, + 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; + switch(pMechanism->mechanism) { +#ifdef HAVE_AES_KEY_WRAP + 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; +#endif + default: + return CKR_MECHANISM_INVALID; + } + SymmetricAlgorithm* cipher = CryptoFactory::i()->getSymmetricAlgorithm(algo); + if (cipher == NULL) return CKR_MECHANISM_INVALID; + + SymmetricKey* unwrappingkey = new SymmetricKey(); + + if (getSymmetricKey(unwrappingkey, token, unwrapKey) != CKR_OK) + { + cipher->recycleKey(unwrappingkey); + CryptoFactory::i()->recycleSymmetricAlgorithm(cipher); + return CKR_GENERAL_ERROR; + } + + // adjust key bit length + unwrappingkey->setBitLen(unwrappingkey->getKeyBits().size() * bb); + + // Unwrap the key + CK_RV rv = CKR_OK; + if (!cipher->unwrapKey(unwrappingkey, mode, wrapped, keydata)) + rv = CKR_GENERAL_ERROR; + cipher->recycleKey(unwrappingkey); + CryptoFactory::i()->recycleSymmetricAlgorithm(cipher); + return rv; +} + +// Internal: Unwrap blob using asymmetric key +CK_RV SoftHSM::UnwrapKeyAsym +( + CK_MECHANISM_PTR pMechanism, + ByteString& wrapped, + Token* token, + OSObject* unwrapKey, + ByteString& keydata +) +{ + // 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; + + case CKM_RSA_PKCS_OAEP: + algo = AsymAlgo::RSA; + mode = AsymMech::RSA_PKCS_OAEP; + break; + + default: + return CKR_MECHANISM_INVALID; + } + AsymmetricAlgorithm* cipher = CryptoFactory::i()->getAsymmetricAlgorithm(algo); + if (cipher == NULL) return CKR_MECHANISM_INVALID; + + 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; + + default: + return CKR_MECHANISM_INVALID; + } + + // Unwrap the key + CK_RV rv = CKR_OK; + if (!cipher->unwrapKey(unwrappingkey, wrapped, keydata, mode)) + rv = CKR_GENERAL_ERROR; + cipher->recyclePrivateKey(unwrappingkey); + CryptoFactory::i()->recycleAsymmetricAlgorithm(cipher); + return rv; +} + +// Unwrap the specified key using the specified unwrapping key +CK_RV SoftHSM::C_UnwrapKey +( + CK_SESSION_HANDLE hSession, + CK_MECHANISM_PTR pMechanism, + CK_OBJECT_HANDLE hUnwrappingKey, + CK_BYTE_PTR pWrappedKey, + CK_ULONG ulWrappedKeyLen, + CK_ATTRIBUTE_PTR pTemplate, + CK_ULONG ulCount, + CK_OBJECT_HANDLE_PTR hKey +) +{ + 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; + + // Get the session + Session* session = (Session*)handleManager->getSession(hSession); + if (session == NULL) return CKR_SESSION_HANDLE_INVALID; + + CK_RV rv; + // Check the 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; +#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; +#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; + + default: + return CKR_MECHANISM_INVALID; + } + + // Get the token + 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; + + CK_BBOOL isUnwrapKeyOnToken = unwrapKey->getBooleanValue(CKA_TOKEN, false); + CK_BBOOL isUnwrapKeyPrivate = unwrapKey->getBooleanValue(CKA_PRIVATE, true); + + // Check user credentials + rv = haveRead(session->getState(), isUnwrapKeyOnToken, isUnwrapKeyPrivate); + if (rv != CKR_OK) + { + if (rv == CKR_USER_NOT_LOGGED_IN) + INFO_MSG("User is not authorized"); + + return rv; + } + + // Check unwrapping key class and type + if ((pMechanism->mechanism == CKM_AES_KEY_WRAP || pMechanism->mechanism == CKM_AES_KEY_WRAP_PAD) && unwrapKey->getUnsignedLongValue(CKA_CLASS, CKO_VENDOR_DEFINED) != CKO_SECRET_KEY) + return CKR_UNWRAPPING_KEY_TYPE_INCONSISTENT; + if (pMechanism->mechanism == CKM_AES_KEY_WRAP && unwrapKey->getUnsignedLongValue(CKA_KEY_TYPE, CKK_VENDOR_DEFINED) != CKK_AES) + return CKR_UNWRAPPING_KEY_TYPE_INCONSISTENT; + if (pMechanism->mechanism == CKM_AES_KEY_WRAP_PAD && unwrapKey->getUnsignedLongValue(CKA_KEY_TYPE, CKK_VENDOR_DEFINED) != CKK_AES) + return CKR_UNWRAPPING_KEY_TYPE_INCONSISTENT; + if ((pMechanism->mechanism == CKM_RSA_PKCS || pMechanism->mechanism == CKM_RSA_PKCS_OAEP) && unwrapKey->getUnsignedLongValue(CKA_CLASS, CKO_VENDOR_DEFINED) != CKO_PRIVATE_KEY) + return CKR_UNWRAPPING_KEY_TYPE_INCONSISTENT; + if ((pMechanism->mechanism == CKM_RSA_PKCS || pMechanism->mechanism == CKM_RSA_PKCS_OAEP) && unwrapKey->getUnsignedLongValue(CKA_KEY_TYPE, CKK_VENDOR_DEFINED) != CKK_RSA) + return CKR_UNWRAPPING_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; + + // Check if the specified mechanism is allowed for the unwrap key + if (!isMechanismPermitted(unwrapKey, pMechanism)) + return CKR_MECHANISM_INVALID; + + // Extract information from the template that is needed to create the object. + CK_OBJECT_CLASS objClass; + CK_KEY_TYPE keyType; + CK_BBOOL isOnToken = CK_FALSE; + CK_BBOOL isPrivate = CK_TRUE; + CK_CERTIFICATE_TYPE dummy; + bool isImplicit = false; + 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 && objClass != CKO_PRIVATE_KEY) + return CKR_ATTRIBUTE_VALUE_INVALID; + // Key type will be handled at object creation + + // Check authorization + rv = haveWrite(session->getState(), isOnToken, isPrivate); + if (rv != CKR_OK) + { + if (rv == CKR_USER_NOT_LOGGED_IN) + INFO_MSG("User is not authorized"); + if (rv == CKR_SESSION_READ_ONLY) + INFO_MSG("Session is read-only"); + + return rv; + } + + // 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) } + }; + CK_ULONG secretAttribsCount = 4; + + // Add the additional + if (ulCount > (maxAttribs - secretAttribsCount)) + return CKR_TEMPLATE_INCONSISTENT; + for (CK_ULONG i = 0; i < ulCount; ++i) + { + switch (pTemplate[i].type) + { + case CKA_CLASS: + case CKA_TOKEN: + case CKA_PRIVATE: + case CKA_KEY_TYPE: + continue; + default: + secretAttribs[secretAttribsCount++] = pTemplate[i]; + } + } + + // Apply the unwrap template + if (unwrapKey->attributeExists(CKA_UNWRAP_TEMPLATE)) + { + OSAttribute unwrapAttr = unwrapKey->getAttribute(CKA_UNWRAP_TEMPLATE); + + if (unwrapAttr.isAttributeMapAttribute()) + { + typedef std::map<CK_ATTRIBUTE_TYPE,OSAttribute> attrmap_type; + + const attrmap_type& map = unwrapAttr.getAttributeMapValue(); + + for (attrmap_type::const_iterator it = map.begin(); it != map.end(); ++it) + { + CK_ATTRIBUTE* attr = NULL; + for (CK_ULONG i = 0; i < secretAttribsCount; ++i) + { + if (it->first == secretAttribs[i].type) + { + if (attr != NULL) + { + return CKR_TEMPLATE_INCONSISTENT; + } + attr = &secretAttribs[i]; + ByteString value; + it->second.peekValue(value); + if (attr->ulValueLen != value.size()) + { + return CKR_TEMPLATE_INCONSISTENT; + } + if (memcmp(attr->pValue, value.const_byte_str(), value.size()) != 0) + { + return CKR_TEMPLATE_INCONSISTENT; + } + } + } + if (attr == NULL) + { + return CKR_TEMPLATE_INCONSISTENT; + } + } + } + } + + *hKey = CK_INVALID_HANDLE; + + // Unwrap the key + ByteString wrapped(pWrappedKey, ulWrappedKeyLen); + ByteString keydata; + if (unwrapKey->getUnsignedLongValue(CKA_CLASS, CKO_VENDOR_DEFINED) == CKO_SECRET_KEY) + rv = UnwrapKeySym(pMechanism, wrapped, token, unwrapKey, keydata); + else if (unwrapKey->getUnsignedLongValue(CKA_CLASS, CKO_VENDOR_DEFINED) == CKO_PRIVATE_KEY) + rv = UnwrapKeyAsym(pMechanism, wrapped, token, unwrapKey, keydata); + else + rv = CKR_UNWRAPPING_KEY_TYPE_INCONSISTENT; + if (rv != CKR_OK) + return rv; + + // Create the secret object using C_CreateObject + rv = this->CreateObject(hSession, secretAttribs, secretAttribsCount, hKey, OBJECT_OP_UNWRAP); + + // Store the attributes that are being supplied + if (rv == CKR_OK) + { + OSObject* osobject = (OSObject*)handleManager->getObject(*hKey); + if (osobject == NULL_PTR || !osobject->isValid()) + rv = CKR_FUNCTION_FAILED; + if (osobject->startTransaction()) + { + bool bOK = true; + + // Common Attributes + bOK = bOK && osobject->setAttribute(CKA_LOCAL, false); + + // Common Secret Key Attributes + bOK = bOK && osobject->setAttribute(CKA_ALWAYS_SENSITIVE, false); + bOK = bOK && osobject->setAttribute(CKA_NEVER_EXTRACTABLE, false); + + // Secret Attributes + if (objClass == CKO_SECRET_KEY) + { + ByteString value; + if (isPrivate) + token->encrypt(keydata, value); + else + value = keydata; + bOK = bOK && osobject->setAttribute(CKA_VALUE, value); + } + else if (keyType == CKK_RSA) + { + bOK = bOK && setRSAPrivateKey(osobject, keydata, token, isPrivate != CK_FALSE); + } + else if (keyType == CKK_DSA) + { + bOK = bOK && setDSAPrivateKey(osobject, keydata, token, isPrivate != CK_FALSE); + } + else if (keyType == CKK_DH) + { + bOK = bOK && setDHPrivateKey(osobject, keydata, token, isPrivate != CK_FALSE); + } + else if (keyType == CKK_EC) + { + bOK = bOK && setECPrivateKey(osobject, keydata, token, isPrivate != CK_FALSE); + } + else + bOK = false; + + if (bOK) + bOK = osobject->commitTransaction(); + else + osobject->abortTransaction(); + + if (!bOK) + rv = CKR_FUNCTION_FAILED; + } + else + rv = CKR_FUNCTION_FAILED; + } + + // Remove secret that may have been created already when the function fails. + if (rv != CKR_OK) + { + if (*hKey != CK_INVALID_HANDLE) + { + OSObject* obj = (OSObject*)handleManager->getObject(*hKey); + handleManager->destroyObject(*hKey); + if (obj) obj->destroyObject(); + *hKey = CK_INVALID_HANDLE; + } + + } + + return rv; +} + +// Derive a key from the specified base key +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 +) +{ + 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; + + // Get the session + 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: +#ifdef WITH_ECC + case CKM_ECDH1_DERIVE: +#endif +#ifndef WITH_FIPS + 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: + break; + default: + ERROR_MSG("Invalid mechanism"); + return CKR_MECHANISM_INVALID; + } + + // Get the token + 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; + + CK_BBOOL isKeyOnToken = key->getBooleanValue(CKA_TOKEN, false); + CK_BBOOL isKeyPrivate = key->getBooleanValue(CKA_PRIVATE, true); + + // Check user credentials + CK_RV rv = haveRead(session->getState(), isKeyOnToken, isKeyPrivate); + if (rv != CKR_OK) + { + if (rv == CKR_USER_NOT_LOGGED_IN) + INFO_MSG("User is not authorized"); + + return rv; + } + + // Check if key can be used for derive + if (!key->getBooleanValue(CKA_DERIVE, false)) + return CKR_KEY_FUNCTION_NOT_PERMITTED; + + // Check if the specified mechanism is allowed for the key + if (!isMechanismPermitted(key, pMechanism)) + return CKR_MECHANISM_INVALID; + + // Extract information from the template that is needed to create the object. + CK_OBJECT_CLASS objClass; + CK_KEY_TYPE keyType; + CK_BBOOL isOnToken = CK_FALSE; + CK_BBOOL isPrivate = CK_TRUE; + CK_CERTIFICATE_TYPE dummy; + bool isImplicit = false; + 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) + return CKR_TEMPLATE_INCONSISTENT; + + // Check authorization + rv = haveWrite(session->getState(), isOnToken, isPrivate); + if (rv != CKR_OK) + { + if (rv == CKR_USER_NOT_LOGGED_IN) + INFO_MSG("User is not authorized"); + if (rv == CKR_SESSION_READ_ONLY) + INFO_MSG("Session is read-only"); + + return rv; + } + + // Derive DH secret + if (pMechanism->mechanism == CKM_DH_PKCS_DERIVE) + { + // Check key class and type + if (key->getUnsignedLongValue(CKA_CLASS, CKO_VENDOR_DEFINED) != CKO_PRIVATE_KEY) + return CKR_KEY_TYPE_INCONSISTENT; + if (key->getUnsignedLongValue(CKA_KEY_TYPE, CKK_VENDOR_DEFINED) != CKK_DH) + return CKR_KEY_TYPE_INCONSISTENT; + + return this->deriveDH(hSession, pMechanism, hBaseKey, pTemplate, ulCount, phKey, keyType, isOnToken, isPrivate); + } + +#ifdef WITH_ECC + // Derive ECDH secret + if (pMechanism->mechanism == CKM_ECDH1_DERIVE) + { + // Check key class and type + if (key->getUnsignedLongValue(CKA_CLASS, CKO_VENDOR_DEFINED) != CKO_PRIVATE_KEY) + return CKR_KEY_TYPE_INCONSISTENT; + if (key->getUnsignedLongValue(CKA_KEY_TYPE, CKK_VENDOR_DEFINED) != CKK_EC) + return CKR_KEY_TYPE_INCONSISTENT; + + return this->deriveECDH(hSession, pMechanism, hBaseKey, pTemplate, ulCount, phKey, keyType, isOnToken, isPrivate); + } +#endif + + // 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) + { + // 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) + return CKR_KEY_TYPE_INCONSISTENT; + if (pMechanism->mechanism == CKM_DES_CBC_ENCRYPT_DATA && + baseKeyType != CKK_DES) + return CKR_KEY_TYPE_INCONSISTENT; + if (pMechanism->mechanism == CKM_DES3_ECB_ENCRYPT_DATA && + 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) + return CKR_KEY_TYPE_INCONSISTENT; + if (pMechanism->mechanism == CKM_AES_ECB_ENCRYPT_DATA && + baseKeyType != CKK_AES) + return CKR_KEY_TYPE_INCONSISTENT; + if (pMechanism->mechanism == CKM_AES_CBC_ENCRYPT_DATA && + baseKeyType != CKK_AES) + return CKR_KEY_TYPE_INCONSISTENT; + + return this->deriveSymmetric(hSession, pMechanism, hBaseKey, pTemplate, ulCount, phKey, keyType, isOnToken, isPrivate); + } + + return CKR_MECHANISM_INVALID; +} + +// 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 (pSeed == NULL_PTR) return CKR_ARGUMENTS_BAD; + + // Get the session + 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; + + // Seed the RNG + ByteString seed(pSeed, ulSeedLen); + rng->seed(seed); + + return CKR_OK; +} + +// 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 (pRandomData == NULL_PTR) return CKR_ARGUMENTS_BAD; + + // Get the session + 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; + + // Generate random data + ByteString randomData; + if (!rng->generateRandom(randomData, ulRandomLen)) return CKR_GENERAL_ERROR; + + // Return random data + if (ulRandomLen != 0) + { + memcpy(pRandomData, randomData.byte_str(), ulRandomLen); + } + + return CKR_OK; +} + +// Legacy function +CK_RV SoftHSM::C_GetFunctionStatus(CK_SESSION_HANDLE hSession) +{ + if (!isInitialised) return CKR_CRYPTOKI_NOT_INITIALIZED; + + // Get the session + Session* session = (Session*)handleManager->getSession(hSession); + if (session == NULL) return CKR_SESSION_HANDLE_INVALID; + + return CKR_FUNCTION_NOT_PARALLEL; +} + +// Legacy function +CK_RV SoftHSM::C_CancelFunction(CK_SESSION_HANDLE hSession) +{ + if (!isInitialised) return CKR_CRYPTOKI_NOT_INITIALIZED; + + // Get the session + Session* session = (Session*)handleManager->getSession(hSession); + if (session == NULL) return CKR_SESSION_HANDLE_INVALID; + + return CKR_FUNCTION_NOT_PARALLEL; +} + +// 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*/) +{ + return CKR_FUNCTION_NOT_SUPPORTED; +} + +// 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) +{ + *phKey = CK_INVALID_HANDLE; + + // Get the session + 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; + + // Extract desired parameter information + size_t keyLen = 0; + bool checkValue = true; + for (CK_ULONG i = 0; i < ulCount; i++) + { + 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; + } + } + + // CKA_VALUE_LEN must be specified + if (keyLen == 0) + { + INFO_MSG("Missing CKA_VALUE_LEN in pTemplate"); + return CKR_TEMPLATE_INCOMPLETE; + } + + // keyLen must be 16, 24, or 32 + if (keyLen != 16 && keyLen != 24 && keyLen != 32) + { + INFO_MSG("bad AES key length"); + return CKR_ATTRIBUTE_VALUE_INVALID; + } + + // Generate the secret key + 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(); + if (rng == NULL) + { + ERROR_MSG("Could not get RNG"); + aes->recycleKey(key); + CryptoFactory::i()->recycleSymmetricAlgorithm(aes); + return CKR_GENERAL_ERROR; + } + if (!aes->generateKey(*key, rng)) + { + ERROR_MSG("Could not generate AES secret key"); + aes->recycleKey(key); + CryptoFactory::i()->recycleSymmetricAlgorithm(aes); + return CKR_GENERAL_ERROR; + } + + 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_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) }, + }; + 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) + { + 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]; + } + } + + if (rv == CKR_OK) + 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()) { + rv = CKR_FUNCTION_FAILED; + } else if (osobject->startTransaction()) { + bool bOK = true; + + // Common Attributes + 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); + + // Common Secret Key Attributes + bool bAlwaysSensitive = osobject->getBooleanValue(CKA_SENSITIVE, false); + bOK = bOK && osobject->setAttribute(CKA_ALWAYS_SENSITIVE,bAlwaysSensitive); + bool bNeverExtractable = osobject->getBooleanValue(CKA_EXTRACTABLE, false) == false; + bOK = bOK && osobject->setAttribute(CKA_NEVER_EXTRACTABLE, bNeverExtractable); + + // AES Secret Key Attributes + ByteString value; + ByteString kcv; + if (isPrivate) + { + token->encrypt(key->getKeyBits(), value); + token->encrypt(key->getKeyCheckValue(), kcv); + } + else + { + value = key->getKeyBits(); + kcv = key->getKeyCheckValue(); + } + bOK = bOK && osobject->setAttribute(CKA_VALUE, value); + if (checkValue) + bOK = bOK && osobject->setAttribute(CKA_CHECK_VALUE, kcv); + + if (bOK) + bOK = osobject->commitTransaction(); + else + osobject->abortTransaction(); + + if (!bOK) + rv = CKR_FUNCTION_FAILED; + } else + rv = CKR_FUNCTION_FAILED; + } + + // Clean up + aes->recycleKey(key); + CryptoFactory::i()->recycleSymmetricAlgorithm(aes); + + // Remove the key that may have been created already when the function fails. + if (rv != CKR_OK) + { + if (*phKey != CK_INVALID_HANDLE) + { + OSObject* oskey = (OSObject*)handleManager->getObject(*phKey); + handleManager->destroyObject(*phKey); + if (oskey) oskey->destroyObject(); + *phKey = CK_INVALID_HANDLE; + } + } + + return rv; +} + +// 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) +{ + *phKey = CK_INVALID_HANDLE; + + // Get the session + 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; + + // Extract desired parameter information + bool checkValue = true; + for (CK_ULONG i = 0; i < ulCount; i++) + { + 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; + } + } + + // Generate the secret key + 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(); + if (rng == NULL) + { + ERROR_MSG("Could not get RNG"); + des->recycleKey(key); + CryptoFactory::i()->recycleSymmetricAlgorithm(des); + return CKR_GENERAL_ERROR; + } + if (!des->generateKey(*key, rng)) + { + ERROR_MSG("Could not generate DES secret key"); + des->recycleKey(key); + CryptoFactory::i()->recycleSymmetricAlgorithm(des); + return CKR_GENERAL_ERROR; + } + + 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_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) }, + }; + 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) + { + 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]; + } + } + + if (rv == CKR_OK) + 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()) { + rv = CKR_FUNCTION_FAILED; + } else if (osobject->startTransaction()) { + bool bOK = true; + + // Common Attributes + 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); + + // Common Secret Key Attributes + bool bAlwaysSensitive = osobject->getBooleanValue(CKA_SENSITIVE, false); + bOK = bOK && osobject->setAttribute(CKA_ALWAYS_SENSITIVE,bAlwaysSensitive); + bool bNeverExtractable = osobject->getBooleanValue(CKA_EXTRACTABLE, false) == false; + bOK = bOK && osobject->setAttribute(CKA_NEVER_EXTRACTABLE, bNeverExtractable); + + // DES Secret Key Attributes + ByteString value; + ByteString kcv; + if (isPrivate) + { + token->encrypt(key->getKeyBits(), value); + token->encrypt(key->getKeyCheckValue(), kcv); + } + else + { + value = key->getKeyBits(); + kcv = key->getKeyCheckValue(); + } + bOK = bOK && osobject->setAttribute(CKA_VALUE, value); + if (checkValue) + bOK = bOK && osobject->setAttribute(CKA_CHECK_VALUE, kcv); + + if (bOK) + bOK = osobject->commitTransaction(); + else + osobject->abortTransaction(); + + if (!bOK) + rv = CKR_FUNCTION_FAILED; + } else + rv = CKR_FUNCTION_FAILED; + } + + // Clean up + des->recycleKey(key); + CryptoFactory::i()->recycleSymmetricAlgorithm(des); + + // Remove the key that may have been created already when the function fails. + if (rv != CKR_OK) + { + if (*phKey != CK_INVALID_HANDLE) + { + OSObject* oskey = (OSObject*)handleManager->getObject(*phKey); + handleManager->destroyObject(*phKey); + if (oskey) oskey->destroyObject(); + *phKey = CK_INVALID_HANDLE; + } + } + + return rv; +} + +// 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) +{ + *phKey = CK_INVALID_HANDLE; + + // Get the session + 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; + + // Extract desired parameter information + bool checkValue = true; + for (CK_ULONG i = 0; i < ulCount; i++) + { + 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; + } + } + + // Generate the secret key + 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(); + if (rng == NULL) + { + ERROR_MSG("Could not get RNG"); + des->recycleKey(key); + CryptoFactory::i()->recycleSymmetricAlgorithm(des); + return CKR_GENERAL_ERROR; + } + if (!des->generateKey(*key, rng)) + { + ERROR_MSG("Could not generate DES secret key"); + des->recycleKey(key); + CryptoFactory::i()->recycleSymmetricAlgorithm(des); + return CKR_GENERAL_ERROR; + } + + 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_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) }, + }; + 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) + { + 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]; + } + } + + if (rv == CKR_OK) + 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()) { + rv = CKR_FUNCTION_FAILED; + } else if (osobject->startTransaction()) { + bool bOK = true; + + // Common Attributes + 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); + + // Common Secret Key Attributes + bool bAlwaysSensitive = osobject->getBooleanValue(CKA_SENSITIVE, false); + bOK = bOK && osobject->setAttribute(CKA_ALWAYS_SENSITIVE,bAlwaysSensitive); + bool bNeverExtractable = osobject->getBooleanValue(CKA_EXTRACTABLE, false) == false; + bOK = bOK && osobject->setAttribute(CKA_NEVER_EXTRACTABLE, bNeverExtractable); + + // DES Secret Key Attributes + ByteString value; + ByteString kcv; + if (isPrivate) + { + token->encrypt(key->getKeyBits(), value); + token->encrypt(key->getKeyCheckValue(), kcv); + } + else + { + value = key->getKeyBits(); + kcv = key->getKeyCheckValue(); + } + bOK = bOK && osobject->setAttribute(CKA_VALUE, value); + if (checkValue) + bOK = bOK && osobject->setAttribute(CKA_CHECK_VALUE, kcv); + + if (bOK) + bOK = osobject->commitTransaction(); + else + osobject->abortTransaction(); + + if (!bOK) + rv = CKR_FUNCTION_FAILED; + } else + rv = CKR_FUNCTION_FAILED; + } + + // Clean up + des->recycleKey(key); + CryptoFactory::i()->recycleSymmetricAlgorithm(des); + + // Remove the key that may have been created already when the function fails. + if (rv != CKR_OK) + { + if (*phKey != CK_INVALID_HANDLE) + { + OSObject* oskey = (OSObject*)handleManager->getObject(*phKey); + handleManager->destroyObject(*phKey); + if (oskey) oskey->destroyObject(); + *phKey = CK_INVALID_HANDLE; + } + } + + return rv; +} + +// 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) +{ + *phKey = CK_INVALID_HANDLE; + + // Get the session + 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; + + // Extract desired parameter information + bool checkValue = true; + for (CK_ULONG i = 0; i < ulCount; i++) + { + 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; + } + } + + // Generate the secret key + 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(); + if (rng == NULL) + { + ERROR_MSG("Could not get RNG"); + des->recycleKey(key); + CryptoFactory::i()->recycleSymmetricAlgorithm(des); + return CKR_GENERAL_ERROR; + } + if (!des->generateKey(*key, rng)) + { + ERROR_MSG("Could not generate DES secret key"); + des->recycleKey(key); + CryptoFactory::i()->recycleSymmetricAlgorithm(des); + return CKR_GENERAL_ERROR; + } + + 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_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) }, + }; + 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) + { + 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]; + } + } + + if (rv == CKR_OK) + 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()) { + rv = CKR_FUNCTION_FAILED; + } else if (osobject->startTransaction()) { + bool bOK = true; + + // Common Attributes + 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); + + // Common Secret Key Attributes + bool bAlwaysSensitive = osobject->getBooleanValue(CKA_SENSITIVE, false); + bOK = bOK && osobject->setAttribute(CKA_ALWAYS_SENSITIVE,bAlwaysSensitive); + bool bNeverExtractable = osobject->getBooleanValue(CKA_EXTRACTABLE, false) == false; + bOK = bOK && osobject->setAttribute(CKA_NEVER_EXTRACTABLE, bNeverExtractable); + + // DES Secret Key Attributes + ByteString value; + ByteString kcv; + if (isPrivate) + { + token->encrypt(key->getKeyBits(), value); + token->encrypt(key->getKeyCheckValue(), kcv); + } + else + { + value = key->getKeyBits(); + kcv = key->getKeyCheckValue(); + } + bOK = bOK && osobject->setAttribute(CKA_VALUE, value); + if (checkValue) + bOK = bOK && osobject->setAttribute(CKA_CHECK_VALUE, kcv); + + if (bOK) + bOK = osobject->commitTransaction(); + else + osobject->abortTransaction(); + + if (!bOK) + rv = CKR_FUNCTION_FAILED; + } else + rv = CKR_FUNCTION_FAILED; + } + + // Clean up + des->recycleKey(key); + CryptoFactory::i()->recycleSymmetricAlgorithm(des); + + // Remove the key that may have been created already when the function fails. + if (rv != CKR_OK) + { + if (*phKey != CK_INVALID_HANDLE) + { + OSObject* oskey = (OSObject*)handleManager->getObject(*phKey); + handleManager->destroyObject(*phKey); + if (oskey) oskey->destroyObject(); + *phKey = CK_INVALID_HANDLE; + } + } + + return rv; +} + +// 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 +) +{ + *phPublicKey = CK_INVALID_HANDLE; + *phPrivateKey = CK_INVALID_HANDLE; + + // Get the session + 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; + + // Extract desired key information: bitlen and public exponent + size_t bitLen = 0; + ByteString exponent("010001"); + for (CK_ULONG i = 0; i < ulPublicKeyAttributeCount; i++) + { + 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; + } + } + + // CKA_MODULUS_BITS must be specified to be able to generate a key pair. + if (bitLen == 0) { + INFO_MSG("Missing CKA_MODULUS_BITS in pPublicKeyTemplate"); + return CKR_TEMPLATE_INCOMPLETE; + } + + // Set the parameters + RSAParameters p; + p.setE(exponent); + p.setBitLength(bitLen); + + // Generate key pair + AsymmetricKeyPair* kp = NULL; + AsymmetricAlgorithm* rsa = CryptoFactory::i()->getAsymmetricAlgorithm(AsymAlgo::RSA); + if (rsa == NULL) + return CKR_GENERAL_ERROR; + if (!rsa->generateKeyPair(&kp, &p)) + { + ERROR_MSG("Could not generate key pair"); + CryptoFactory::i()->recycleAsymmetricAlgorithm(rsa); + return CKR_GENERAL_ERROR; + } + + RSAPublicKey* pub = (RSAPublicKey*) kp->getPublicKey(); + RSAPrivateKey* priv = (RSAPrivateKey*) kp->getPrivateKey(); + + CK_RV rv = CKR_OK; + + // Create a public key using C_CreateObject + if (rv == CKR_OK) + { + const CK_ULONG maxAttribs = 32; + 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) }, + }; + 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) + { + 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]; + } + } + + if (rv == CKR_OK) + 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()) { + rv = CKR_FUNCTION_FAILED; + } else if (osobject->startTransaction()) { + bool bOK = true; + + // Common Key Attributes + 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); + + // RSA Public Key Attributes + ByteString modulus; + ByteString publicExponent; + if (isPublicKeyPrivate) + { + token->encrypt(pub->getN(), modulus); + token->encrypt(pub->getE(), publicExponent); + } + else + { + modulus = pub->getN(); + publicExponent = pub->getE(); + } + bOK = bOK && osobject->setAttribute(CKA_MODULUS, modulus); + bOK = bOK && osobject->setAttribute(CKA_PUBLIC_EXPONENT, publicExponent); + + if (bOK) + bOK = osobject->commitTransaction(); + else + osobject->abortTransaction(); + + if (!bOK) + rv = CKR_FUNCTION_FAILED; + } else + rv = CKR_FUNCTION_FAILED; + } + } + + // Create a private key using C_CreateObject + if (rv == CKR_OK) + { + const CK_ULONG maxAttribs = 32; + 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) }, + }; + CK_ULONG privateKeyAttribsCount = 4; + if (ulPrivateKeyAttributeCount > (maxAttribs - privateKeyAttribsCount)) + rv = CKR_TEMPLATE_INCONSISTENT; + 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]; + } + } + + if (rv == CKR_OK) + 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()) { + rv = CKR_FUNCTION_FAILED; + } else if (osobject->startTransaction()) { + bool bOK = true; + + // Common Key Attributes + 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); + + // Common Private Key Attributes + bool bAlwaysSensitive = osobject->getBooleanValue(CKA_SENSITIVE, false); + bOK = bOK && osobject->setAttribute(CKA_ALWAYS_SENSITIVE,bAlwaysSensitive); + bool bNeverExtractable = osobject->getBooleanValue(CKA_EXTRACTABLE, false) == false; + bOK = bOK && osobject->setAttribute(CKA_NEVER_EXTRACTABLE, bNeverExtractable); + + // RSA Private Key Attributes + ByteString modulus; + ByteString publicExponent; + ByteString privateExponent; + ByteString prime1; + ByteString prime2; + ByteString exponent1; + ByteString exponent2; + ByteString coefficient; + if (isPrivateKeyPrivate) + { + token->encrypt(priv->getN(), modulus); + token->encrypt(priv->getE(), publicExponent); + token->encrypt(priv->getD(), privateExponent); + token->encrypt(priv->getP(), prime1); + token->encrypt(priv->getQ(), prime2); + token->encrypt(priv->getDP1(), exponent1); + token->encrypt(priv->getDQ1(), exponent2); + token->encrypt(priv->getPQ(), coefficient); + } + else + { + modulus = priv->getN(); + publicExponent = priv->getE(); + privateExponent = priv->getD(); + prime1 = priv->getP(); + prime2 = priv->getQ(); + exponent1 = priv->getDP1(); + exponent2 = priv->getDQ1(); + coefficient = priv->getPQ(); + } + bOK = bOK && osobject->setAttribute(CKA_MODULUS, modulus); + bOK = bOK && osobject->setAttribute(CKA_PUBLIC_EXPONENT, publicExponent); + 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_2, exponent2); + bOK = bOK && osobject->setAttribute(CKA_COEFFICIENT, coefficient); + + if (bOK) + bOK = osobject->commitTransaction(); + else + osobject->abortTransaction(); + + if (!bOK) + rv = CKR_FUNCTION_FAILED; + } else + rv = CKR_FUNCTION_FAILED; + } + } + + // Clean up + rsa->recycleKeyPair(kp); + CryptoFactory::i()->recycleAsymmetricAlgorithm(rsa); + + // Remove keys that may have been created already when the function fails. + if (rv != CKR_OK) + { + if (*phPrivateKey != CK_INVALID_HANDLE) + { + OSObject* ospriv = (OSObject*)handleManager->getObject(*phPrivateKey); + handleManager->destroyObject(*phPrivateKey); + if (ospriv) ospriv->destroyObject(); + *phPrivateKey = CK_INVALID_HANDLE; + } + + if (*phPublicKey != CK_INVALID_HANDLE) + { + OSObject* ospub = (OSObject*)handleManager->getObject(*phPublicKey); + handleManager->destroyObject(*phPublicKey); + if (ospub) ospub->destroyObject(); + *phPublicKey = CK_INVALID_HANDLE; + } + } + + return rv; +} + +// 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) +{ + *phPublicKey = CK_INVALID_HANDLE; + *phPrivateKey = CK_INVALID_HANDLE; + + // Get the session + 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; + + // Extract desired key information + ByteString prime; + ByteString subprime; + ByteString generator; + for (CK_ULONG i = 0; i < ulPublicKeyAttributeCount; i++) + { + 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; + } + } + + // The parameters must be specified to be able to generate a key pair. + if (prime.size() == 0 || subprime.size() == 0 || generator.size() == 0) { + INFO_MSG("Missing parameter(s) in pPublicKeyTemplate"); + return CKR_TEMPLATE_INCOMPLETE; + } + + // Set the parameters + DSAParameters p; + p.setP(prime); + p.setQ(subprime); + p.setG(generator); + + // Generate key pair + 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"); + CryptoFactory::i()->recycleAsymmetricAlgorithm(dsa); + return CKR_GENERAL_ERROR; + } + + DSAPublicKey* pub = (DSAPublicKey*) kp->getPublicKey(); + DSAPrivateKey* priv = (DSAPrivateKey*) kp->getPrivateKey(); + + CK_RV rv = CKR_OK; + + // Create a public key using C_CreateObject + if (rv == CKR_OK) + { + const CK_ULONG maxAttribs = 32; + 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) }, + }; + 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) + { + switch (pPublicKeyTemplate[i].type) + { + 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); + + // 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()) { + rv = CKR_FUNCTION_FAILED; + } else if (osobject->startTransaction()) { + bool bOK = true; + + // Common Key Attributes + 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); + + // DSA Public Key Attributes + ByteString value; + if (isPublicKeyPrivate) + { + token->encrypt(pub->getY(), value); + } + else + { + value = pub->getY(); + } + bOK = bOK && osobject->setAttribute(CKA_VALUE, value); + + if (bOK) + bOK = osobject->commitTransaction(); + else + osobject->abortTransaction(); + + if (!bOK) + rv = CKR_FUNCTION_FAILED; + } else + rv = CKR_FUNCTION_FAILED; + } + } + + // Create a private key using C_CreateObject + if (rv == CKR_OK) + { + const CK_ULONG maxAttribs = 32; + 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) }, + }; + CK_ULONG privateKeyAttribsCount = 4; + if (ulPrivateKeyAttributeCount > (maxAttribs - privateKeyAttribsCount)) + rv = CKR_TEMPLATE_INCONSISTENT; + 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]; + } + } + + if (rv == CKR_OK) + 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()) { + rv = CKR_FUNCTION_FAILED; + } else if (osobject->startTransaction()) { + bool bOK = true; + + // Common Key Attributes + 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); + + // Common Private Key Attributes + bool bAlwaysSensitive = osobject->getBooleanValue(CKA_SENSITIVE, false); + bOK = bOK && osobject->setAttribute(CKA_ALWAYS_SENSITIVE,bAlwaysSensitive); + bool bNeverExtractable = osobject->getBooleanValue(CKA_EXTRACTABLE, false) == false; + bOK = bOK && osobject->setAttribute(CKA_NEVER_EXTRACTABLE, bNeverExtractable); + + // DSA Private Key Attributes + ByteString bPrime; + ByteString bSubprime; + ByteString bGenerator; + ByteString bValue; + if (isPrivateKeyPrivate) + { + token->encrypt(priv->getP(), bPrime); + token->encrypt(priv->getQ(), bSubprime); + token->encrypt(priv->getG(), bGenerator); + token->encrypt(priv->getX(), bValue); + } + else + { + bPrime = priv->getP(); + bSubprime = priv->getQ(); + bGenerator = priv->getG(); + bValue = priv->getX(); + } + bOK = bOK && osobject->setAttribute(CKA_PRIME, bPrime); + bOK = bOK && osobject->setAttribute(CKA_SUBPRIME, bSubprime); + bOK = bOK && osobject->setAttribute(CKA_BASE, bGenerator); + bOK = bOK && osobject->setAttribute(CKA_VALUE, bValue); + + if (bOK) + bOK = osobject->commitTransaction(); + else + osobject->abortTransaction(); + + if (!bOK) + rv = CKR_FUNCTION_FAILED; + } else + rv = CKR_FUNCTION_FAILED; + } + } + + // Clean up + dsa->recycleKeyPair(kp); + CryptoFactory::i()->recycleAsymmetricAlgorithm(dsa); + + // Remove keys that may have been created already when the function fails. + if (rv != CKR_OK) + { + if (*phPrivateKey != CK_INVALID_HANDLE) + { + OSObject* ospriv = (OSObject*)handleManager->getObject(*phPrivateKey); + handleManager->destroyObject(*phPrivateKey); + if (ospriv) ospriv->destroyObject(); + *phPrivateKey = CK_INVALID_HANDLE; + } + + if (*phPublicKey != CK_INVALID_HANDLE) + { + OSObject* ospub = (OSObject*)handleManager->getObject(*phPublicKey); + handleManager->destroyObject(*phPublicKey); + if (ospub) ospub->destroyObject(); + *phPublicKey = CK_INVALID_HANDLE; + } + } + + return rv; +} + +// 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) +{ + *phKey = CK_INVALID_HANDLE; + + // Get the session + 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; + + // Extract desired parameter information + size_t bitLen = 0; + size_t qLen = 0; + for (CK_ULONG i = 0; i < ulCount; i++) + { + 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_SUBPRIME_BITS: + if (pTemplate[i].ulValueLen != sizeof(CK_ULONG)) + { + INFO_MSG("CKA_SUBPRIME_BITS does not have the size of CK_ULONG"); + return CKR_ATTRIBUTE_VALUE_INVALID; + } + qLen = *(CK_ULONG*)pTemplate[i].pValue; + break; + default: + break; + } + } + + // CKA_PRIME_BITS must be specified + if (bitLen == 0) + { + INFO_MSG("Missing CKA_PRIME_BITS in pTemplate"); + return CKR_TEMPLATE_INCOMPLETE; + } + + // No real choice for CKA_SUBPRIME_BITS + if ((qLen != 0) && + (((bitLen >= 2048) && (qLen != 256)) || + ((bitLen < 2048) && (qLen != 160)))) + INFO_MSG("CKA_SUBPRIME_BITS is ignored"); + + + // Generate domain parameters + 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"); + CryptoFactory::i()->recycleAsymmetricAlgorithm(dsa); + return CKR_GENERAL_ERROR; + } + + DSAParameters* params = (DSAParameters*) p; + + CK_RV rv = CKR_OK; + + // Create the domain parameter object using C_CreateObject + const CK_ULONG maxAttribs = 32; + 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) }, + }; + 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) + { + switch (pTemplate[i].type) + { + 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); + + // Store the attributes that are being supplied + if (rv == CKR_OK) + { + OSObject* osobject = (OSObject*)handleManager->getObject(*phKey); + if (osobject == NULL_PTR || !osobject->isValid()) { + rv = CKR_FUNCTION_FAILED; + } else if (osobject->startTransaction()) { + bool bOK = true; + + // Common Attributes + 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); + + // DSA Domain Parameters Attributes + ByteString prime; + ByteString subprime; + ByteString generator; + if (isPrivate) + { + token->encrypt(params->getP(), prime); + token->encrypt(params->getQ(), subprime); + token->encrypt(params->getG(), generator); + } + else + { + prime = params->getP(); + subprime = params->getQ(); + generator = params->getG(); + } + bOK = bOK && osobject->setAttribute(CKA_PRIME, prime); + bOK = bOK && osobject->setAttribute(CKA_SUBPRIME, subprime); + bOK = bOK && osobject->setAttribute(CKA_BASE, generator); + + if (bOK) + bOK = osobject->commitTransaction(); + else + osobject->abortTransaction(); + + if (!bOK) + rv = CKR_FUNCTION_FAILED; + } else + rv = CKR_FUNCTION_FAILED; + } + + // Clean up + dsa->recycleParameters(p); + CryptoFactory::i()->recycleAsymmetricAlgorithm(dsa); + + // Remove parameters that may have been created already when the function fails. + if (rv != CKR_OK) + { + if (*phKey != CK_INVALID_HANDLE) + { + OSObject* osparams = (OSObject*)handleManager->getObject(*phKey); + handleManager->destroyObject(*phKey); + if (osparams) osparams->destroyObject(); + *phKey = CK_INVALID_HANDLE; + } + } + + return rv; +} + +// 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) +{ + *phPublicKey = CK_INVALID_HANDLE; + *phPrivateKey = CK_INVALID_HANDLE; + + // Get the session + 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; + + // Extract desired key information + ByteString params; + for (CK_ULONG i = 0; i < ulPublicKeyAttributeCount; i++) + { + switch (pPublicKeyTemplate[i].type) + { + 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) { + INFO_MSG("Missing parameter(s) in pPublicKeyTemplate"); + return CKR_TEMPLATE_INCOMPLETE; + } + + // Set the parameters + ECParameters p; + p.setEC(params); + + // Generate key pair + 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"); + CryptoFactory::i()->recycleAsymmetricAlgorithm(ec); + return CKR_GENERAL_ERROR; + } + + ECPublicKey* pub = (ECPublicKey*) kp->getPublicKey(); + ECPrivateKey* priv = (ECPrivateKey*) kp->getPrivateKey(); + + CK_RV rv = CKR_OK; + + // Create a public key using C_CreateObject + if (rv == CKR_OK) + { + const CK_ULONG maxAttribs = 32; + 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) }, + }; + 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) + { + switch (pPublicKeyTemplate[i].type) + { + 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); + + // 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()) { + rv = CKR_FUNCTION_FAILED; + } else if (osobject->startTransaction()) { + bool bOK = true; + + // Common Key Attributes + 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); + + // EC Public Key Attributes + ByteString point; + if (isPublicKeyPrivate) + { + token->encrypt(pub->getQ(), point); + } + else + { + point = pub->getQ(); + } + bOK = bOK && osobject->setAttribute(CKA_EC_POINT, point); + + if (bOK) + bOK = osobject->commitTransaction(); + else + osobject->abortTransaction(); + + if (!bOK) + rv = CKR_FUNCTION_FAILED; + } else + rv = CKR_FUNCTION_FAILED; + } + } + + // Create a private key using C_CreateObject + if (rv == CKR_OK) + { + const CK_ULONG maxAttribs = 32; + 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) }, + }; + CK_ULONG privateKeyAttribsCount = 4; + if (ulPrivateKeyAttributeCount > (maxAttribs - privateKeyAttribsCount)) + rv = CKR_TEMPLATE_INCONSISTENT; + 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]; + } + } + + if (rv == CKR_OK) + 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()) { + rv = CKR_FUNCTION_FAILED; + } else if (osobject->startTransaction()) { + bool bOK = true; + + // Common Key Attributes + 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); + + // Common Private Key Attributes + bool bAlwaysSensitive = osobject->getBooleanValue(CKA_SENSITIVE, false); + bOK = bOK && osobject->setAttribute(CKA_ALWAYS_SENSITIVE,bAlwaysSensitive); + bool bNeverExtractable = osobject->getBooleanValue(CKA_EXTRACTABLE, false) == false; + bOK = bOK && osobject->setAttribute(CKA_NEVER_EXTRACTABLE, bNeverExtractable); + + // EC Private Key Attributes + ByteString group; + ByteString value; + if (isPrivateKeyPrivate) + { + token->encrypt(priv->getEC(), group); + token->encrypt(priv->getD(), value); + } + else + { + group = priv->getEC(); + value = priv->getD(); + } + bOK = bOK && osobject->setAttribute(CKA_EC_PARAMS, group); + bOK = bOK && osobject->setAttribute(CKA_VALUE, value); + + if (bOK) + bOK = osobject->commitTransaction(); + else + osobject->abortTransaction(); + + if (!bOK) + rv = CKR_FUNCTION_FAILED; + } else + rv = CKR_FUNCTION_FAILED; + } + } + + // Clean up + ec->recycleKeyPair(kp); + CryptoFactory::i()->recycleAsymmetricAlgorithm(ec); + + // Remove keys that may have been created already when the function fails. + if (rv != CKR_OK) + { + if (*phPrivateKey != CK_INVALID_HANDLE) + { + OSObject* ospriv = (OSObject*)handleManager->getObject(*phPrivateKey); + handleManager->destroyObject(*phPrivateKey); + if (ospriv) ospriv->destroyObject(); + *phPrivateKey = CK_INVALID_HANDLE; + } + + if (*phPublicKey != CK_INVALID_HANDLE) + { + OSObject* ospub = (OSObject*)handleManager->getObject(*phPublicKey); + handleManager->destroyObject(*phPublicKey); + if (ospub) ospub->destroyObject(); + *phPublicKey = CK_INVALID_HANDLE; + } + } + + return rv; +} + +// 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) +{ + *phPublicKey = CK_INVALID_HANDLE; + *phPrivateKey = CK_INVALID_HANDLE; + + // Get the session + 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; + + // Extract desired key information + ByteString prime; + ByteString generator; + for (CK_ULONG i = 0; i < ulPublicKeyAttributeCount; i++) + { + 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; + } + } + + // The parameters must be specified to be able to generate a key pair. + if (prime.size() == 0 || generator.size() == 0) { + INFO_MSG("Missing parameter(s) in pPublicKeyTemplate"); + return CKR_TEMPLATE_INCOMPLETE; + } + + // Extract optional bit length + size_t bitLen = 0; + for (CK_ULONG i = 0; i < ulPrivateKeyAttributeCount; i++) + { + switch (pPrivateKeyTemplate[i].type) + { + case CKA_VALUE_BITS: + bitLen = *(CK_ULONG*)pPrivateKeyTemplate[i].pValue; + break; + default: + break; + } + } + + // Set the parameters + DHParameters p; + p.setP(prime); + p.setG(generator); + p.setXBitLength(bitLen); + + // Generate key pair + 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"); + CryptoFactory::i()->recycleAsymmetricAlgorithm(dh); + return CKR_GENERAL_ERROR; + } + + DHPublicKey* pub = (DHPublicKey*) kp->getPublicKey(); + DHPrivateKey* priv = (DHPrivateKey*) kp->getPrivateKey(); + + CK_RV rv = CKR_OK; + + // Create a public key using C_CreateObject + if (rv == CKR_OK) + { + const CK_ULONG maxAttribs = 32; + 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) }, + }; + 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) + { + switch (pPublicKeyTemplate[i].type) + { + 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); + + // 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()) { + rv = CKR_FUNCTION_FAILED; + } else if (osobject->startTransaction()) { + bool bOK = true; + + // Common Key Attributes + 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); + + // DH Public Key Attributes + ByteString value; + if (isPublicKeyPrivate) + { + token->encrypt(pub->getY(), value); + } + else + { + value = pub->getY(); + } + bOK = bOK && osobject->setAttribute(CKA_VALUE, value); + + if (bOK) + bOK = osobject->commitTransaction(); + else + osobject->abortTransaction(); + + if (!bOK) + rv = CKR_FUNCTION_FAILED; + } else + rv = CKR_FUNCTION_FAILED; + } + } + + // Create a private key using C_CreateObject + if (rv == CKR_OK) + { + const CK_ULONG maxAttribs = 32; + 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) }, + }; + CK_ULONG privateKeyAttribsCount = 4; + if (ulPrivateKeyAttributeCount > (maxAttribs - privateKeyAttribsCount)) + rv = CKR_TEMPLATE_INCONSISTENT; + 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]; + } + } + + if (rv == CKR_OK) + 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()) { + rv = CKR_FUNCTION_FAILED; + } else if (osobject->startTransaction()) { + bool bOK = true; + + // Common Key Attributes + 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); + + // Common Private Key Attributes + bool bAlwaysSensitive = osobject->getBooleanValue(CKA_SENSITIVE, false); + bOK = bOK && osobject->setAttribute(CKA_ALWAYS_SENSITIVE,bAlwaysSensitive); + bool bNeverExtractable = osobject->getBooleanValue(CKA_EXTRACTABLE, false) == false; + bOK = bOK && osobject->setAttribute(CKA_NEVER_EXTRACTABLE, bNeverExtractable); + + // DH Private Key Attributes + ByteString bPrime; + ByteString bGenerator; + ByteString bValue; + if (isPrivateKeyPrivate) + { + token->encrypt(priv->getP(), bPrime); + token->encrypt(priv->getG(), bGenerator); + token->encrypt(priv->getX(), bValue); + } + else + { + bPrime = priv->getP(); + bGenerator = priv->getG(); + bValue = priv->getX(); + } + bOK = bOK && osobject->setAttribute(CKA_PRIME, bPrime); + bOK = bOK && osobject->setAttribute(CKA_BASE, bGenerator); + bOK = bOK && osobject->setAttribute(CKA_VALUE, bValue); + + if (bitLen == 0) + { + bOK = bOK && osobject->setAttribute(CKA_VALUE_BITS, (unsigned long)priv->getX().bits()); + } + + if (bOK) + bOK = osobject->commitTransaction(); + else + osobject->abortTransaction(); + + if (!bOK) + rv = CKR_FUNCTION_FAILED; + } else + rv = CKR_FUNCTION_FAILED; + } + } + + // Clean up + dh->recycleKeyPair(kp); + CryptoFactory::i()->recycleAsymmetricAlgorithm(dh); + + // Remove keys that may have been created already when the function fails. + if (rv != CKR_OK) + { + if (*phPrivateKey != CK_INVALID_HANDLE) + { + OSObject* ospriv = (OSObject*)handleManager->getObject(*phPrivateKey); + handleManager->destroyObject(*phPrivateKey); + if (ospriv) ospriv->destroyObject(); + *phPrivateKey = CK_INVALID_HANDLE; + } + + if (*phPublicKey != CK_INVALID_HANDLE) + { + OSObject* ospub = (OSObject*)handleManager->getObject(*phPublicKey); + handleManager->destroyObject(*phPublicKey); + if (ospub) ospub->destroyObject(); + *phPublicKey = CK_INVALID_HANDLE; + } + } + + return rv; +} + +// 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) +{ + *phKey = CK_INVALID_HANDLE; + + // Get the session + 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; + + // Extract desired parameter information + size_t bitLen = 0; + for (CK_ULONG i = 0; i < ulCount; i++) + { + 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; + } + } + + // CKA_PRIME_BITS must be specified + if (bitLen == 0) + { + INFO_MSG("Missing CKA_PRIME_BITS in pTemplate"); + return CKR_TEMPLATE_INCOMPLETE; + } + + // Generate domain parameters + 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"); + CryptoFactory::i()->recycleAsymmetricAlgorithm(dh); + return CKR_GENERAL_ERROR; + } + + DHParameters* params = (DHParameters*) p; + + CK_RV rv = CKR_OK; + + // Create the domain parameter object using C_CreateObject + const CK_ULONG maxAttribs = 32; + 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) }, + }; + 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) + { + switch (pTemplate[i].type) + { + 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); + + // Store the attributes that are being supplied + if (rv == CKR_OK) + { + OSObject* osobject = (OSObject*)handleManager->getObject(*phKey); + if (osobject == NULL_PTR || !osobject->isValid()) { + rv = CKR_FUNCTION_FAILED; + } else if (osobject->startTransaction()) { + bool bOK = true; + + // Common Attributes + 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); + + // DH Domain Parameters Attributes + ByteString prime; + ByteString generator; + if (isPrivate) + { + token->encrypt(params->getP(), prime); + token->encrypt(params->getG(), generator); + } + else + { + prime = params->getP(); + generator = params->getG(); + } + bOK = bOK && osobject->setAttribute(CKA_PRIME, prime); + bOK = bOK && osobject->setAttribute(CKA_BASE, generator); + + if (bOK) + bOK = osobject->commitTransaction(); + else + osobject->abortTransaction(); + + if (!bOK) + rv = CKR_FUNCTION_FAILED; + } else + rv = CKR_FUNCTION_FAILED; + } + + // Clean up + dh->recycleParameters(p); + CryptoFactory::i()->recycleAsymmetricAlgorithm(dh); + + // Remove parameters that may have been created already when the function fails. + if (rv != CKR_OK) + { + if (*phKey != CK_INVALID_HANDLE) + { + OSObject* osparams = (OSObject*)handleManager->getObject(*phKey); + handleManager->destroyObject(*phKey); + if (osparams) osparams->destroyObject(); + *phKey = CK_INVALID_HANDLE; + } + } + + return rv; +} + +// 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) +{ + *phPublicKey = CK_INVALID_HANDLE; + *phPrivateKey = CK_INVALID_HANDLE; + + // Get the session + 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; + + // Extract desired key information + ByteString param_3410; + ByteString param_3411; + ByteString param_28147; + for (CK_ULONG i = 0; i < ulPublicKeyAttributeCount; i++) + { + 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; + } + } + + // The parameters must be specified to be able to generate a key pair. + if (param_3410.size() == 0 || param_3411.size() == 0) { + INFO_MSG("Missing parameter(s) in pPublicKeyTemplate"); + return CKR_TEMPLATE_INCOMPLETE; + } + + // Set the parameters + ECParameters p; + p.setEC(param_3410); + + // Generate key pair + 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"); + CryptoFactory::i()->recycleAsymmetricAlgorithm(gost); + return CKR_GENERAL_ERROR; + } + + GOSTPublicKey* pub = (GOSTPublicKey*) kp->getPublicKey(); + GOSTPrivateKey* priv = (GOSTPrivateKey*) kp->getPrivateKey(); + + CK_RV rv = CKR_OK; + + // Create a public key using C_CreateObject + if (rv == CKR_OK) + { + const CK_ULONG maxAttribs = 32; + 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) }, + }; + 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) + { + switch (pPublicKeyTemplate[i].type) + { + 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); + + // 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()) { + rv = CKR_FUNCTION_FAILED; + } else if (osobject->startTransaction()) { + bool bOK = true; + + // Common Key Attributes + 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); + + // EC Public Key Attributes + ByteString point; + if (isPublicKeyPrivate) + { + token->encrypt(pub->getQ(), point); + } + else + { + point = pub->getQ(); + } + bOK = bOK && osobject->setAttribute(CKA_VALUE, point); + + if (bOK) + bOK = osobject->commitTransaction(); + else + osobject->abortTransaction(); + + if (!bOK) + rv = CKR_FUNCTION_FAILED; + } else + rv = CKR_FUNCTION_FAILED; + } + } + + // Create a private key using C_CreateObject + if (rv == CKR_OK) + { + const CK_ULONG maxAttribs = 32; + 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) }, + }; + CK_ULONG privateKeyAttribsCount = 4; + if (ulPrivateKeyAttributeCount > (maxAttribs - privateKeyAttribsCount)) + rv = CKR_TEMPLATE_INCONSISTENT; + 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]; + } + } + + if (rv == CKR_OK) + 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()) { + rv = CKR_FUNCTION_FAILED; + } else if (osobject->startTransaction()) { + bool bOK = true; + + // Common Key Attributes + 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); + + // Common Private Key Attributes + bool bAlwaysSensitive = osobject->getBooleanValue(CKA_SENSITIVE, false); + bOK = bOK && osobject->setAttribute(CKA_ALWAYS_SENSITIVE,bAlwaysSensitive); + bool bNeverExtractable = osobject->getBooleanValue(CKA_EXTRACTABLE, false) == false; + bOK = bOK && osobject->setAttribute(CKA_NEVER_EXTRACTABLE, bNeverExtractable); + + // GOST Private Key Attributes + ByteString value; + ByteString param_a; + ByteString param_b; + ByteString param_c; + if (isPrivateKeyPrivate) + { + token->encrypt(priv->getD(), value); + token->encrypt(priv->getEC(), param_a); + token->encrypt(param_3411, param_b); + token->encrypt(param_28147, param_c); + } + else + { + value = priv->getD(); + param_a = priv->getEC(); + param_b = param_3411; + param_c = param_28147; + } + bOK = bOK && osobject->setAttribute(CKA_VALUE, value); + bOK = bOK && osobject->setAttribute(CKA_GOSTR3410_PARAMS, param_a); + bOK = bOK && osobject->setAttribute(CKA_GOSTR3411_PARAMS, param_b); + bOK = bOK && osobject->setAttribute(CKA_GOST28147_PARAMS, param_c); + + if (bOK) + bOK = osobject->commitTransaction(); + else + osobject->abortTransaction(); + + if (!bOK) + rv = CKR_FUNCTION_FAILED; + } else + rv = CKR_FUNCTION_FAILED; + } + } + + // Clean up + gost->recycleKeyPair(kp); + CryptoFactory::i()->recycleAsymmetricAlgorithm(gost); + + // Remove keys that may have been created already when the function fails. + if (rv != CKR_OK) + { + if (*phPrivateKey != CK_INVALID_HANDLE) + { + OSObject* ospriv = (OSObject*)handleManager->getObject(*phPrivateKey); + handleManager->destroyObject(*phPrivateKey); + if (ospriv) ospriv->destroyObject(); + *phPrivateKey = CK_INVALID_HANDLE; + } + + if (*phPublicKey != CK_INVALID_HANDLE) + { + OSObject* ospub = (OSObject*)handleManager->getObject(*phPublicKey); + handleManager->destroyObject(*phPublicKey); + if (ospub) ospub->destroyObject(); + *phPublicKey = CK_INVALID_HANDLE; + } + } + + return rv; +} + +// 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) +{ + *phKey = CK_INVALID_HANDLE; + + 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); + if (session == NULL) + return CKR_SESSION_HANDLE_INVALID; + + // Get the token + Token* token = session->getToken(); + if (token == NULL) + return CKR_GENERAL_ERROR; + + // Extract desired parameter information + size_t byteLen = 0; + bool checkValue = true; + for (CK_ULONG i = 0; i < ulCount; i++) + { + 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) + { + 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 + OSObject *baseKey = (OSObject *)handleManager->getObject(hBaseKey); + if (baseKey == NULL || !baseKey->isValid()) + return CKR_KEY_HANDLE_INVALID; + + // Get the DH algorithm handler + AsymmetricAlgorithm* dh = CryptoFactory::i()->getAsymmetricAlgorithm(AsymAlgo::DH); + if (dh == NULL) + return CKR_MECHANISM_INVALID; + + // Get the keys + PrivateKey* privateKey = dh->newPrivateKey(); + if (privateKey == NULL) + { + CryptoFactory::i()->recycleAsymmetricAlgorithm(dh); + return CKR_HOST_MEMORY; + } + if (getDHPrivateKey((DHPrivateKey*)privateKey, token, baseKey) != CKR_OK) + { + dh->recyclePrivateKey(privateKey); + CryptoFactory::i()->recycleAsymmetricAlgorithm(dh); + return CKR_GENERAL_ERROR; + } + + ByteString mechParameters; + mechParameters.resize(pMechanism->ulParameterLen); + memcpy(&mechParameters[0], pMechanism->pParameter, pMechanism->ulParameterLen); + 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) + { + dh->recyclePrivateKey(privateKey); + dh->recyclePublicKey(publicKey); + CryptoFactory::i()->recycleAsymmetricAlgorithm(dh); + return CKR_GENERAL_ERROR; + } + + // Derive the secret + SymmetricKey* secret = NULL; + CK_RV rv = CKR_OK; + if (!dh->deriveKey(&secret, publicKey, privateKey)) + rv = CKR_GENERAL_ERROR; + dh->recyclePrivateKey(privateKey); + dh->recyclePublicKey(publicKey); + + // 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) }, + }; + 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) + { + 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]; + } + } + + if (rv == CKR_OK) + rv = this->CreateObject(hSession, secretAttribs, secretAttribsCount, phKey, OBJECT_OP_DERIVE); + + // Store the attributes that are being supplied + if (rv == CKR_OK) + { + OSObject* osobject = (OSObject*)handleManager->getObject(*phKey); + if (osobject == NULL_PTR || !osobject->isValid()) { + rv = CKR_FUNCTION_FAILED; + } else if (osobject->startTransaction()) { + bool bOK = true; + + // Common Attributes + 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); + } + else + { + 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); + } + else + { + bOK = bOK && osobject->setAttribute(CKA_NEVER_EXTRACTABLE,false); + } + + // Secret Attributes + ByteString secretValue = secret->getKeyBits(); + ByteString value; + ByteString plainKCV; + ByteString kcv; + + if (byteLen > secretValue.size()) + { + INFO_MSG("The derived secret is too short"); + bOK = false; + } + else + { + // Truncate value when requested, remove from the leading end + if (byteLen < secretValue.size()) + secretValue.split(secretValue.size() - byteLen); + + // Fix the odd parity for DES + if (keyType == CKK_DES || + keyType == CKK_DES2 || + keyType == CKK_DES3) + { + for (size_t i = 0; i < secretValue.size(); i++) + { + secretValue[i] = odd_parity[secretValue[i]]; + } + } + + // 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; + } + + if (isPrivate) + { + token->encrypt(secretValue, value); + token->encrypt(plainKCV, kcv); + } + else + { + value = secretValue; + kcv = plainKCV; + } + } + bOK = bOK && osobject->setAttribute(CKA_VALUE, value); + if (checkValue) + bOK = bOK && osobject->setAttribute(CKA_CHECK_VALUE, kcv); + + if (bOK) + bOK = osobject->commitTransaction(); + else + osobject->abortTransaction(); + + if (!bOK) + rv = CKR_FUNCTION_FAILED; + } else + rv = CKR_FUNCTION_FAILED; + } + + // Clean up + dh->recycleSymmetricKey(secret); + CryptoFactory::i()->recycleAsymmetricAlgorithm(dh); + + // Remove secret that may have been created already when the function fails. + if (rv != CKR_OK) + { + if (*phKey != CK_INVALID_HANDLE) + { + OSObject* ossecret = (OSObject*)handleManager->getObject(*phKey); + handleManager->destroyObject(*phKey); + if (ossecret) ossecret->destroyObject(); + *phKey = CK_INVALID_HANDLE; + } + } + + return rv; +} + +// Derive an ECDH secret +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) +{ +#ifdef WITH_ECC + *phKey = CK_INVALID_HANDLE; + + if ((pMechanism->pParameter == NULL_PTR) || + (pMechanism->ulParameterLen != sizeof(CK_ECDH1_DERIVE_PARAMS))) + { + DEBUG_MSG("pParameter must be of type CK_ECDH1_DERIVE_PARAMS"); + return CKR_MECHANISM_PARAM_INVALID; + } + if (CK_ECDH1_DERIVE_PARAMS_PTR(pMechanism->pParameter)->kdf != CKD_NULL) + { + DEBUG_MSG("kdf must be CKD_NULL"); + 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)) + { + 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)) + { + DEBUG_MSG("there must be a public data"); + return CKR_MECHANISM_PARAM_INVALID; + } + + // Get the session + 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; + + // Extract desired parameter information + size_t byteLen = 0; + bool checkValue = true; + for (CK_ULONG i = 0; i < ulCount; i++) + { + 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) + { + 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 + OSObject *baseKey = (OSObject *)handleManager->getObject(hBaseKey); + if (baseKey == NULL || !baseKey->isValid()) + return CKR_KEY_HANDLE_INVALID; + + // Get the ECDH algorithm handler + AsymmetricAlgorithm* ecdh = CryptoFactory::i()->getAsymmetricAlgorithm(AsymAlgo::ECDH); + if (ecdh == NULL) + return CKR_MECHANISM_INVALID; + + // Get the keys + PrivateKey* privateKey = ecdh->newPrivateKey(); + if (privateKey == NULL) + { + CryptoFactory::i()->recycleAsymmetricAlgorithm(ecdh); + return CKR_HOST_MEMORY; + } + if (getECPrivateKey((ECPrivateKey*)privateKey, token, baseKey) != CKR_OK) + { + ecdh->recyclePrivateKey(privateKey); + CryptoFactory::i()->recycleAsymmetricAlgorithm(ecdh); + return CKR_GENERAL_ERROR; + } + + 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(); + if (publicKey == NULL) + { + ecdh->recyclePrivateKey(privateKey); + CryptoFactory::i()->recycleAsymmetricAlgorithm(ecdh); + return CKR_HOST_MEMORY; + } + if (getECDHPublicKey((ECPublicKey*)publicKey, (ECPrivateKey*)privateKey, publicData) != CKR_OK) + { + ecdh->recyclePrivateKey(privateKey); + ecdh->recyclePublicKey(publicKey); + CryptoFactory::i()->recycleAsymmetricAlgorithm(ecdh); + return CKR_GENERAL_ERROR; + } + + // Derive the secret + SymmetricKey* secret = NULL; + CK_RV rv = CKR_OK; + if (!ecdh->deriveKey(&secret, publicKey, privateKey)) + rv = CKR_GENERAL_ERROR; + ecdh->recyclePrivateKey(privateKey); + ecdh->recyclePublicKey(publicKey); + + // 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) }, + }; + 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) + { + 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]; + } + } + + if (rv == CKR_OK) + rv = this->CreateObject(hSession, secretAttribs, secretAttribsCount, phKey, OBJECT_OP_DERIVE); + + // Store the attributes that are being supplied + if (rv == CKR_OK) + { + OSObject* osobject = (OSObject*)handleManager->getObject(*phKey); + if (osobject == NULL_PTR || !osobject->isValid()) { + rv = CKR_FUNCTION_FAILED; + } else if (osobject->startTransaction()) { + bool bOK = true; + + // Common Attributes + 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); + } + else + { + 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); + } + else + { + bOK = bOK && osobject->setAttribute(CKA_NEVER_EXTRACTABLE,false); + } + + // Secret Attributes + ByteString secretValue = secret->getKeyBits(); + ByteString value; + ByteString plainKCV; + ByteString kcv; + + // For generic and AES keys: + // default to return max size available. + if (byteLen == 0) + { + 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; + } + } + + if (byteLen > secretValue.size()) + { + INFO_MSG("The derived secret is too short"); + bOK = false; + } + else + { + // Truncate value when requested, remove from the leading end + if (byteLen < secretValue.size()) + secretValue.split(secretValue.size() - byteLen); + + // Fix the odd parity for DES + if (keyType == CKK_DES || + keyType == CKK_DES2 || + keyType == CKK_DES3) + { + for (size_t i = 0; i < secretValue.size(); i++) + { + secretValue[i] = odd_parity[secretValue[i]]; + } + } + + // 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; + } + + if (isPrivate) + { + token->encrypt(secretValue, value); + token->encrypt(plainKCV, kcv); + } + else + { + value = secretValue; + kcv = plainKCV; + } + } + bOK = bOK && osobject->setAttribute(CKA_VALUE, value); + if (checkValue) + bOK = bOK && osobject->setAttribute(CKA_CHECK_VALUE, kcv); + + if (bOK) + bOK = osobject->commitTransaction(); + else + osobject->abortTransaction(); + + if (!bOK) + rv = CKR_FUNCTION_FAILED; + } else + rv = CKR_FUNCTION_FAILED; + } + + // Clean up + ecdh->recycleSymmetricKey(secret); + CryptoFactory::i()->recycleAsymmetricAlgorithm(ecdh); + + // Remove secret that may have been created already when the function fails. + if (rv != CKR_OK) + { + if (*phKey != CK_INVALID_HANDLE) + { + OSObject* ossecret = (OSObject*)handleManager->getObject(*phKey); + handleManager->destroyObject(*phKey); + if (ossecret) ossecret->destroyObject(); + *phKey = CK_INVALID_HANDLE; + } + } + + return rv; +#else + return CKR_MECHANISM_INVALID; +#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) +{ + *phKey = CK_INVALID_HANDLE; + + if (pMechanism->pParameter == NULL_PTR) + { + DEBUG_MSG("pParameter must be supplied"); + return CKR_MECHANISM_PARAM_INVALID; + } + + 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)) + { + 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; + if (ulLen == 0 || pData == NULL_PTR) + { + DEBUG_MSG("There must be data in the parameter"); + return CKR_MECHANISM_PARAM_INVALID; + } + if (ulLen % 8 != 0) + { + DEBUG_MSG("The data must be a multiple of 8 bytes long"); + return CKR_MECHANISM_PARAM_INVALID; + } + data.resize(ulLen); + memcpy(&data[0], + 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)) + { + 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; + if (length == 0 || pData == NULL_PTR) + { + DEBUG_MSG("There must be data in the parameter"); + return CKR_MECHANISM_PARAM_INVALID; + } + if (length % 8 != 0) + { + DEBUG_MSG("The data must be a multiple of 8 bytes long"); + return CKR_MECHANISM_PARAM_INVALID; + } + data.resize(length); + memcpy(&data[0], + pData, + length); + } + else if (pMechanism->mechanism == CKM_AES_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; + if (ulLen == 0 || pData == NULL_PTR) + { + DEBUG_MSG("There must be data in the parameter"); + return CKR_MECHANISM_PARAM_INVALID; + } + if (ulLen % 16 != 0) + { + DEBUG_MSG("The data must be a multiple of 16 bytes long"); + return CKR_MECHANISM_PARAM_INVALID; + } + data.resize(ulLen); + memcpy(&data[0], + pData, + ulLen); + } + else if ((pMechanism->mechanism == CKM_AES_CBC_ENCRYPT_DATA) && + 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; + if (length == 0 || pData == NULL_PTR) + { + DEBUG_MSG("There must be data in the parameter"); + return CKR_MECHANISM_PARAM_INVALID; + } + if (length % 16 != 0) + { + DEBUG_MSG("The data must be a multiple of 16 bytes long"); + return CKR_MECHANISM_PARAM_INVALID; + } + data.resize(length); + memcpy(&data[0], + pData, + length); + } + else + { + DEBUG_MSG("pParameter is invalid"); + return CKR_MECHANISM_PARAM_INVALID; + } + + // Get the session + 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; + + // Extract desired parameter information + size_t byteLen = 0; + bool checkValue = true; + for (CK_ULONG i = 0; i < ulCount; i++) + { + 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) + { + 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 symmetric algorithm matching the mechanism + SymAlgo::Type algo = SymAlgo::Unknown; + SymMode::Type mode = SymMode::Unknown; + bool padding = false; + ByteString iv; + size_t bb = 8; + 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; +#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; + 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; + + 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; + } + + // Get the data + ByteString secretValue; + + // 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) }, + }; + CK_ULONG secretAttribsCount = 4; + + // Add the additional + CK_RV rv = CKR_OK; + if (ulCount > (maxAttribs - secretAttribsCount)) + rv = CKR_TEMPLATE_INCONSISTENT; + 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]; + } + } + + if (rv == CKR_OK) + rv = this->CreateObject(hSession, secretAttribs, secretAttribsCount, phKey, OBJECT_OP_DERIVE); + + // Store the attributes that are being supplied + if (rv == CKR_OK) + { + OSObject* osobject = (OSObject*)handleManager->getObject(*phKey); + if (osobject == NULL_PTR || !osobject->isValid()) { + rv = CKR_FUNCTION_FAILED; + } else if (osobject->startTransaction()) { + bool bOK = true; + + // Common Attributes + 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); + } + else + { + 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); + } + else + { + bOK = bOK && osobject->setAttribute(CKA_NEVER_EXTRACTABLE,false); + } + + ByteString value; + ByteString plainKCV; + ByteString kcv; + + if (byteLen > secretValue.size()) + { + INFO_MSG("The derived secret is too short"); + bOK = false; + } + else + { + // Truncate value when requested, remove from the trailing end + if (byteLen < secretValue.size()) + secretValue.resize(byteLen); + + // Fix the odd parity for DES + if (keyType == CKK_DES || + keyType == CKK_DES2 || + keyType == CKK_DES3) + { + for (size_t i = 0; i < secretValue.size(); i++) + { + secretValue[i] = odd_parity[secretValue[i]]; + } + } + + // Get the KCV + 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; + } + delete secret; + + if (isPrivate) + { + token->encrypt(secretValue, value); + token->encrypt(plainKCV, kcv); + } + else + { + value = secretValue; + kcv = plainKCV; + } + } + bOK = bOK && osobject->setAttribute(CKA_VALUE, value); + if (checkValue) + bOK = bOK && osobject->setAttribute(CKA_CHECK_VALUE, kcv); + + if (bOK) + bOK = osobject->commitTransaction(); + else + osobject->abortTransaction(); + + if (!bOK) + rv = CKR_FUNCTION_FAILED; + } else + rv = CKR_FUNCTION_FAILED; + } + + // Remove secret that may have been created already when the function fails. + if (rv != CKR_OK) + { + if (*phKey != CK_INVALID_HANDLE) + { + OSObject* ossecret = (OSObject*)handleManager->getObject(*phKey); + handleManager->destroyObject(*phKey); + if (ossecret) ossecret->destroyObject(); + *phKey = CK_INVALID_HANDLE; + } + } + + return rv; +} + +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 (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; + + // Get the slot + 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; + + // Extract information from the template that is needed to create the object. + CK_OBJECT_CLASS objClass = CKO_DATA; + CK_KEY_TYPE keyType = CKK_RSA; + CK_CERTIFICATE_TYPE certType = CKC_X_509; + 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); + if (rv != CKR_OK) + { + ERROR_MSG("Mandatory attribute not present in template"); + return rv; + } + + // Check user credentials + rv = haveWrite(session->getState(), isOnToken, isPrivate); + if (rv != CKR_OK) + { + if (rv == CKR_USER_NOT_LOGGED_IN) + INFO_MSG("User is not authorized"); + if (rv == CKR_SESSION_READ_ONLY) + INFO_MSG("Session is read-only"); + + return rv; + } + + // Change order of attributes + const CK_ULONG maxAttribs = 32; + CK_ATTRIBUTE attribs[maxAttribs]; + CK_ATTRIBUTE saveAttribs[maxAttribs]; + CK_ULONG attribsCount = 0; + CK_ULONG saveAttribsCount = 0; + if (ulCount > maxAttribs) + { + return CKR_TEMPLATE_INCONSISTENT; + } + 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]; + } + } + for (CK_ULONG i=0; i < saveAttribsCount; i++) + { + attribs[attribsCount++] = saveAttribs[i]; + } + + P11Object* p11object = NULL; + rv = newP11Object(objClass,keyType,certType,&p11object); + if (rv != CKR_OK) + return rv; + + // Create the object in session or on the token + OSObject *object = NULL_PTR; + if (isOnToken) + { + object = (OSObject*) token->createObject(); + } + else + { + object = sessionObjectStore->createObject(slot->getSlotID(), hSession, isPrivate != CK_FALSE); + } + + if (object == NULL || !p11object->init(object)) + { + delete p11object; + return CKR_GENERAL_ERROR; + } + + rv = p11object->saveTemplate(token, isPrivate != CK_FALSE, attribs,attribsCount,op); + delete p11object; + if (rv != CKR_OK) + return rv; + + if (op == OBJECT_OP_CREATE) + { + if (objClass == CKO_PUBLIC_KEY && + (!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())) + { + return CKR_GENERAL_ERROR; + } + } + + if (isOnToken) + { + *phObject = handleManager->addTokenObject(slot->getSlotID(), isPrivate != CK_FALSE, object); + } else { + *phObject = handleManager->addSessionObject(slot->getSlotID(), hSession, isPrivate != CK_FALSE, object); + } + + return CKR_OK; +} + +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; + + // Get the CKA_PRIVATE attribute, when the attribute is not present use default false + bool isKeyPrivate = key->getBooleanValue(CKA_PRIVATE, false); + + // RSA Private Key Attributes + ByteString modulus; + ByteString publicExponent; + ByteString privateExponent; + ByteString prime1; + ByteString prime2; + ByteString exponent1; + ByteString exponent2; + ByteString coefficient; + if (isKeyPrivate) + { + bool bOK = true; + bOK = bOK && token->decrypt(key->getByteStringValue(CKA_MODULUS), modulus); + bOK = bOK && token->decrypt(key->getByteStringValue(CKA_PUBLIC_EXPONENT), publicExponent); + bOK = bOK && token->decrypt(key->getByteStringValue(CKA_PRIVATE_EXPONENT), privateExponent); + bOK = bOK && token->decrypt(key->getByteStringValue(CKA_PRIME_1), prime1); + bOK = bOK && token->decrypt(key->getByteStringValue(CKA_PRIME_2), prime2); + bOK = bOK && token->decrypt(key->getByteStringValue(CKA_EXPONENT_1), exponent1); + bOK = bOK && token->decrypt(key->getByteStringValue(CKA_EXPONENT_2), exponent2); + bOK = bOK && token->decrypt(key->getByteStringValue(CKA_COEFFICIENT), coefficient); + if (!bOK) + return CKR_GENERAL_ERROR; + } + else + { + modulus = key->getByteStringValue(CKA_MODULUS); + publicExponent = key->getByteStringValue(CKA_PUBLIC_EXPONENT); + privateExponent = key->getByteStringValue(CKA_PRIVATE_EXPONENT); + prime1 = key->getByteStringValue(CKA_PRIME_1); + prime2 = key->getByteStringValue(CKA_PRIME_2); + exponent1 = key->getByteStringValue(CKA_EXPONENT_1); + exponent2 = key->getByteStringValue(CKA_EXPONENT_2); + coefficient = key->getByteStringValue(CKA_COEFFICIENT); + } + + privateKey->setN(modulus); + privateKey->setE(publicExponent); + privateKey->setD(privateExponent); + privateKey->setP(prime1); + privateKey->setQ(prime2); + privateKey->setDP1(exponent1); + privateKey->setDQ1(exponent2); + privateKey->setPQ(coefficient); + + return CKR_OK; +} + +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; + + // Get the CKA_PRIVATE attribute, when the attribute is not present use default false + bool isKeyPrivate = key->getBooleanValue(CKA_PRIVATE, false); + + // RSA Public Key Attributes + ByteString modulus; + ByteString publicExponent; + if (isKeyPrivate) + { + bool bOK = true; + bOK = bOK && token->decrypt(key->getByteStringValue(CKA_MODULUS), modulus); + bOK = bOK && token->decrypt(key->getByteStringValue(CKA_PUBLIC_EXPONENT), publicExponent); + if (!bOK) + return CKR_GENERAL_ERROR; + } + else + { + modulus = key->getByteStringValue(CKA_MODULUS); + publicExponent = key->getByteStringValue(CKA_PUBLIC_EXPONENT); + } + + publicKey->setN(modulus); + publicKey->setE(publicExponent); + + return CKR_OK; +} + +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; + + // Get the CKA_PRIVATE attribute, when the attribute is not present use default false + bool isKeyPrivate = key->getBooleanValue(CKA_PRIVATE, false); + + // DSA Private Key Attributes + ByteString prime; + ByteString subprime; + ByteString generator; + ByteString value; + if (isKeyPrivate) + { + bool bOK = true; + bOK = bOK && token->decrypt(key->getByteStringValue(CKA_PRIME), prime); + bOK = bOK && token->decrypt(key->getByteStringValue(CKA_SUBPRIME), subprime); + bOK = bOK && token->decrypt(key->getByteStringValue(CKA_BASE), generator); + bOK = bOK && token->decrypt(key->getByteStringValue(CKA_VALUE), value); + if (!bOK) + return CKR_GENERAL_ERROR; + } + else + { + prime = key->getByteStringValue(CKA_PRIME); + subprime = key->getByteStringValue(CKA_SUBPRIME); + generator = key->getByteStringValue(CKA_BASE); + value = key->getByteStringValue(CKA_VALUE); + } + + privateKey->setP(prime); + privateKey->setQ(subprime); + privateKey->setG(generator); + privateKey->setX(value); + + return CKR_OK; +} + +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; + + // Get the CKA_PRIVATE attribute, when the attribute is not present use default false + bool isKeyPrivate = key->getBooleanValue(CKA_PRIVATE, false); + + // DSA Public Key Attributes + ByteString prime; + ByteString subprime; + ByteString generator; + ByteString value; + if (isKeyPrivate) + { + bool bOK = true; + bOK = bOK && token->decrypt(key->getByteStringValue(CKA_PRIME), prime); + bOK = bOK && token->decrypt(key->getByteStringValue(CKA_SUBPRIME), subprime); + bOK = bOK && token->decrypt(key->getByteStringValue(CKA_BASE), generator); + bOK = bOK && token->decrypt(key->getByteStringValue(CKA_VALUE), value); + if (!bOK) + return CKR_GENERAL_ERROR; + } + else + { + prime = key->getByteStringValue(CKA_PRIME); + subprime = key->getByteStringValue(CKA_SUBPRIME); + generator = key->getByteStringValue(CKA_BASE); + value = key->getByteStringValue(CKA_VALUE); + } + + publicKey->setP(prime); + publicKey->setQ(subprime); + publicKey->setG(generator); + publicKey->setY(value); + + return CKR_OK; +} + +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; + + // Get the CKA_PRIVATE attribute, when the attribute is not present use default false + bool isKeyPrivate = key->getBooleanValue(CKA_PRIVATE, false); + + // EC Private Key Attributes + ByteString group; + ByteString value; + if (isKeyPrivate) + { + bool bOK = true; + bOK = bOK && token->decrypt(key->getByteStringValue(CKA_EC_PARAMS), group); + bOK = bOK && token->decrypt(key->getByteStringValue(CKA_VALUE), value); + if (!bOK) + return CKR_GENERAL_ERROR; + } + else + { + group = key->getByteStringValue(CKA_EC_PARAMS); + value = key->getByteStringValue(CKA_VALUE); + } + + privateKey->setEC(group); + privateKey->setD(value); + + return CKR_OK; +} + +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; + + // Get the CKA_PRIVATE attribute, when the attribute is not present use default false + bool isKeyPrivate = key->getBooleanValue(CKA_PRIVATE, false); + + // EC Public Key Attributes + ByteString group; + ByteString point; + if (isKeyPrivate) + { + bool bOK = true; + bOK = bOK && token->decrypt(key->getByteStringValue(CKA_EC_PARAMS), group); + bOK = bOK && token->decrypt(key->getByteStringValue(CKA_EC_POINT), point); + if (!bOK) + return CKR_GENERAL_ERROR; + } + else + { + group = key->getByteStringValue(CKA_EC_PARAMS); + point = key->getByteStringValue(CKA_EC_POINT); + } + + publicKey->setEC(group); + publicKey->setQ(point); + + return CKR_OK; +} + +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; + + // Get the CKA_PRIVATE attribute, when the attribute is not present use default false + bool isKeyPrivate = key->getBooleanValue(CKA_PRIVATE, false); + + // DH Private Key Attributes + ByteString prime; + ByteString generator; + ByteString value; + if (isKeyPrivate) + { + bool bOK = true; + bOK = bOK && token->decrypt(key->getByteStringValue(CKA_PRIME), prime); + bOK = bOK && token->decrypt(key->getByteStringValue(CKA_BASE), generator); + bOK = bOK && token->decrypt(key->getByteStringValue(CKA_VALUE), value); + if (!bOK) + return CKR_GENERAL_ERROR; + } + else + { + prime = key->getByteStringValue(CKA_PRIME); + generator = key->getByteStringValue(CKA_BASE); + value = key->getByteStringValue(CKA_VALUE); + } + + privateKey->setP(prime); + privateKey->setG(generator); + privateKey->setX(value); + + return CKR_OK; +} + +CK_RV SoftHSM::getDHPublicKey(DHPublicKey* publicKey, DHPrivateKey* privateKey, ByteString& pubParams) +{ + if (publicKey == NULL) return CKR_ARGUMENTS_BAD; + if (privateKey == NULL) return CKR_ARGUMENTS_BAD; + + // Copy Domain Parameters from Private Key + publicKey->setP(privateKey->getP()); + publicKey->setG(privateKey->getG()); + + // Set value + publicKey->setY(pubParams); + + return CKR_OK; +} + +CK_RV SoftHSM::getECDHPublicKey(ECPublicKey* publicKey, ECPrivateKey* privateKey, ByteString& pubData) +{ + if (publicKey == NULL) return CKR_ARGUMENTS_BAD; + if (privateKey == NULL) return CKR_ARGUMENTS_BAD; + + // Copy Domain Parameters from Private Key + publicKey->setEC(privateKey->getEC()); + + // Set value + ByteString data = getECDHPubData(pubData); + publicKey->setQ(data); + + return CKR_OK; +} + +// ECDH pubData can be in RAW or DER format. +// Need to convert RAW as SoftHSM uses DER. +ByteString SoftHSM::getECDHPubData(ByteString& pubData) +{ + size_t len = pubData.size(); + size_t controlOctets = 2; + if (len == 65 || len == 97 || len == 133) + { + // Raw: Length matches the public key size of P-256, P-384, or P-521 + controlOctets = 0; + } + else if (len < controlOctets || pubData[0] != 0x04) + { + // Raw: Too short or does not start with 0x04 + controlOctets = 0; + } + else if (pubData[1] < 0x80) + { + // Raw: Length octet does not match remaining data length + if (pubData[1] != (len - controlOctets)) controlOctets = 0; + } + else + { + size_t lengthOctets = pubData[1] & 0x7F; + controlOctets += lengthOctets; + + if (controlOctets >= len) + { + // Raw: Too short + controlOctets = 0; + } + else + { + ByteString length(&pubData[2], lengthOctets); + + if (length.long_val() != (len - controlOctets)) + { + // Raw: Length octets does not match remaining data length + controlOctets = 0; + } + } + } + + // DER format + if (controlOctets != 0) return pubData; + + // RAW format + ByteString header; + if (len < 0x80) + { + header.resize(2); + header[0] = (unsigned char)0x04; + header[1] = (unsigned char)(len & 0x7F); + } + else + { + // Count significate bytes + size_t bytes = sizeof(size_t); + for(; bytes > 0; bytes--) + { + size_t value = len >> ((bytes - 1) * 8); + if (value & 0xFF) break; + } + + // Set header data + header.resize(2 + bytes); + header[0] = (unsigned char)0x04; + header[1] = (unsigned char)(0x80 | bytes); + for (size_t i = 1; i <= bytes; i++) + { + header[2+bytes-i] = (unsigned char) (len & 0xFF); + len >>= 8; + } + } + + return header + pubData; +} + +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; + + // Get the CKA_PRIVATE attribute, when the attribute is not present use default false + bool isKeyPrivate = key->getBooleanValue(CKA_PRIVATE, false); + + // GOST Private Key Attributes + ByteString value; + ByteString param; + if (isKeyPrivate) + { + bool bOK = true; + bOK = bOK && token->decrypt(key->getByteStringValue(CKA_VALUE), value); + bOK = bOK && token->decrypt(key->getByteStringValue(CKA_GOSTR3410_PARAMS), param); + if (!bOK) + return CKR_GENERAL_ERROR; + } + else + { + value = key->getByteStringValue(CKA_VALUE); + param = key->getByteStringValue(CKA_GOSTR3410_PARAMS); + } + + privateKey->setD(value); + privateKey->setEC(param); + + return CKR_OK; +} + +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; + + // Get the CKA_PRIVATE attribute, when the attribute is not present use default false + bool isKeyPrivate = key->getBooleanValue(CKA_PRIVATE, false); + + // GOST Public Key Attributes + ByteString point; + ByteString param; + if (isKeyPrivate) + { + bool bOK = true; + bOK = bOK && token->decrypt(key->getByteStringValue(CKA_VALUE), point); + bOK = bOK && token->decrypt(key->getByteStringValue(CKA_GOSTR3410_PARAMS), param); + if (!bOK) + return CKR_GENERAL_ERROR; + } + else + { + point = key->getByteStringValue(CKA_VALUE); + param = key->getByteStringValue(CKA_GOSTR3410_PARAMS); + } + + publicKey->setQ(point); + publicKey->setEC(param); + + return CKR_OK; +} + +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; + + // Get the CKA_PRIVATE attribute, when the attribute is not present use default false + bool isKeyPrivate = key->getBooleanValue(CKA_PRIVATE, false); + + ByteString keybits; + if (isKeyPrivate) + { + if (!token->decrypt(key->getByteStringValue(CKA_VALUE), keybits)) + return CKR_GENERAL_ERROR; + } + else + { + keybits = key->getByteStringValue(CKA_VALUE); + } + + skey->setKeyBits(keybits); + + return CKR_OK; +} + +bool SoftHSM::setRSAPrivateKey(OSObject* key, const ByteString &ber, Token* token, bool isPrivate) const +{ + AsymmetricAlgorithm* rsa = CryptoFactory::i()->getAsymmetricAlgorithm(AsymAlgo::RSA); + if (rsa == NULL) + return false; + PrivateKey* priv = rsa->newPrivateKey(); + if (priv == NULL) + { + CryptoFactory::i()->recycleAsymmetricAlgorithm(rsa); + return false; + } + if (!priv->PKCS8Decode(ber)) + { + rsa->recyclePrivateKey(priv); + CryptoFactory::i()->recycleAsymmetricAlgorithm(rsa); + return false; + } + // RSA Private Key Attributes + ByteString modulus; + ByteString publicExponent; + ByteString privateExponent; + ByteString prime1; + ByteString prime2; + ByteString exponent1; + ByteString exponent2; + 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); + } + 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(); + } + bool bOK = true; + bOK = bOK && key->setAttribute(CKA_MODULUS, modulus); + bOK = bOK && key->setAttribute(CKA_PUBLIC_EXPONENT, publicExponent); + 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_2, exponent2); + bOK = bOK && key->setAttribute(CKA_COEFFICIENT, coefficient); + + rsa->recyclePrivateKey(priv); + CryptoFactory::i()->recycleAsymmetricAlgorithm(rsa); + + return bOK; +} + +bool SoftHSM::setDSAPrivateKey(OSObject* key, const ByteString &ber, Token* token, bool isPrivate) const +{ + AsymmetricAlgorithm* dsa = CryptoFactory::i()->getAsymmetricAlgorithm(AsymAlgo::DSA); + if (dsa == NULL) + return false; + PrivateKey* priv = dsa->newPrivateKey(); + if (priv == NULL) + { + CryptoFactory::i()->recycleAsymmetricAlgorithm(dsa); + return false; + } + if (!priv->PKCS8Decode(ber)) + { + dsa->recyclePrivateKey(priv); + CryptoFactory::i()->recycleAsymmetricAlgorithm(dsa); + return false; + } + // DSA Private Key Attributes + ByteString prime; + ByteString subprime; + ByteString generator; + 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); + } + else + { + 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); + bOK = bOK && key->setAttribute(CKA_SUBPRIME, subprime); + bOK = bOK && key->setAttribute(CKA_BASE, generator); + bOK = bOK && key->setAttribute(CKA_VALUE, value); + + dsa->recyclePrivateKey(priv); + CryptoFactory::i()->recycleAsymmetricAlgorithm(dsa); + + return bOK; +} + +bool SoftHSM::setDHPrivateKey(OSObject* key, const ByteString &ber, Token* token, bool isPrivate) const +{ + AsymmetricAlgorithm* dh = CryptoFactory::i()->getAsymmetricAlgorithm(AsymAlgo::DH); + if (dh == NULL) + return false; + PrivateKey* priv = dh->newPrivateKey(); + if (priv == NULL) + { + CryptoFactory::i()->recycleAsymmetricAlgorithm(dh); + return false; + } + if (!priv->PKCS8Decode(ber)) + { + dh->recyclePrivateKey(priv); + CryptoFactory::i()->recycleAsymmetricAlgorithm(dh); + return false; + } + // DH Private Key Attributes + ByteString prime; + ByteString generator; + ByteString value; + if (isPrivate) + { + 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(); + } + bool bOK = true; + bOK = bOK && key->setAttribute(CKA_PRIME, prime); + bOK = bOK && key->setAttribute(CKA_BASE, generator); + bOK = bOK && key->setAttribute(CKA_VALUE, value); + + dh->recyclePrivateKey(priv); + CryptoFactory::i()->recycleAsymmetricAlgorithm(dh); + + return bOK; +} +bool SoftHSM::setECPrivateKey(OSObject* key, const ByteString &ber, Token* token, bool isPrivate) const +{ + AsymmetricAlgorithm* ecc = CryptoFactory::i()->getAsymmetricAlgorithm(AsymAlgo::ECDSA); + if (ecc == NULL) + return false; + PrivateKey* priv = ecc->newPrivateKey(); + if (priv == NULL) + { + CryptoFactory::i()->recycleAsymmetricAlgorithm(ecc); + return false; + } + if (!priv->PKCS8Decode(ber)) + { + ecc->recyclePrivateKey(priv); + CryptoFactory::i()->recycleAsymmetricAlgorithm(ecc); + return false; + } + // EC Private Key Attributes + ByteString group; + ByteString value; + if (isPrivate) + { + token->encrypt(((ECPrivateKey*)priv)->getEC(), group); + token->encrypt(((ECPrivateKey*)priv)->getD(), value); + } + else + { + group = ((ECPrivateKey*)priv)->getEC(); + value = ((ECPrivateKey*)priv)->getD(); + } + bool bOK = true; + bOK = bOK && key->setAttribute(CKA_EC_PARAMS, group); + bOK = bOK && key->setAttribute(CKA_VALUE, value); + + ecc->recyclePrivateKey(priv); + CryptoFactory::i()->recycleAsymmetricAlgorithm(ecc); + + return bOK; +} + +CK_RV SoftHSM::MechParamCheckRSAPKCSOAEP(CK_MECHANISM_PTR pMechanism) +{ + // This is a programming error + 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)) + { + 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) + { + ERROR_MSG("ulSourceDataLen must be 0"); + return CKR_ARGUMENTS_BAD; + } + return CKR_OK; +} + +bool SoftHSM::isMechanismPermitted(OSObject* key, CK_MECHANISM_PTR pMechanism) { + OSAttribute attribute = key->getAttribute(CKA_ALLOWED_MECHANISMS); + std::set<CK_MECHANISM_TYPE> allowed = attribute.getMechanismTypeSetValue(); + if (allowed.empty()) { + return true; + } + + return allowed.find(pMechanism->mechanism) != allowed.end(); +} |