/* * Copyright (c)2010 SURFnet bv * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS * INTERRUPTION)HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR * OTHERWISE)ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ /***************************************************************************** main.cpp This file contains the main entry point to the PKCS #11 library. All it does is dispatch calls to the actual implementation and check for fatal exceptions on the boundary of the library. *****************************************************************************/ // The functions are exported library/DLL entry points #define CRYPTOKI_EXPORTS #include "config.h" #include "log.h" #include "fatal.h" #include "cryptoki.h" #include "SoftHSM.h" #if defined(__GNUC__) && \ (__GNUC__ >= 4 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 3)) || \ defined(__SUNPRO_C) && __SUNPRO_C >= 0x590 #define PKCS_API __attribute__ ((visibility("default"))) #else #define PKCS_API #endif // PKCS #11 function list static CK_FUNCTION_LIST functionList = { // Version information { CRYPTOKI_VERSION_MAJOR, CRYPTOKI_VERSION_MINOR }, // Function pointers C_Initialize, C_Finalize, C_GetInfo, C_GetFunctionList, C_GetSlotList, C_GetSlotInfo, C_GetTokenInfo, C_GetMechanismList, C_GetMechanismInfo, C_InitToken, C_InitPIN, C_SetPIN, C_OpenSession, C_CloseSession, C_CloseAllSessions, C_GetSessionInfo, C_GetOperationState, C_SetOperationState, C_Login, C_Logout, C_CreateObject, C_CopyObject, C_DestroyObject, C_GetObjectSize, C_GetAttributeValue, C_SetAttributeValue, C_FindObjectsInit, C_FindObjects, C_FindObjectsFinal, C_EncryptInit, C_Encrypt, C_EncryptUpdate, C_EncryptFinal, C_DecryptInit, C_Decrypt, C_DecryptUpdate, C_DecryptFinal, C_DigestInit, C_Digest, C_DigestUpdate, C_DigestKey, C_DigestFinal, C_SignInit, C_Sign, C_SignUpdate, C_SignFinal, C_SignRecoverInit, C_SignRecover, C_VerifyInit, C_Verify, C_VerifyUpdate, C_VerifyFinal, C_VerifyRecoverInit, C_VerifyRecover, C_DigestEncryptUpdate, C_DecryptDigestUpdate, C_SignEncryptUpdate, C_DecryptVerifyUpdate, C_GenerateKey, C_GenerateKeyPair, C_WrapKey, C_UnwrapKey, C_DeriveKey, C_SeedRandom, C_GenerateRandom, C_GetFunctionStatus, C_CancelFunction, C_WaitForSlotEvent }; // PKCS #11 initialisation function PKCS_API CK_RV C_Initialize(CK_VOID_PTR pInitArgs) { try { return SoftHSM::i()->C_Initialize(pInitArgs); } catch (...) { FatalException(); } return CKR_FUNCTION_FAILED; } // PKCS #11 finalisation function PKCS_API CK_RV C_Finalize(CK_VOID_PTR pReserved) { try { return SoftHSM::i()->C_Finalize(pReserved); } catch (...) { FatalException(); } return CKR_FUNCTION_FAILED; } // Return information about the PKCS #11 module PKCS_API CK_RV C_GetInfo(CK_INFO_PTR pInfo) { try { return SoftHSM::i()->C_GetInfo(pInfo); } catch (...) { FatalException(); } return CKR_FUNCTION_FAILED; } // Return the list of PKCS #11 functions PKCS_API CK_RV C_GetFunctionList(CK_FUNCTION_LIST_PTR_PTR ppFunctionList) { try { if (ppFunctionList == NULL_PTR) return CKR_ARGUMENTS_BAD; *ppFunctionList = &functionList; return CKR_OK; } catch (...) { FatalException(); } return CKR_FUNCTION_FAILED; } // Return a list of available slots PKCS_API CK_RV C_GetSlotList(CK_BBOOL tokenPresent, CK_SLOT_ID_PTR pSlotList, CK_ULONG_PTR pulCount) { try { return SoftHSM::i()->C_GetSlotList(tokenPresent, pSlotList, pulCount); } catch (...) { FatalException(); } return CKR_FUNCTION_FAILED; } // Return information about a slot PKCS_API CK_RV C_GetSlotInfo(CK_SLOT_ID slotID, CK_SLOT_INFO_PTR pInfo) { try { return SoftHSM::i()->C_GetSlotInfo(slotID, pInfo); } catch (...) { FatalException(); } return CKR_FUNCTION_FAILED; } // Return information about a token in a slot PKCS_API CK_RV C_GetTokenInfo(CK_SLOT_ID slotID, CK_TOKEN_INFO_PTR pInfo) { try { return SoftHSM::i()->C_GetTokenInfo(slotID, pInfo); } catch (...) { FatalException(); } return CKR_FUNCTION_FAILED; } // Return the list of supported mechanisms for a given slot PKCS_API CK_RV C_GetMechanismList(CK_SLOT_ID slotID, CK_MECHANISM_TYPE_PTR pMechanismList, CK_ULONG_PTR pulCount) { try { return SoftHSM::i()->C_GetMechanismList(slotID, pMechanismList, pulCount); } catch (...) { FatalException(); } return CKR_FUNCTION_FAILED; } // Return more information about a mechanism for a given slot PKCS_API CK_RV C_GetMechanismInfo(CK_SLOT_ID slotID, CK_MECHANISM_TYPE type, CK_MECHANISM_INFO_PTR pInfo) { try { return SoftHSM::i()->C_GetMechanismInfo(slotID, type, pInfo); } catch (...) { FatalException(); } return CKR_FUNCTION_FAILED; } // Initialise the token in the specified slot PKCS_API CK_RV C_InitToken(CK_SLOT_ID slotID, CK_UTF8CHAR_PTR pPin, CK_ULONG ulPinLen, CK_UTF8CHAR_PTR pLabel) { try { return SoftHSM::i()->C_InitToken(slotID, pPin, ulPinLen, pLabel); } catch (...) { FatalException(); } return CKR_FUNCTION_FAILED; } // Initialise the user PIN PKCS_API CK_RV C_InitPIN(CK_SESSION_HANDLE hSession, CK_UTF8CHAR_PTR pPin, CK_ULONG ulPinLen) { try { return SoftHSM::i()->C_InitPIN(hSession, pPin, ulPinLen); } catch (...) { FatalException(); } return CKR_FUNCTION_FAILED; } // Change the PIN PKCS_API CK_RV C_SetPIN(CK_SESSION_HANDLE hSession, CK_UTF8CHAR_PTR pOldPin, CK_ULONG ulOldLen, CK_UTF8CHAR_PTR pNewPin, CK_ULONG ulNewLen) { try { return SoftHSM::i()->C_SetPIN(hSession, pOldPin, ulOldLen, pNewPin, ulNewLen); } catch (...) { FatalException(); } return CKR_FUNCTION_FAILED; } // Open a new session to the specified slot PKCS_API CK_RV C_OpenSession(CK_SLOT_ID slotID, CK_FLAGS flags, CK_VOID_PTR pApplication, CK_NOTIFY notify, CK_SESSION_HANDLE_PTR phSession) { try { return SoftHSM::i()->C_OpenSession(slotID, flags, pApplication, notify, phSession); } catch (...) { FatalException(); } return CKR_FUNCTION_FAILED; } // Close the given session PKCS_API CK_RV C_CloseSession(CK_SESSION_HANDLE hSession) { try { return SoftHSM::i()->C_CloseSession(hSession); } catch (...) { FatalException(); } return CKR_FUNCTION_FAILED; } // Close all open sessions PKCS_API CK_RV C_CloseAllSessions(CK_SLOT_ID slotID) { try { return SoftHSM::i()->C_CloseAllSessions(slotID); } catch (...) { FatalException(); } return CKR_FUNCTION_FAILED; } // Retrieve information about the specified session PKCS_API CK_RV C_GetSessionInfo(CK_SESSION_HANDLE hSession, CK_SESSION_INFO_PTR pInfo) { try { return SoftHSM::i()->C_GetSessionInfo(hSession, pInfo); } catch (...) { FatalException(); } return CKR_FUNCTION_FAILED; } // Determine the state of a running operation in a session PKCS_API CK_RV C_GetOperationState(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pOperationState, CK_ULONG_PTR pulOperationStateLen) { try { return SoftHSM::i()->C_GetOperationState(hSession, pOperationState, pulOperationStateLen); } catch (...) { FatalException(); } return CKR_FUNCTION_FAILED; } // Set the operation sate in a session PKCS_API CK_RV C_SetOperationState(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pOperationState, CK_ULONG ulOperationStateLen, CK_OBJECT_HANDLE hEncryptionKey, CK_OBJECT_HANDLE hAuthenticationKey) { try { return SoftHSM::i()->C_SetOperationState(hSession, pOperationState, ulOperationStateLen, hEncryptionKey, hAuthenticationKey); } catch (...) { FatalException(); } return CKR_FUNCTION_FAILED; } // Login on the token in the specified session PKCS_API CK_RV C_Login(CK_SESSION_HANDLE hSession, CK_USER_TYPE userType, CK_UTF8CHAR_PTR pPin, CK_ULONG ulPinLen) { try { return SoftHSM::i()->C_Login(hSession, userType, pPin, ulPinLen); } catch (...) { FatalException(); } return CKR_FUNCTION_FAILED; } // Log out of the token in the specified session PKCS_API CK_RV C_Logout(CK_SESSION_HANDLE hSession) { try { return SoftHSM::i()->C_Logout(hSession); } catch (...) { FatalException(); } return CKR_FUNCTION_FAILED; } // Create a new object on the token in the specified session using the given attribute template PKCS_API CK_RV C_CreateObject(CK_SESSION_HANDLE hSession, CK_ATTRIBUTE_PTR pTemplate, CK_ULONG ulCount, CK_OBJECT_HANDLE_PTR phObject) { try { return SoftHSM::i()->C_CreateObject(hSession, pTemplate, ulCount, phObject); } catch (...) { FatalException(); } return CKR_FUNCTION_FAILED; } // Create a copy of the object with the specified handle PKCS_API CK_RV C_CopyObject(CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE hObject, CK_ATTRIBUTE_PTR pTemplate, CK_ULONG ulCount, CK_OBJECT_HANDLE_PTR phNewObject) { try { return SoftHSM::i()->C_CopyObject(hSession, hObject, pTemplate, ulCount, phNewObject); } catch (...) { FatalException(); } return CKR_FUNCTION_FAILED; } // Destroy the specified object PKCS_API CK_RV C_DestroyObject(CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE hObject) { try { return SoftHSM::i()->C_DestroyObject(hSession, hObject); } catch (...) { FatalException(); } return CKR_FUNCTION_FAILED; } // Determine the size of the specified object PKCS_API CK_RV C_GetObjectSize(CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE hObject, CK_ULONG_PTR pulSize) { try { return SoftHSM::i()->C_GetObjectSize(hSession, hObject, pulSize); } catch (...) { FatalException(); } return CKR_FUNCTION_FAILED; } // Retrieve the specified attributes for the given object PKCS_API CK_RV C_GetAttributeValue(CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE hObject, CK_ATTRIBUTE_PTR pTemplate, CK_ULONG ulCount) { try { return SoftHSM::i()->C_GetAttributeValue(hSession, hObject, pTemplate, ulCount); } catch (...) { FatalException(); } return CKR_FUNCTION_FAILED; } // Change or set the value of the specified attributes on the specified object PKCS_API CK_RV C_SetAttributeValue(CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE hObject, CK_ATTRIBUTE_PTR pTemplate, CK_ULONG ulCount) { try { return SoftHSM::i()->C_SetAttributeValue(hSession, hObject, pTemplate, ulCount); } catch (...) { FatalException(); } return CKR_FUNCTION_FAILED; } // Initialise object search in the specified session using the specified attribute template as search parameters PKCS_API CK_RV C_FindObjectsInit(CK_SESSION_HANDLE hSession, CK_ATTRIBUTE_PTR pTemplate, CK_ULONG ulCount) { try { return SoftHSM::i()->C_FindObjectsInit(hSession, pTemplate, ulCount); } catch (...) { FatalException(); } return CKR_FUNCTION_FAILED; } // Continue the search for objects in the specified session PKCS_API CK_RV C_FindObjects(CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE_PTR phObject, CK_ULONG ulMaxObjectCount, CK_ULONG_PTR pulObjectCount) { try { return SoftHSM::i()->C_FindObjects(hSession, phObject, ulMaxObjectCount, pulObjectCount); } catch (...) { FatalException(); } return CKR_FUNCTION_FAILED; } // Finish searching for objects PKCS_API CK_RV C_FindObjectsFinal(CK_SESSION_HANDLE hSession) { try { return SoftHSM::i()->C_FindObjectsFinal(hSession); } catch (...) { FatalException(); } return CKR_FUNCTION_FAILED; } // Initialise encryption using the specified object and mechanism PKCS_API CK_RV C_EncryptInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechanism, CK_OBJECT_HANDLE hObject) { try { return SoftHSM::i()->C_EncryptInit(hSession, pMechanism, hObject); } catch (...) { FatalException(); } return CKR_FUNCTION_FAILED; } // Perform a single operation encryption operation in the specified session PKCS_API CK_RV C_Encrypt(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pData, CK_ULONG ulDataLen, CK_BYTE_PTR pEncryptedData, CK_ULONG_PTR pulEncryptedDataLen) { try { return SoftHSM::i()->C_Encrypt(hSession, pData, ulDataLen, pEncryptedData, pulEncryptedDataLen); } catch (...) { FatalException(); } return CKR_FUNCTION_FAILED; } // Feed data to the running encryption operation in a session PKCS_API CK_RV C_EncryptUpdate(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pData, CK_ULONG ulDataLen, CK_BYTE_PTR pEncryptedData, CK_ULONG_PTR pulEncryptedDataLen) { try { return SoftHSM::i()->C_EncryptUpdate(hSession, pData, ulDataLen, pEncryptedData, pulEncryptedDataLen); } catch (...) { FatalException(); } return CKR_FUNCTION_FAILED; } // Finalise the encryption operation PKCS_API CK_RV C_EncryptFinal(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pEncryptedData, CK_ULONG_PTR pulEncryptedDataLen) { try { return SoftHSM::i()->C_EncryptFinal(hSession, pEncryptedData, pulEncryptedDataLen); } catch (...) { FatalException(); } return CKR_FUNCTION_FAILED; } // Initialise decryption using the specified object PKCS_API CK_RV C_DecryptInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechanism, CK_OBJECT_HANDLE hObject) { try { return SoftHSM::i()->C_DecryptInit(hSession, pMechanism, hObject); } catch (...) { FatalException(); } return CKR_FUNCTION_FAILED; } // Perform a single operation decryption in the given session PKCS_API CK_RV C_Decrypt(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pEncryptedData, CK_ULONG ulEncryptedDataLen, CK_BYTE_PTR pData, CK_ULONG_PTR pulDataLen) { try { return SoftHSM::i()->C_Decrypt(hSession, pEncryptedData, ulEncryptedDataLen, pData, pulDataLen); } catch (...) { FatalException(); } return CKR_FUNCTION_FAILED; } // Feed data to the running decryption operation in a session PKCS_API CK_RV C_DecryptUpdate(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pEncryptedData, CK_ULONG ulEncryptedDataLen, CK_BYTE_PTR pData, CK_ULONG_PTR pDataLen) { try { return SoftHSM::i()->C_DecryptUpdate(hSession, pEncryptedData, ulEncryptedDataLen, pData, pDataLen); } catch (...) { FatalException(); } return CKR_FUNCTION_FAILED; } // Finalise the decryption operation PKCS_API CK_RV C_DecryptFinal(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pData, CK_ULONG_PTR pDataLen) { try { return SoftHSM::i()->C_DecryptFinal(hSession, pData, pDataLen); } catch (...) { FatalException(); } return CKR_FUNCTION_FAILED; } // Initialise digesting using the specified mechanism in the specified session PKCS_API CK_RV C_DigestInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechanism) { try { return SoftHSM::i()->C_DigestInit(hSession, pMechanism); } catch (...) { FatalException(); } return CKR_FUNCTION_FAILED; } // Digest the specified data in a one-pass operation and return the resulting digest PKCS_API CK_RV C_Digest(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pData, CK_ULONG ulDataLen, CK_BYTE_PTR pDigest, CK_ULONG_PTR pulDigestLen) { try { return SoftHSM::i()->C_Digest(hSession, pData, ulDataLen, pDigest, pulDigestLen); } catch (...) { FatalException(); } return CKR_FUNCTION_FAILED; } // Update a running digest operation PKCS_API CK_RV C_DigestUpdate(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pPart, CK_ULONG ulPartLen) { try { return SoftHSM::i()->C_DigestUpdate(hSession, pPart, ulPartLen); } catch (...) { FatalException(); } return CKR_FUNCTION_FAILED; } // Update a running digest operation by digesting a secret key with the specified handle PKCS_API CK_RV C_DigestKey(CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE hObject) { try { return SoftHSM::i()->C_DigestKey(hSession, hObject); } catch (...) { FatalException(); } return CKR_FUNCTION_FAILED; } // Finalise the digest operation in the specified session and return the digest PKCS_API CK_RV C_DigestFinal(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pDigest, CK_ULONG_PTR pulDigestLen) { try { return SoftHSM::i()->C_DigestFinal(hSession, pDigest, pulDigestLen); } catch (...) { FatalException(); } return CKR_FUNCTION_FAILED; } // Initialise a signing operation using the specified key and mechanism PKCS_API CK_RV C_SignInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechanism, CK_OBJECT_HANDLE hKey) { try { return SoftHSM::i()->C_SignInit(hSession, pMechanism, hKey); } catch (...) { FatalException(); } return CKR_FUNCTION_FAILED; } // Sign the data in a single pass operation PKCS_API CK_RV C_Sign(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pData, CK_ULONG ulDataLen, CK_BYTE_PTR pSignature, CK_ULONG_PTR pulSignatureLen) { try { return SoftHSM::i()->C_Sign(hSession, pData, ulDataLen, pSignature, pulSignatureLen); } catch (...) { FatalException(); } return CKR_FUNCTION_FAILED; } // Update a running signing operation with additional data PKCS_API CK_RV C_SignUpdate(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pPart, CK_ULONG ulPartLen) { try { return SoftHSM::i()->C_SignUpdate(hSession, pPart, ulPartLen); } catch (...) { FatalException(); } return CKR_FUNCTION_FAILED; } // Finalise a running signing operation and return the signature PKCS_API CK_RV C_SignFinal(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pSignature, CK_ULONG_PTR pulSignatureLen) { try { return SoftHSM::i()->C_SignFinal(hSession, pSignature, pulSignatureLen); } catch (...) { FatalException(); } return CKR_FUNCTION_FAILED; } // Initialise a signing operation that allows recovery of the signed data PKCS_API CK_RV C_SignRecoverInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechanism, CK_OBJECT_HANDLE hKey) { try { return SoftHSM::i()->C_SignRecoverInit(hSession, pMechanism, hKey); } catch (...) { FatalException(); } return CKR_FUNCTION_FAILED; } // Perform a single part signing operation that allows recovery of the signed data PKCS_API CK_RV C_SignRecover(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pData, CK_ULONG ulDataLen, CK_BYTE_PTR pSignature, CK_ULONG_PTR pulSignatureLen) { try { return SoftHSM::i()->C_SignRecover(hSession, pData, ulDataLen, pSignature, pulSignatureLen); } catch (...) { FatalException(); } return CKR_FUNCTION_FAILED; } // Initialise a verification operation using the specified key and mechanism PKCS_API CK_RV C_VerifyInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechanism, CK_OBJECT_HANDLE hKey) { try { return SoftHSM::i()->C_VerifyInit(hSession, pMechanism, hKey); } catch (...) { FatalException(); } return CKR_FUNCTION_FAILED; } // Perform a single pass verification operation PKCS_API CK_RV C_Verify(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pData, CK_ULONG ulDataLen, CK_BYTE_PTR pSignature, CK_ULONG ulSignatureLen) { try { return SoftHSM::i()->C_Verify(hSession, pData, ulDataLen, pSignature, ulSignatureLen); } catch (...) { FatalException(); } return CKR_FUNCTION_FAILED; } // Update a running verification operation with additional data PKCS_API CK_RV C_VerifyUpdate(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pPart, CK_ULONG ulPartLen) { try { return SoftHSM::i()->C_VerifyUpdate(hSession, pPart, ulPartLen); } catch (...) { FatalException(); } return CKR_FUNCTION_FAILED; } // Finalise the verification operation and check the signature PKCS_API CK_RV C_VerifyFinal(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pSignature, CK_ULONG ulSignatureLen) { try { return SoftHSM::i()->C_VerifyFinal(hSession, pSignature, ulSignatureLen); } catch (...) { FatalException(); } return CKR_FUNCTION_FAILED; } // Initialise a verification operation the allows recovery of the signed data from the signature PKCS_API CK_RV C_VerifyRecoverInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechanism, CK_OBJECT_HANDLE hKey) { try { return SoftHSM::i()->C_VerifyRecoverInit(hSession, pMechanism, hKey); } catch (...) { FatalException(); } return CKR_FUNCTION_FAILED; } // Perform a single part verification operation and recover the signed data PKCS_API CK_RV C_VerifyRecover(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pSignature, CK_ULONG ulSignatureLen, CK_BYTE_PTR pData, CK_ULONG_PTR pulDataLen) { try { return SoftHSM::i()->C_VerifyRecover(hSession, pSignature, ulSignatureLen, pData, pulDataLen); } catch (...) { FatalException(); } return CKR_FUNCTION_FAILED; } // Update a running multi-part encryption and digesting operation PKCS_API CK_RV C_DigestEncryptUpdate(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pPart, CK_ULONG ulPartLen, CK_BYTE_PTR pEncryptedPart, CK_ULONG_PTR pulEncryptedPartLen) { try { return SoftHSM::i()->C_DigestEncryptUpdate(hSession, pPart, ulPartLen, pEncryptedPart, pulEncryptedPartLen); } catch (...) { FatalException(); } return CKR_FUNCTION_FAILED; } // Update a running multi-part decryption and digesting operation PKCS_API CK_RV C_DecryptDigestUpdate(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pPart, CK_ULONG ulPartLen, CK_BYTE_PTR pDecryptedPart, CK_ULONG_PTR pulDecryptedPartLen) { try { return SoftHSM::i()->C_DecryptDigestUpdate(hSession, pPart, ulPartLen, pDecryptedPart, pulDecryptedPartLen); } catch (...) { FatalException(); } return CKR_FUNCTION_FAILED; } // Update a running multi-part signing and encryption operation PKCS_API CK_RV C_SignEncryptUpdate(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pPart, CK_ULONG ulPartLen, CK_BYTE_PTR pEncryptedPart, CK_ULONG_PTR pulEncryptedPartLen) { try { return SoftHSM::i()->C_SignEncryptUpdate(hSession, pPart, ulPartLen, pEncryptedPart, pulEncryptedPartLen); } catch (...) { FatalException(); } return CKR_FUNCTION_FAILED; } // Update a running multi-part decryption and verification operation PKCS_API CK_RV C_DecryptVerifyUpdate(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pEncryptedPart, CK_ULONG ulEncryptedPartLen, CK_BYTE_PTR pPart, CK_ULONG_PTR pulPartLen) { try { return SoftHSM::i()->C_DecryptVerifyUpdate(hSession, pEncryptedPart, ulEncryptedPartLen, pPart, pulPartLen); } catch (...) { FatalException(); } return CKR_FUNCTION_FAILED; } // Generate a secret key using the specified mechanism PKCS_API CK_RV C_GenerateKey(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechanism, CK_ATTRIBUTE_PTR pTemplate, CK_ULONG ulCount, CK_OBJECT_HANDLE_PTR phKey) { try { return SoftHSM::i()->C_GenerateKey(hSession, pMechanism, pTemplate, ulCount, phKey); } catch (...) { FatalException(); } return CKR_FUNCTION_FAILED; } // Generate a key-pair using the specified mechanism PKCS_API CK_RV 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 ) { try { return SoftHSM::i()->C_GenerateKeyPair(hSession, pMechanism, pPublicKeyTemplate, ulPublicKeyAttributeCount, pPrivateKeyTemplate, ulPrivateKeyAttributeCount, phPublicKey, phPrivateKey); } catch (...) { FatalException(); } return CKR_FUNCTION_FAILED; } // Wrap the specified key using the specified wrapping key and mechanism PKCS_API CK_RV 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 ) { try { return SoftHSM::i()->C_WrapKey(hSession, pMechanism, hWrappingKey, hKey, pWrappedKey, pulWrappedKeyLen); } catch (...) { FatalException(); } return CKR_FUNCTION_FAILED; } // Unwrap the specified key using the specified unwrapping key PKCS_API CK_RV 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 phKey ) { try { return SoftHSM::i()->C_UnwrapKey(hSession, pMechanism, hUnwrappingKey, pWrappedKey, ulWrappedKeyLen, pTemplate, ulCount, phKey); } catch (...) { FatalException(); } return CKR_FUNCTION_FAILED; } // Derive a key from the specified base key PKCS_API CK_RV 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 ) { try { return SoftHSM::i()->C_DeriveKey(hSession, pMechanism, hBaseKey, pTemplate, ulCount, phKey); } catch (...) { FatalException(); } return CKR_FUNCTION_FAILED; } // Seed the random number generator with new data PKCS_API CK_RV C_SeedRandom(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pSeed, CK_ULONG ulSeedLen) { try { return SoftHSM::i()->C_SeedRandom(hSession, pSeed, ulSeedLen); } catch (...) { FatalException(); } return CKR_FUNCTION_FAILED; } // Generate the specified amount of random data PKCS_API CK_RV C_GenerateRandom(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pRandomData, CK_ULONG ulRandomLen) { try { return SoftHSM::i()->C_GenerateRandom(hSession, pRandomData, ulRandomLen); } catch (...) { FatalException(); } return CKR_FUNCTION_FAILED; } // Legacy function PKCS_API CK_RV C_GetFunctionStatus(CK_SESSION_HANDLE hSession) { try { return SoftHSM::i()->C_GetFunctionStatus(hSession); } catch (...) { FatalException(); } return CKR_FUNCTION_FAILED; } // Legacy function PKCS_API CK_RV C_CancelFunction(CK_SESSION_HANDLE hSession) { try { return SoftHSM::i()->C_CancelFunction(hSession); } catch (...) { FatalException(); } return CKR_FUNCTION_FAILED; } // Wait or poll for a slot even on the specified slot PKCS_API CK_RV C_WaitForSlotEvent(CK_FLAGS flags, CK_SLOT_ID_PTR pSlot, CK_VOID_PTR pReserved) { try { return SoftHSM::i()->C_WaitForSlotEvent(flags, pSlot, pReserved); } catch (...) { FatalException(); } return CKR_FUNCTION_FAILED; }