path: root/SoftHSMv2/src/lib/main.cpp

/*
 * 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;
}