From f26b580ae9a3bc7c4de1926962b0a93c56a3c357 Mon Sep 17 00:00:00 2001 From: Ingo Franzki Date: Mon, 4 May 2026 11:40:24 +0200 Subject: [PATCH 01/17] pkcs11: Add a PKCS#11 interface for libzpc Add the initial skeleton for a PKCS#11 v3.2 shared library (zpcpkcs11). Implement C_Initialize, C_Finalize, C_GetInfo, C_GetFunctionList, C_GetInterfaceList, and C_GetInterface. All other functions return CKR_FUNCTION_NOT_SUPPORTED. Signed-off-by: Ingo Franzki --- CMakeLists.txt | 39 ++ src/pkcs11/pkcs11.c | 1537 +++++++++++++++++++++++++++++++++++++++++++ src/pkcs11/pkcs11.h | 1233 ++++++++++++++++++++++++++++++++++ zpcpkcs11.map | 110 ++++ 4 files changed, 2919 insertions(+) create mode 100644 src/pkcs11/pkcs11.c create mode 100644 src/pkcs11/pkcs11.h create mode 100644 zpcpkcs11.map diff --git a/CMakeLists.txt b/CMakeLists.txt index 74e36846..22fee41f 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -387,6 +387,45 @@ install( DESTINATION ${CMAKE_INSTALL_MANDIR}/man1 ) +########################################################### +# zpckcs11 + +if (${CMAKE_SYSTEM_PROCESSOR} STREQUAL s390x) + +set(ZPCPKCS11_SOURCES + src/pkcs11/pkcs11.c +) + +add_library(zpcpkcs11 SHARED ${ZPCPKCS11_SOURCES}) +set_target_properties(zpcpkcs11 + PROPERTIES + PREFIX "" + C_VISIBILITY_PRESET default + LINK_FLAGS "-Wl,--version-script=${CMAKE_SOURCE_DIR}/zpcpkcs11.map" +) +target_compile_definitions( + zpcpkcs11 PRIVATE + ZPCPKCS11_VERSION_MAJOR=${ZPC_VERSION_MAJOR} + ZPCPKCS11_VERSION_MINOR=${ZPC_VERSION_MINOR} + ZPCPKCS11_VERSION_PATCH=${ZPC_VERSION_PATCH} +) +target_include_directories(zpcpkcs11 PRIVATE src/pkcs11) + +if(PkgConfig_FOUND) + pkg_get_variable(P11KIT_MODULEDIR p11-kit-1 p11_module_path) +endif() +if(NOT P11KIT_MODULEDIR) + set(P11KIT_MODULEDIR "${CMAKE_INSTALL_LIBDIR}/pkcs11") +endif() +message(STATUS "PKCS#11 module install directory: ${P11KIT_MODULEDIR}") + +install( + TARGETS zpcpkcs11 + LIBRARY DESTINATION ${P11KIT_MODULEDIR} +) + +endif() # CMAKE_SYSTEM_PROCESSOR == s390x + ########################################################### # Test diff --git a/src/pkcs11/pkcs11.c b/src/pkcs11/pkcs11.c new file mode 100644 index 00000000..e0f0742c --- /dev/null +++ b/src/pkcs11/pkcs11.c @@ -0,0 +1,1537 @@ +// SPDX-License-Identifier: MIT +// Copyright contributors to the libzpc project +#include +#include +#include "pkcs11.h" + +#define PKCS11_MANUFACTURER "IBM" +#define PKCS11_LIBRARY_DESC "ZPC PKCS#11 provider" + +CK_RV C_Finalize(CK_VOID_PTR pReserved); + +/* + * As per PKCS#11 spec, C_Initialize and C_Finalize are both single-threaded. + * It is the application's responsibility to ensure C_Initialize and C_Finalize + * are not called concurrently with each other or with any other C_ function. + * This no locking is needed or the api_initialized flag. + */ +static volatile CK_BBOOL api_initialized = CK_FALSE; +static pthread_once_t atfork_once = PTHREAD_ONCE_INIT; + +/* General purpose functions */ + +static void child_fork_initializer(void) +{ + C_Finalize(NULL); +} + +static void register_atfork(void) +{ + pthread_atfork(NULL, NULL, child_fork_initializer); +} + +CK_RV C_Initialize(CK_VOID_PTR pInitArgs) +{ + CK_C_INITIALIZE_ARGS *pArgs = pInitArgs; + + if (api_initialized) + return CKR_CRYPTOKI_ALREADY_INITIALIZED; + + if (pArgs != NULL) { + if (pArgs->pReserved != NULL) + return CKR_ARGUMENTS_BAD; + if ((pArgs->flags & CKF_LIBRARY_CANT_CREATE_OS_THREADS) != 0) + return CKR_ARGUMENTS_BAD; + if ((pArgs->flags & CKF_OS_LOCKING_OK) == 0 && + (pArgs->CreateMutex != NULL || pArgs->DestroyMutex != NULL || + pArgs->LockMutex != NULL || pArgs->UnlockMutex != NULL)) + return CKR_CANT_LOCK; + } + + pthread_once(&atfork_once, register_atfork); + + api_initialized = CK_TRUE; + return CKR_OK; +} + +CK_RV C_Finalize(CK_VOID_PTR pReserved) +{ + if (pReserved != NULL) + return CKR_ARGUMENTS_BAD; + + if (!api_initialized) + return CKR_CRYPTOKI_NOT_INITIALIZED; + + api_initialized = CK_FALSE; + return CKR_OK; +} + +CK_RV C_GetInfo(CK_INFO_PTR pInfo) +{ + if (pInfo == NULL) + return CKR_ARGUMENTS_BAD; + if (!api_initialized) + return CKR_CRYPTOKI_NOT_INITIALIZED; + + pInfo->cryptokiVersion.major = 3; + pInfo->cryptokiVersion.minor = 2; + + memset(pInfo->manufacturerID, ' ', sizeof(pInfo->manufacturerID)); + memcpy(pInfo->manufacturerID, PKCS11_MANUFACTURER, + strlen(PKCS11_MANUFACTURER)); + + pInfo->flags = 0; + + memset(pInfo->libraryDescription, ' ', + sizeof(pInfo->libraryDescription)); + memcpy(pInfo->libraryDescription, PKCS11_LIBRARY_DESC, + strlen(PKCS11_LIBRARY_DESC)); + + pInfo->libraryVersion.major = ZPCPKCS11_VERSION_MAJOR; + pInfo->libraryVersion.minor = ZPCPKCS11_VERSION_MINOR; + + return CKR_OK; +} + +/* Slot and token management functions */ + +CK_RV C_GetSlotList(CK_BBOOL tokenPresent, CK_SLOT_ID_PTR pSlotList, + CK_ULONG_PTR pulCount) +{ + (void)tokenPresent; + (void)pSlotList; + (void)pulCount; + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_GetSlotInfo(CK_SLOT_ID slotID, CK_SLOT_INFO_PTR pInfo) +{ + (void)slotID; + (void)pInfo; + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_GetTokenInfo(CK_SLOT_ID slotID, CK_TOKEN_INFO_PTR pInfo) +{ + (void)slotID; + (void)pInfo; + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_WaitForSlotEvent(CK_FLAGS flags, CK_SLOT_ID_PTR pSlot, + CK_VOID_PTR pReserved) +{ + (void)flags; + (void)pSlot; + (void)pReserved; + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_GetMechanismList(CK_SLOT_ID slotID, + CK_MECHANISM_TYPE_PTR pMechanismList, + CK_ULONG_PTR pulCount) +{ + (void)slotID; + (void)pMechanismList; + (void)pulCount; + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_GetMechanismInfo(CK_SLOT_ID slotID, CK_MECHANISM_TYPE type, + CK_MECHANISM_INFO_PTR pInfo) +{ + (void)slotID; + (void)type; + (void)pInfo; + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_InitToken(CK_SLOT_ID slotID, CK_UTF8CHAR_PTR pPin, CK_ULONG ulPinLen, + CK_UTF8CHAR_PTR pLabel) +{ + (void)slotID; + (void)pPin; + (void)ulPinLen; + (void)pLabel; + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_InitPIN(CK_SESSION_HANDLE hSession, CK_UTF8CHAR_PTR pPin, + CK_ULONG ulPinLen) +{ + (void)hSession; + (void)pPin; + (void)ulPinLen; + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_SetPIN(CK_SESSION_HANDLE hSession, CK_UTF8CHAR_PTR pOldPin, + CK_ULONG ulOldLen, CK_UTF8CHAR_PTR pNewPin, CK_ULONG ulNewLen) +{ + (void)hSession; + (void)pOldPin; + (void)ulOldLen; + (void)pNewPin; + (void)ulNewLen; + return CKR_FUNCTION_NOT_SUPPORTED; +} + +/* Session management functions */ + +CK_RV C_OpenSession(CK_SLOT_ID slotID, CK_FLAGS flags, CK_VOID_PTR pApplication, + CK_NOTIFY Notify, CK_SESSION_HANDLE_PTR phSession) +{ + (void)slotID; + (void)flags; + (void)pApplication; + (void)Notify; + (void)phSession; + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_CloseSession(CK_SESSION_HANDLE hSession) +{ + (void)hSession; + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_CloseAllSessions(CK_SLOT_ID slotID) +{ + (void)slotID; + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_GetSessionInfo(CK_SESSION_HANDLE hSession, CK_SESSION_INFO_PTR pInfo) +{ + (void)hSession; + (void)pInfo; + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_GetOperationState(CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pOperationState, + CK_ULONG_PTR pulOperationStateLen) +{ + (void)hSession; + (void)pOperationState; + (void)pulOperationStateLen; + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_SetOperationState(CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pOperationState, + CK_ULONG ulOperationStateLen, + CK_OBJECT_HANDLE hEncryptionKey, + CK_OBJECT_HANDLE hAuthenticationKey) +{ + (void)hSession; + (void)pOperationState; + (void)ulOperationStateLen; + (void)hEncryptionKey; + (void)hAuthenticationKey; + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_Login(CK_SESSION_HANDLE hSession, CK_USER_TYPE userType, + CK_UTF8CHAR_PTR pPin, CK_ULONG ulPinLen) +{ + (void)hSession; + (void)userType; + (void)pPin; + (void)ulPinLen; + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_Logout(CK_SESSION_HANDLE hSession) +{ + (void)hSession; + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_SessionCancel(CK_SESSION_HANDLE hSession, CK_FLAGS flags) +{ + (void)hSession; + (void)flags; + return CKR_FUNCTION_NOT_SUPPORTED; +} + +/* Object management functions */ + +CK_RV C_CreateObject(CK_SESSION_HANDLE hSession, CK_ATTRIBUTE_PTR pTemplate, + CK_ULONG ulCount, CK_OBJECT_HANDLE_PTR phObject) +{ + (void)hSession; + (void)pTemplate; + (void)ulCount; + (void)phObject; + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_CopyObject(CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE hObject, + CK_ATTRIBUTE_PTR pTemplate, CK_ULONG ulCount, + CK_OBJECT_HANDLE_PTR phNewObject) +{ + (void)hSession; + (void)hObject; + (void)pTemplate; + (void)ulCount; + (void)phNewObject; + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_DestroyObject(CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE hObject) +{ + (void)hSession; + (void)hObject; + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_GetObjectSize(CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE hObject, + CK_ULONG_PTR pulSize) +{ + (void)hSession; + (void)hObject; + (void)pulSize; + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_GetAttributeValue(CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE hObject, + CK_ATTRIBUTE_PTR pTemplate, CK_ULONG ulCount) +{ + (void)hSession; + (void)hObject; + (void)pTemplate; + (void)ulCount; + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_SetAttributeValue(CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE hObject, + CK_ATTRIBUTE_PTR pTemplate, CK_ULONG ulCount) +{ + (void)hSession; + (void)hObject; + (void)pTemplate; + (void)ulCount; + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_FindObjectsInit(CK_SESSION_HANDLE hSession, CK_ATTRIBUTE_PTR pTemplate, + CK_ULONG ulCount) +{ + (void)hSession; + (void)pTemplate; + (void)ulCount; + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_FindObjects(CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE_PTR phObject, + CK_ULONG ulMaxObjectCount, CK_ULONG_PTR pulObjectCount) +{ + (void)hSession; + (void)phObject; + (void)ulMaxObjectCount; + (void)pulObjectCount; + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_FindObjectsFinal(CK_SESSION_HANDLE hSession) +{ + (void)hSession; + return CKR_FUNCTION_NOT_SUPPORTED; +} + +/* Encryption functions */ + +CK_RV C_EncryptInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechanism, + CK_OBJECT_HANDLE hKey) +{ + (void)hSession; + (void)pMechanism; + (void)hKey; + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_Encrypt(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pData, + CK_ULONG ulDataLen, CK_BYTE_PTR pEncryptedData, + CK_ULONG_PTR pulEncryptedDataLen) +{ + (void)hSession; + (void)pData; + (void)ulDataLen; + (void)pEncryptedData; + (void)pulEncryptedDataLen; + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_EncryptUpdate(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pPart, + CK_ULONG ulPartLen, CK_BYTE_PTR pEncryptedPart, + CK_ULONG_PTR pulEncryptedPartLen) +{ + (void)hSession; + (void)pPart; + (void)ulPartLen; + (void)pEncryptedPart; + (void)pulEncryptedPartLen; + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_EncryptFinal(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pLastEncryptedPart, + CK_ULONG_PTR pulLastEncryptedPartLen) +{ + (void)hSession; + (void)pLastEncryptedPart; + (void)pulLastEncryptedPartLen; + return CKR_FUNCTION_NOT_SUPPORTED; +} + +/* Decryption functions */ + +CK_RV C_DecryptInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechanism, + CK_OBJECT_HANDLE hKey) +{ + (void)hSession; + (void)pMechanism; + (void)hKey; + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_Decrypt(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pEncryptedData, + CK_ULONG ulEncryptedDataLen, CK_BYTE_PTR pData, + CK_ULONG_PTR pulDataLen) +{ + (void)hSession; + (void)pEncryptedData; + (void)ulEncryptedDataLen; + (void)pData; + (void)pulDataLen; + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_DecryptUpdate(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pEncryptedPart, + CK_ULONG ulEncryptedPartLen, CK_BYTE_PTR pPart, + CK_ULONG_PTR pulPartLen) +{ + (void)hSession; + (void)pEncryptedPart; + (void)ulEncryptedPartLen; + (void)pPart; + (void)pulPartLen; + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_DecryptFinal(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pLastPart, + CK_ULONG_PTR pulLastPartLen) +{ + (void)hSession; + (void)pLastPart; + (void)pulLastPartLen; + return CKR_FUNCTION_NOT_SUPPORTED; +} + +/* Message digesting functions */ + +CK_RV C_DigestInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechanism) +{ + (void)hSession; + (void)pMechanism; + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_Digest(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pData, + CK_ULONG ulDataLen, CK_BYTE_PTR pDigest, + CK_ULONG_PTR pulDigestLen) +{ + (void)hSession; + (void)pData; + (void)ulDataLen; + (void)pDigest; + (void)pulDigestLen; + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_DigestUpdate(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pPart, + CK_ULONG ulPartLen) +{ + (void)hSession; + (void)pPart; + (void)ulPartLen; + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_DigestKey(CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE hKey) +{ + (void)hSession; + (void)hKey; + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_DigestFinal(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pDigest, + CK_ULONG_PTR pulDigestLen) +{ + (void)hSession; + (void)pDigest; + (void)pulDigestLen; + return CKR_FUNCTION_NOT_SUPPORTED; +} + +/* Signing and MACing functions */ + +CK_RV C_SignInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechanism, + CK_OBJECT_HANDLE hKey) +{ + (void)hSession; + (void)pMechanism; + (void)hKey; + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_Sign(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pData, CK_ULONG ulDataLen, + CK_BYTE_PTR pSignature, CK_ULONG_PTR pulSignatureLen) +{ + (void)hSession; + (void)pData; + (void)ulDataLen; + (void)pSignature; + (void)pulSignatureLen; + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_SignUpdate(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pPart, + CK_ULONG ulPartLen) +{ + (void)hSession; + (void)pPart; + (void)ulPartLen; + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_SignFinal(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pSignature, + CK_ULONG_PTR pulSignatureLen) +{ + (void)hSession; + (void)pSignature; + (void)pulSignatureLen; + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_SignRecoverInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechanism, + CK_OBJECT_HANDLE hKey) +{ + (void)hSession; + (void)pMechanism; + (void)hKey; + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_SignRecover(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pData, + CK_ULONG ulDataLen, CK_BYTE_PTR pSignature, + CK_ULONG_PTR pulSignatureLen) +{ + (void)hSession; + (void)pData; + (void)ulDataLen; + (void)pSignature; + (void)pulSignatureLen; + return CKR_FUNCTION_NOT_SUPPORTED; +} + +/* Verifying signatures and MACs functions */ + +CK_RV C_VerifyInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechanism, + CK_OBJECT_HANDLE hKey) +{ + (void)hSession; + (void)pMechanism; + (void)hKey; + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_Verify(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pData, + CK_ULONG ulDataLen, CK_BYTE_PTR pSignature, + CK_ULONG ulSignatureLen) +{ + (void)hSession; + (void)pData; + (void)ulDataLen; + (void)pSignature; + (void)ulSignatureLen; + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_VerifyUpdate(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pPart, + CK_ULONG ulPartLen) +{ + (void)hSession; + (void)pPart; + (void)ulPartLen; + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_VerifyFinal(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pSignature, + CK_ULONG ulSignatureLen) +{ + (void)hSession; + (void)pSignature; + (void)ulSignatureLen; + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_VerifyRecoverInit(CK_SESSION_HANDLE hSession, + CK_MECHANISM_PTR pMechanism, + CK_OBJECT_HANDLE hKey) +{ + (void)hSession; + (void)pMechanism; + (void)hKey; + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_VerifyRecover(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pSignature, + CK_ULONG ulSignatureLen, CK_BYTE_PTR pData, + CK_ULONG_PTR pulDataLen) +{ + (void)hSession; + (void)pSignature; + (void)ulSignatureLen; + (void)pData; + (void)pulDataLen; + return CKR_FUNCTION_NOT_SUPPORTED; +} + +/* Dual-function cryptographic functions */ + +CK_RV C_DigestEncryptUpdate(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pPart, + CK_ULONG ulPartLen, CK_BYTE_PTR pEncryptedPart, + CK_ULONG_PTR pulEncryptedPartLen) +{ + (void)hSession; + (void)pPart; + (void)ulPartLen; + (void)pEncryptedPart; + (void)pulEncryptedPartLen; + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_DecryptDigestUpdate(CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pEncryptedPart, + CK_ULONG ulEncryptedPartLen, CK_BYTE_PTR pPart, + CK_ULONG_PTR pulPartLen) +{ + (void)hSession; + (void)pEncryptedPart; + (void)ulEncryptedPartLen; + (void)pPart; + (void)pulPartLen; + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_SignEncryptUpdate(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pPart, + CK_ULONG ulPartLen, CK_BYTE_PTR pEncryptedPart, + CK_ULONG_PTR pulEncryptedPartLen) +{ + (void)hSession; + (void)pPart; + (void)ulPartLen; + (void)pEncryptedPart; + (void)pulEncryptedPartLen; + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_DecryptVerifyUpdate(CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pEncryptedPart, + CK_ULONG ulEncryptedPartLen, CK_BYTE_PTR pPart, + CK_ULONG_PTR pulPartLen) +{ + (void)hSession; + (void)pEncryptedPart; + (void)ulEncryptedPartLen; + (void)pPart; + (void)pulPartLen; + return CKR_FUNCTION_NOT_SUPPORTED; +} + +/* Key management functions */ + +CK_RV C_GenerateKey(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechanism, + CK_ATTRIBUTE_PTR pTemplate, CK_ULONG ulCount, + CK_OBJECT_HANDLE_PTR phKey) +{ + (void)hSession; + (void)pMechanism; + (void)pTemplate; + (void)ulCount; + (void)phKey; + return CKR_FUNCTION_NOT_SUPPORTED; +} + +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) +{ + (void)hSession; + (void)pMechanism; + (void)pPublicKeyTemplate; + (void)ulPublicKeyAttributeCount; + (void)pPrivateKeyTemplate; + (void)ulPrivateKeyAttributeCount; + (void)phPublicKey; + (void)phPrivateKey; + return CKR_FUNCTION_NOT_SUPPORTED; +} + +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) +{ + (void)hSession; + (void)pMechanism; + (void)hWrappingKey; + (void)hKey; + (void)pWrappedKey; + (void)pulWrappedKeyLen; + return CKR_FUNCTION_NOT_SUPPORTED; +} + +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 ulAttributeCount, CK_OBJECT_HANDLE_PTR phKey) +{ + (void)hSession; + (void)pMechanism; + (void)hUnwrappingKey; + (void)pWrappedKey; + (void)ulWrappedKeyLen; + (void)pTemplate; + (void)ulAttributeCount; + (void)phKey; + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_DeriveKey(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechanism, + CK_OBJECT_HANDLE hBaseKey, CK_ATTRIBUTE_PTR pTemplate, + CK_ULONG ulAttributeCount, CK_OBJECT_HANDLE_PTR phKey) +{ + (void)hSession; + (void)pMechanism; + (void)hBaseKey; + (void)pTemplate; + (void)ulAttributeCount; + (void)phKey; + return CKR_FUNCTION_NOT_SUPPORTED; +} + +/* Random number generation functions */ + +CK_RV C_SeedRandom(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pSeed, + CK_ULONG ulSeedLen) +{ + (void)hSession; + (void)pSeed; + (void)ulSeedLen; + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_GenerateRandom(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pRandomData, + CK_ULONG ulRandomLen) +{ + (void)hSession; + (void)pRandomData; + (void)ulRandomLen; + return CKR_FUNCTION_NOT_SUPPORTED; +} + +/* Parallel function management functions */ + +CK_RV C_GetFunctionStatus(CK_SESSION_HANDLE hSession) +{ + (void)hSession; + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_CancelFunction(CK_SESSION_HANDLE hSession) +{ + (void)hSession; + return CKR_FUNCTION_NOT_SUPPORTED; +} + +/* Message-based encryption and decryption functions (v3.0) */ + +CK_RV C_MessageEncryptInit(CK_SESSION_HANDLE hSession, + CK_MECHANISM_PTR pMechanism, + CK_OBJECT_HANDLE hKey) +{ + (void)hSession; + (void)pMechanism; + (void)hKey; + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_EncryptMessage(CK_SESSION_HANDLE hSession, CK_VOID_PTR pParameter, + CK_ULONG ulParameterLen, CK_BYTE_PTR pAssociatedData, + CK_ULONG ulAssociatedDataLen, CK_BYTE_PTR pPlaintext, + CK_ULONG ulPlaintextLen, CK_BYTE_PTR pCiphertext, + CK_ULONG_PTR pulCiphertextLen) +{ + (void)hSession; + (void)pParameter; + (void)ulParameterLen; + (void)pAssociatedData; + (void)ulAssociatedDataLen; + (void)pPlaintext; + (void)ulPlaintextLen; + (void)pCiphertext; + (void)pulCiphertextLen; + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_EncryptMessageBegin(CK_SESSION_HANDLE hSession, CK_VOID_PTR pParameter, + CK_ULONG ulParameterLen, CK_BYTE_PTR pAssociatedData, + CK_ULONG ulAssociatedDataLen) +{ + (void)hSession; + (void)pParameter; + (void)ulParameterLen; + (void)pAssociatedData; + (void)ulAssociatedDataLen; + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_EncryptMessageNext(CK_SESSION_HANDLE hSession, CK_VOID_PTR pParameter, + CK_ULONG ulParameterLen, CK_BYTE_PTR pPlaintextPart, + CK_ULONG ulPlaintextPartLen, + CK_BYTE_PTR pCiphertextPart, + CK_ULONG_PTR pulCiphertextPartLen, CK_FLAGS flags) +{ + (void)hSession; + (void)pParameter; + (void)ulParameterLen; + (void)pPlaintextPart; + (void)ulPlaintextPartLen; + (void)pCiphertextPart; + (void)pulCiphertextPartLen; + (void)flags; + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_MessageEncryptFinal(CK_SESSION_HANDLE hSession) +{ + (void)hSession; + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_MessageDecryptInit(CK_SESSION_HANDLE hSession, + CK_MECHANISM_PTR pMechanism, + CK_OBJECT_HANDLE hKey) +{ + (void)hSession; + (void)pMechanism; + (void)hKey; + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_DecryptMessage(CK_SESSION_HANDLE hSession, CK_VOID_PTR pParameter, + CK_ULONG ulParameterLen, CK_BYTE_PTR pAssociatedData, + CK_ULONG ulAssociatedDataLen, CK_BYTE_PTR pCiphertext, + CK_ULONG ulCiphertextLen, CK_BYTE_PTR pPlaintext, + CK_ULONG_PTR pulPlaintextLen) +{ + (void)hSession; + (void)pParameter; + (void)ulParameterLen; + (void)pAssociatedData; + (void)ulAssociatedDataLen; + (void)pCiphertext; + (void)ulCiphertextLen; + (void)pPlaintext; + (void)pulPlaintextLen; + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_DecryptMessageBegin(CK_SESSION_HANDLE hSession, CK_VOID_PTR pParameter, + CK_ULONG ulParameterLen, + CK_BYTE_PTR pAssociatedData, + CK_ULONG ulAssociatedDataLen) +{ + (void)hSession; + (void)pParameter; + (void)ulParameterLen; + (void)pAssociatedData; + (void)ulAssociatedDataLen; + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_DecryptMessageNext(CK_SESSION_HANDLE hSession, CK_VOID_PTR pParameter, + CK_ULONG ulParameterLen, CK_BYTE_PTR pCiphertextPart, + CK_ULONG ulCiphertextPartLen, + CK_BYTE_PTR pPlaintextPart, + CK_ULONG_PTR pulPlaintextPartLen, CK_FLAGS flags) +{ + (void)hSession; + (void)pParameter; + (void)ulParameterLen; + (void)pCiphertextPart; + (void)ulCiphertextPartLen; + (void)pPlaintextPart; + (void)pulPlaintextPartLen; + (void)flags; + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_MessageDecryptFinal(CK_SESSION_HANDLE hSession) +{ + (void)hSession; + return CKR_FUNCTION_NOT_SUPPORTED; +} + +/* Message-based signing and verification functions (v3.0) */ + +CK_RV C_MessageSignInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechanism, + CK_OBJECT_HANDLE hKey) +{ + (void)hSession; + (void)pMechanism; + (void)hKey; + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_SignMessage(CK_SESSION_HANDLE hSession, CK_VOID_PTR pParameter, + CK_ULONG ulParameterLen, CK_BYTE_PTR pData, + CK_ULONG ulDataLen, + CK_BYTE_PTR pSignature, CK_ULONG_PTR pulSignatureLen) +{ + (void)hSession; + (void)pParameter; + (void)ulParameterLen; + (void)pData; + (void)ulDataLen; + (void)pSignature; + (void)pulSignatureLen; + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_SignMessageBegin(CK_SESSION_HANDLE hSession, CK_VOID_PTR pParameter, + CK_ULONG ulParameterLen) +{ + (void)hSession; + (void)pParameter; + (void)ulParameterLen; + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_SignMessageNext(CK_SESSION_HANDLE hSession, CK_VOID_PTR pParameter, + CK_ULONG ulParameterLen, CK_BYTE_PTR pData, + CK_ULONG ulDataLen, CK_BYTE_PTR pSignature, + CK_ULONG_PTR pulSignatureLen) +{ + (void)hSession; + (void)pParameter; + (void)ulParameterLen; + (void)pData; + (void)ulDataLen; + (void)pSignature; + (void)pulSignatureLen; + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_MessageSignFinal(CK_SESSION_HANDLE hSession) +{ + (void)hSession; + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_MessageVerifyInit(CK_SESSION_HANDLE hSession, + CK_MECHANISM_PTR pMechanism, + CK_OBJECT_HANDLE hKey) +{ + (void)hSession; + (void)pMechanism; + (void)hKey; + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_VerifyMessage(CK_SESSION_HANDLE hSession, CK_VOID_PTR pParameter, + CK_ULONG ulParameterLen, CK_BYTE_PTR pData, + CK_ULONG ulDataLen, + CK_BYTE_PTR pSignature, CK_ULONG ulSignatureLen) +{ + (void)hSession; + (void)pParameter; + (void)ulParameterLen; + (void)pData; + (void)ulDataLen; + (void)pSignature; + (void)ulSignatureLen; + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_VerifyMessageBegin(CK_SESSION_HANDLE hSession, CK_VOID_PTR pParameter, + CK_ULONG ulParameterLen) +{ + (void)hSession; + (void)pParameter; + (void)ulParameterLen; + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_VerifyMessageNext(CK_SESSION_HANDLE hSession, CK_VOID_PTR pParameter, + CK_ULONG ulParameterLen, CK_BYTE_PTR pData, + CK_ULONG ulDataLen, CK_BYTE_PTR pSignature, + CK_ULONG ulSignatureLen) +{ + (void)hSession; + (void)pParameter; + (void)ulParameterLen; + (void)pData; + (void)ulDataLen; + (void)pSignature; + (void)ulSignatureLen; + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_MessageVerifyFinal(CK_SESSION_HANDLE hSession) +{ + (void)hSession; + return CKR_FUNCTION_NOT_SUPPORTED; +} + +/* PKCS #11 v3.2 functions */ + +CK_RV C_LoginUser(CK_SESSION_HANDLE hSession, CK_USER_TYPE userType, + CK_UTF8CHAR_PTR pPin, CK_ULONG ulPinLen, + CK_UTF8CHAR_PTR pUsername, CK_ULONG ulUsernameLen) +{ + (void)hSession; + (void)userType; + (void)pPin; + (void)ulPinLen; + (void)pUsername; + (void)ulUsernameLen; + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_EncapsulateKey(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechanism, + CK_OBJECT_HANDLE hPublicKey, CK_ATTRIBUTE_PTR pTemplate, + CK_ULONG ulAttributeCount, CK_BYTE_PTR pCiphertext, + CK_ULONG_PTR pulCiphertextLen, + CK_OBJECT_HANDLE_PTR phKey) +{ + (void)hSession; + (void)pMechanism; + (void)hPublicKey; + (void)pTemplate; + (void)ulAttributeCount; + (void)pCiphertext; + (void)pulCiphertextLen; + (void)phKey; + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_DecapsulateKey(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechanism, + CK_OBJECT_HANDLE hPrivateKey, CK_ATTRIBUTE_PTR pTemplate, + CK_ULONG ulAttributeCount, CK_BYTE_PTR pCiphertext, + CK_ULONG ulCiphertextLen, CK_OBJECT_HANDLE_PTR phKey) +{ + (void)hSession; + (void)pMechanism; + (void)hPrivateKey; + (void)pTemplate; + (void)ulAttributeCount; + (void)pCiphertext; + (void)ulCiphertextLen; + (void)phKey; + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_VerifySignatureInit(CK_SESSION_HANDLE hSession, + CK_MECHANISM_PTR pMechanism, + CK_OBJECT_HANDLE hKey, + CK_BYTE_PTR pSignature, + CK_ULONG ulSignatureLen) +{ + (void)hSession; + (void)pMechanism; + (void)hKey; + (void)pSignature; + (void)ulSignatureLen; + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_VerifySignature(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pData, + CK_ULONG ulDataLen) +{ + (void)hSession; + (void)pData; + (void)ulDataLen; + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_VerifySignatureUpdate(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pPart, + CK_ULONG ulPartLen) +{ + (void)hSession; + (void)pPart; + (void)ulPartLen; + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_VerifySignatureFinal(CK_SESSION_HANDLE hSession) +{ + (void)hSession; + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_GetSessionValidationFlags(CK_SESSION_HANDLE hSession, + CK_SESSION_VALIDATION_FLAGS_TYPE type, + CK_FLAGS_PTR pFlags) +{ + (void)hSession; + (void)type; + (void)pFlags; + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_AsyncComplete(CK_SESSION_HANDLE hSession, CK_UTF8CHAR_PTR pFunctionName, + CK_ASYNC_DATA_PTR pResult) +{ + (void)hSession; + (void)pFunctionName; + (void)pResult; + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_AsyncGetID(CK_SESSION_HANDLE hSession, CK_UTF8CHAR_PTR pFunctionName, + CK_ULONG_PTR pulID) +{ + (void)hSession; + (void)pFunctionName; + (void)pulID; + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_AsyncJoin(CK_SESSION_HANDLE hSession, CK_UTF8CHAR_PTR pFunctionName, + CK_ULONG ulID, CK_BYTE_PTR pData, CK_ULONG ulData) +{ + (void)hSession; + (void)pFunctionName; + (void)ulID; + (void)pData; + (void)ulData; + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_WrapKeyAuthenticated(CK_SESSION_HANDLE hSession, + CK_MECHANISM_PTR pMechanism, + CK_OBJECT_HANDLE hWrappingKey, + CK_OBJECT_HANDLE hKey, + CK_BYTE_PTR pAssociatedData, + CK_ULONG ulAssociatedDataLen, + CK_BYTE_PTR pWrappedKey, + CK_ULONG_PTR pulWrappedKeyLen) +{ + (void)(hSession); + (void)(pMechanism); + (void)(hWrappingKey); + (void)(hKey); + (void)(pAssociatedData); + (void)(ulAssociatedDataLen); + (void)(pWrappedKey); + (void)(pulWrappedKeyLen); + return CKR_FUNCTION_NOT_SUPPORTED; +} + +CK_RV C_UnwrapKeyAuthenticated(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 ulAttributeCount, + CK_BYTE_PTR pAssociatedData, + CK_ULONG ulAssociatedDataLen, + CK_OBJECT_HANDLE_PTR phKey) +{ + (void)(hSession); + (void)(pMechanism); + (void)(hUnwrappingKey); + (void)(pWrappedKey); + (void)ulWrappedKeyLen; + (void)(pTemplate); + (void)(ulAttributeCount); + (void)(pAssociatedData); + (void)(ulAssociatedDataLen); + (void)phKey; + return CKR_FUNCTION_NOT_SUPPORTED; +} + +/* Interface lists and related functions */ + +CK_RV C_GetFunctionList(CK_FUNCTION_LIST_PTR_PTR ppFunctionList); +CK_RV C_GetInterfaceList(CK_INTERFACE_PTR pInterfacesList, + CK_ULONG_PTR pulCount); +CK_RV C_GetInterface(CK_UTF8CHAR_PTR pInterfaceName, CK_VERSION_PTR pVersion, + CK_INTERFACE_PTR_PTR ppInterface, CK_FLAGS flags); + +static CK_FUNCTION_LIST func_list_pkcs11_2_40 = { + {2, 40}, + 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 +}; + +static CK_FUNCTION_LIST_3_0 func_list_pkcs11_3_0 = { + {3, 0}, + 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, + C_GetInterfaceList, + C_GetInterface, + C_LoginUser, + C_SessionCancel, + C_MessageEncryptInit, + C_EncryptMessage, + C_EncryptMessageBegin, + C_EncryptMessageNext, + C_MessageEncryptFinal, + C_MessageDecryptInit, + C_DecryptMessage, + C_DecryptMessageBegin, + C_DecryptMessageNext, + C_MessageDecryptFinal, + C_MessageSignInit, + C_SignMessage, + C_SignMessageBegin, + C_SignMessageNext, + C_MessageSignFinal, + C_MessageVerifyInit, + C_VerifyMessage, + C_VerifyMessageBegin, + C_VerifyMessageNext, + C_MessageVerifyFinal +}; + +static CK_FUNCTION_LIST_3_2 func_list_pkcs11_3_2 = { + {3, 2}, + 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, + C_GetInterfaceList, + C_GetInterface, + C_LoginUser, + C_SessionCancel, + C_MessageEncryptInit, + C_EncryptMessage, + C_EncryptMessageBegin, + C_EncryptMessageNext, + C_MessageEncryptFinal, + C_MessageDecryptInit, + C_DecryptMessage, + C_DecryptMessageBegin, + C_DecryptMessageNext, + C_MessageDecryptFinal, + C_MessageSignInit, + C_SignMessage, + C_SignMessageBegin, + C_SignMessageNext, + C_MessageSignFinal, + C_MessageVerifyInit, + C_VerifyMessage, + C_VerifyMessageBegin, + C_VerifyMessageNext, + C_MessageVerifyFinal, + C_EncapsulateKey, + C_DecapsulateKey, + C_VerifySignatureInit, + C_VerifySignature, + C_VerifySignatureUpdate, + C_VerifySignatureFinal, + C_GetSessionValidationFlags, + C_AsyncComplete, + C_AsyncGetID, + C_AsyncJoin, + C_WrapKeyAuthenticated, + C_UnwrapKeyAuthenticated +}; + +static CK_INTERFACE interfaces[] = { + { + (CK_UTF8CHAR *)"PKCS 11", + &func_list_pkcs11_3_2, + CKF_INTERFACE_FORK_SAFE + }, + { + (CK_UTF8CHAR *)"PKCS 11", + &func_list_pkcs11_3_0, + CKF_INTERFACE_FORK_SAFE + }, + { + (CK_UTF8CHAR *)"PKCS 11", + &func_list_pkcs11_2_40, + CKF_INTERFACE_FORK_SAFE + }, +}; + +CK_RV C_GetFunctionList(CK_FUNCTION_LIST_PTR_PTR ppFunctionList) +{ + if (ppFunctionList == NULL_PTR) + return CKR_ARGUMENTS_BAD; + + *ppFunctionList = &func_list_pkcs11_2_40; + return CKR_OK; +} + +CK_RV C_GetInterfaceList(CK_INTERFACE_PTR pInterfacesList, + CK_ULONG_PTR pulCount) +{ + if (pulCount == NULL_PTR) + return CKR_ARGUMENTS_BAD; + + if (pInterfacesList == NULL_PTR) { + *pulCount = sizeof(interfaces) / sizeof(interfaces[0]); + return CKR_OK; + } + + if (*pulCount < sizeof(interfaces) / sizeof(interfaces[0])) { + *pulCount = sizeof(interfaces) / sizeof(interfaces[0]); + return CKR_BUFFER_TOO_SMALL; + } + + *pulCount = sizeof(interfaces) / sizeof(interfaces[0]); + for (CK_ULONG i = 0; i < *pulCount; i++) + pInterfacesList[i] = interfaces[i]; + + return CKR_OK; +} + +CK_RV C_GetInterface(CK_UTF8CHAR_PTR pInterfaceName, CK_VERSION_PTR pVersion, + CK_INTERFACE_PTR_PTR ppInterface, CK_FLAGS flags) +{ + CK_INTERFACE *interf; + size_t i; + + if (ppInterface == NULL_PTR) + return CKR_ARGUMENTS_BAD; + + *ppInterface = NULL; + for (i = 0; i < sizeof(interfaces) / sizeof(interfaces[0]); i++) { + interf = &interfaces[i]; + + if ((pInterfaceName == NULL || + (pInterfaceName != NULL && + strcmp((char *)pInterfaceName, + (char *)interf->pInterfaceName) == 0)) && + (pVersion == NULL || + (pVersion->major == + ((CK_VERSION *)interf->pFunctionList)->major && + pVersion->minor == + ((CK_VERSION *)interf->pFunctionList)->minor)) && + (flags == (interf->flags & flags))) { + *ppInterface = interf; + break; + } + } + + if (*ppInterface == NULL) + return CKR_FUNCTION_FAILED; + + return CKR_OK; +} diff --git a/src/pkcs11/pkcs11.h b/src/pkcs11/pkcs11.h new file mode 100644 index 00000000..e002a443 --- /dev/null +++ b/src/pkcs11/pkcs11.h @@ -0,0 +1,1233 @@ +// SPDX-License-Identifier: MIT +// Copyright contributors to the libzpc project +#ifndef PKCS11_H +#define PKCS11_H + +#ifdef __cplusplus +extern "C" { +#endif + +#define CK_TRUE 1 +#define CK_FALSE 0 + +#define CK_PTR * + +#define CK_CALLBACK_FUNCTION(returnType, name) returnType (* name) + +#ifndef NULL_PTR +#define NULL_PTR NULL +#endif + +typedef unsigned char CK_BYTE; +typedef CK_BYTE CK_CHAR; +typedef CK_BYTE CK_UTF8CHAR; +typedef CK_BYTE CK_BBOOL; +typedef unsigned long int CK_ULONG; +typedef long int CK_LONG; +typedef CK_ULONG CK_FLAGS; + +#define CK_UNAVAILABLE_INFORMATION (~0UL) +#define CK_EFFECTIVELY_INFINITE 0 + +typedef CK_BYTE CK_PTR CK_BYTE_PTR; +typedef CK_CHAR CK_PTR CK_CHAR_PTR; +typedef CK_UTF8CHAR CK_PTR CK_UTF8CHAR_PTR; +typedef CK_ULONG CK_PTR CK_ULONG_PTR; +typedef void CK_PTR CK_VOID_PTR; +typedef CK_ULONG CK_PTR CK_FLAGS_PTR; +typedef CK_VOID_PTR CK_PTR CK_VOID_PTR_PTR; + +#define CK_INVALID_HANDLE 0 + +typedef struct CK_VERSION { + CK_BYTE major; + CK_BYTE minor; +} CK_VERSION; + +typedef CK_VERSION CK_PTR CK_VERSION_PTR; + +typedef struct CK_INFO { + CK_VERSION cryptokiVersion; + CK_CHAR manufacturerID[32]; + CK_FLAGS flags; + CK_CHAR libraryDescription[32]; + CK_VERSION libraryVersion; +} CK_INFO; + +typedef CK_INFO CK_PTR CK_INFO_PTR; + +typedef CK_ULONG CK_NOTIFICATION; +#define CKN_SURRENDER 0 + +typedef CK_ULONG CK_SLOT_ID; +typedef CK_SLOT_ID CK_PTR CK_SLOT_ID_PTR; + +typedef struct CK_SLOT_INFO { + CK_CHAR slotDescription[64]; + CK_CHAR manufacturerID[32]; + CK_FLAGS flags; + CK_VERSION hardwareVersion; + CK_VERSION firmwareVersion; +} CK_SLOT_INFO; + +#define CKF_TOKEN_PRESENT 0x00000001 +#define CKF_REMOVABLE_DEVICE 0x00000002 +#define CKF_HW_SLOT 0x00000004 + +typedef CK_SLOT_INFO CK_PTR CK_SLOT_INFO_PTR; + +typedef struct CK_TOKEN_INFO { + CK_CHAR label[32]; + CK_CHAR manufacturerID[32]; + CK_CHAR model[16]; + CK_CHAR serialNumber[16]; + CK_FLAGS flags; + CK_ULONG ulMaxSessionCount; + CK_ULONG ulSessionCount; + CK_ULONG ulMaxRwSessionCount; + CK_ULONG ulRwSessionCount; + CK_ULONG ulMaxPinLen; + CK_ULONG ulMinPinLen; + CK_ULONG ulTotalPublicMemory; + CK_ULONG ulFreePublicMemory; + CK_ULONG ulTotalPrivateMemory; + CK_ULONG ulFreePrivateMemory; + CK_VERSION hardwareVersion; + CK_VERSION firmwareVersion; + CK_CHAR utcTime[16]; +} CK_TOKEN_INFO; + +#define CKF_RNG 0x00000001 +#define CKF_WRITE_PROTECTED 0x00000002 +#define CKF_LOGIN_REQUIRED 0x00000004 +#define CKF_USER_PIN_INITIALIZED 0x00000008 +#define CKF_RESTORE_KEY_NOT_NEEDED 0x00000020 +#define CKF_CLOCK_ON_TOKEN 0x00000040 +#define CKF_PROTECTED_AUTHENTICATION_PATH 0x00000100 +#define CKF_DUAL_CRYPTO_OPERATIONS 0x00000200 +#define CKF_TOKEN_INITIALIZED 0x00000400 +#define CKF_SECONDARY_AUTHENTICATION 0x00000800 +#define CKF_USER_PIN_COUNT_LOW 0x00010000 +#define CKF_USER_PIN_FINAL_TRY 0x00020000 +#define CKF_USER_PIN_LOCKED 0x00040000 +#define CKF_USER_PIN_TO_BE_CHANGED 0x00080000 +#define CKF_SO_PIN_COUNT_LOW 0x00100000 +#define CKF_SO_PIN_FINAL_TRY 0x00200000 +#define CKF_SO_PIN_LOCKED 0x00400000 +#define CKF_SO_PIN_TO_BE_CHANGED 0x00800000 +#define CKF_ERROR_STATE 0x01000000 +#define CKF_SEED_RANDOM_REQUIRED 0x02000000 +#define CKF_ASYNC_SESSION_SUPPORTED 0x04000000 + +typedef CK_TOKEN_INFO CK_PTR CK_TOKEN_INFO_PTR; +typedef CK_ULONG CK_SESSION_HANDLE; +typedef CK_SESSION_HANDLE CK_PTR CK_SESSION_HANDLE_PTR; + +typedef CK_ULONG CK_USER_TYPE; +#define CKU_SO 0 +#define CKU_USER 1 +#define CKU_CONTEXT_SPECIFIC 2 + +typedef CK_ULONG CK_STATE; +#define CKS_RO_PUBLIC_SESSION 0 +#define CKS_RO_USER_FUNCTIONS 1 +#define CKS_RW_PUBLIC_SESSION 2 +#define CKS_RW_USER_FUNCTIONS 3 +#define CKS_RW_SO_FUNCTIONS 4 + +typedef struct CK_SESSION_INFO { + CK_SLOT_ID slotID; + CK_STATE state; + CK_FLAGS flags; + CK_ULONG ulDeviceError; +} CK_SESSION_INFO; + +#define CKF_RW_SESSION 0x00000002 +#define CKF_SERIAL_SESSION 0x00000004 +#define CKF_ASYNC_SESSION 0x00000008 + +typedef CK_SESSION_INFO CK_PTR CK_SESSION_INFO_PTR; + +typedef CK_ULONG CK_OBJECT_HANDLE; +typedef CK_OBJECT_HANDLE CK_PTR CK_OBJECT_HANDLE_PTR; + +typedef CK_ULONG CK_OBJECT_CLASS; +typedef CK_OBJECT_CLASS CK_PTR CK_OBJECT_CLASS_PTR; + +#define CKO_DATA 0x00000000 +#define CKO_CERTIFICATE 0x00000001 +#define CKO_PUBLIC_KEY 0x00000002 +#define CKO_PRIVATE_KEY 0x00000003 +#define CKO_SECRET_KEY 0x00000004 +#define CKO_HW_FEATURE 0x00000005 +#define CKO_DOMAIN_PARAMETERS 0x00000006 +#define CKO_PROFILE 0x00000009 +#define CKO_VALIDATION 0x0000000A +#define CKO_TRUST 0x0000000B +#define CKO_VENDOR_DEFINED 0x80000000 + +typedef CK_ULONG CK_KEY_TYPE; + +#define CKK_RSA 0x00000000 +#define CKK_DSA 0x00000001 +#define CKK_DH 0x00000002 +#define CKK_EC 0x00000003 +#define CKK_GENERIC_SECRET 0x00000010 +#define CKK_AES 0x0000001F +#define CKK_AES_XTS 0x00000035 +#define CKK_EC_EDWARDS 0x00000040 +#define CKK_EC_MONTGOMERY 0x00000041 + +typedef CK_ULONG CK_ATTRIBUTE_TYPE; + +#define CKF_ARRAY_ATTRIBUTE 0x40000000 + +#define CKA_CLASS 0x00000000 +#define CKA_TOKEN 0x00000001 +#define CKA_PRIVATE 0x00000002 +#define CKA_LABEL 0x00000003 +#define CKA_UNIQUE_ID 0x00000004 +#define CKA_APPLICATION 0x00000010 +#define CKA_VALUE 0x00000011 +#define CKA_OBJECT_ID 0x00000012 +#define CKA_CERTIFICATE_TYP 0x00000080 +#define CKA_ISSUER 0x00000081 +#define CKA_SERIAL_NUMBER 0x00000082 +#define CKA_AC_ISSUER 0x00000083 +#define CKA_OWNER 0x00000084 +#define CKA_ATTR_TYPES 0x00000085 +#define CKA_TRUSTED 0x00000086 +#define CKA_KEY_TYPE 0x00000100 +#define CKA_SUBJECT 0x00000101 +#define CKA_ID 0x00000102 +#define CKA_SENSITIVE 0x00000103 +#define CKA_ENCRYPT 0x00000104 +#define CKA_DECRYPT 0x00000105 +#define CKA_WRAP 0x00000106 +#define CKA_UNWRAP 0x00000107 +#define CKA_SIGN 0x00000108 +#define CKA_SIGN_RECOVER 0x00000109 +#define CKA_VERIFY 0x0000010A +#define CKA_VERIFY_RECOVER 0x0000010B +#define CKA_DERIVE 0x0000010C +#define CKA_START_DATE 0x00000110 +#define CKA_END_DATE 0x00000111 +#define CKA_PUBLIC_KEY_INFO 0x00000129 +#define CKA_VALUE_BITS 0x00000160 +#define CKA_VALUE_LEN 0x00000161 +#define CKA_EXTRACTABLE 0x00000162 +#define CKA_LOCAL 0x00000163 +#define CKA_NEVER_EXTRACTABLE 0x00000164 +#define CKA_ALWAYS_SENSITIVE 0x00000165 +#define CKA_MODIFIABLE 0x00000170 +#define CKA_COPYABLE 0x00000171 +#define CKA_DESTROYABLE 0x00000172 +#define CKA_EC_PARAMS 0x00000180 +#define CKA_EC_POINT 0x00000181 +#define CKA_ALWAYS_AUTHENTICATE 0x00000202 +#define CKA_WRAP_WITH_TRUSTED 0x00000210 +#define CKA_ENCAPSULATE 0x00000633 +#define CKA_DECAPSULATE 0x00000634 + +#define CKA_WRAP_TEMPLATE (CKF_ARRAY_ATTRIBUTE | 0x00000211) +#define CKA_UNWRAP_TEMPLATE (CKF_ARRAY_ATTRIBUTE | 0x00000212) +#define CKA_DERIVE_TEMPLATE (CKF_ARRAY_ATTRIBUTE | 0x00000213) + +typedef struct CK_ATTRIBUTE { + CK_ATTRIBUTE_TYPE type; + CK_VOID_PTR pValue; + CK_ULONG ulValueLen; +} CK_ATTRIBUTE; + +typedef CK_ATTRIBUTE CK_PTR CK_ATTRIBUTE_PTR; + +typedef struct CK_DATE { + CK_CHAR year[4]; + CK_CHAR month[2]; + CK_CHAR day[2]; +} CK_DATE; + +typedef CK_ULONG CK_MECHANISM_TYPE; + +#define CKM_ECDSA 0x00001041 +#define CKM_ECDSA_SHA1 0x00001042 +#define CKM_ECDSA_SHA224 0x00001043 +#define CKM_ECDSA_SHA256 0x00001044 +#define CKM_ECDSA_SHA384 0x00001045 +#define CKM_ECDSA_SHA512 0x00001046 +#define CKM_ECDSA_SHA3_224 0x00001047 +#define CKM_ECDSA_SHA3_256 0x00001048 +#define CKM_ECDSA_SHA3_384 0x00001049 +#define CKM_ECDSA_SHA3_512 0x0000104A +#define CKM_AES_XTS 0x00001071 +#define CKM_AES_ECB 0x00001081 +#define CKM_AES_CBC 0x00001082 +#define CKM_AES_CTR 0x00001086 +#define CKM_AES_GCM 0x00001087 +#define CKM_EDDSA 0x00001057 + +typedef CK_MECHANISM_TYPE CK_PTR CK_MECHANISM_TYPE_PTR; + +typedef struct CK_MECHANISM { + CK_MECHANISM_TYPE mechanism; + CK_VOID_PTR pParameter; + CK_ULONG ulParameterLen; +} CK_MECHANISM; + +typedef CK_MECHANISM CK_PTR CK_MECHANISM_PTR; + +typedef struct CK_MECHANISM_INFO { + CK_ULONG ulMinKeySize; + CK_ULONG ulMaxKeySize; + CK_FLAGS flags; +} CK_MECHANISM_INFO; + +typedef CK_MECHANISM_INFO CK_PTR CK_MECHANISM_INFO_PTR; + +#define CKF_HW 0x00000001 +#define CKF_MESSAGE_ENCRYPT 0x00000002 +#define CKF_MESSAGE_DECRYPT 0x00000004 +#define CKF_MESSAGE_SIGN 0x00000008 +#define CKF_MESSAGE_VERIFY 0x00000010 +#define CKF_MULTI_MESSAGE 0x00000020 +#define CKF_FIND_OBJECTS 0x00000040 +#define CKF_ENCRYPT 0x00000100 +#define CKF_DECRYPT 0x00000200 +#define CKF_DIGEST 0x00000400 +#define CKF_SIGN 0x00000800 +#define CKF_SIGN_RECOVER 0x00001000 +#define CKF_VERIFY 0x00002000 +#define CKF_VERIFY_RECOVER 0x00004000 +#define CKF_GENERATE 0x00008000 +#define CKF_GENERATE_KEY_PAIR 0x00010000 +#define CKF_WRAP 0x00020000 +#define CKF_UNWRAP 0x00040000 +#define CKF_DERIVE 0x00080000 +#define CKF_EC_F_P 0x00100000 +#define CKF_EC_F_2M 0x00200000 +#define CKF_EC_ECPARAMETERS 0x00400000 +#define CKF_EC_OID 0x00800000 +#define CKF_EC_UNCOMPRESS 0x01000000 +#define CKF_EC_COMPRESS 0x02000000 +#define CKF_EC_CURVENAME 0x04000000 +#define CKF_ENCAPSULATE 0x10000000 +#define CKF_DECAPSULATE 0x20000000 + +typedef CK_ULONG CK_RV; + +#define CKR_OK 0x00000000 +#define CKR_CANCEL 0x00000001 +#define CKR_HOST_MEMORY 0x00000002 +#define CKR_SLOT_ID_INVALID 0x00000003 +#define CKR_GENERAL_ERROR 0x00000005 +#define CKR_FUNCTION_FAILED 0x00000006 +#define CKR_ARGUMENTS_BAD 0x00000007 +#define CKR_NO_EVENT 0x00000008 +#define CKR_NEED_TO_CREATE_THREADS 0x00000009 +#define CKR_CANT_LOCK 0x0000000A +#define CKR_ATTRIBUTE_READ_ONLY 0x00000010 +#define CKR_ATTRIBUTE_SENSITIVE 0x00000011 +#define CKR_ATTRIBUTE_TYPE_INVALID 0x00000012 +#define CKR_ATTRIBUTE_VALUE_INVALID 0x00000013 +#define CKR_ACTION_PROHIBITED 0x0000001B +#define CKR_DATA_INVALID 0x00000020 +#define CKR_DATA_LEN_RANGE 0x00000021 +#define CKR_DEVICE_ERROR 0x00000030 +#define CKR_DEVICE_MEMORY 0x00000031 +#define CKR_DEVICE_REMOVED 0x00000032 +#define CKR_ENCRYPTED_DATA_INVALID 0x00000040 +#define CKR_ENCRYPTED_DATA_LEN_RANGE 0x00000041 +#define CKR_AEAD_DECRYPT_FAILED 0x00000042 +#define CKR_FUNCTION_CANCELED 0x00000050 +#define CKR_FUNCTION_NOT_PARALLEL 0x00000051 +#define CKR_FUNCTION_NOT_SUPPORTED 0x00000054 +#define CKR_KEY_HANDLE_INVALID 0x00000060 +#define CKR_KEY_SIZE_RANGE 0x00000062 +#define CKR_KEY_TYPE_INCONSISTENT 0x00000063 +#define CKR_KEY_NOT_NEEDED 0x00000064 +#define CKR_KEY_CHANGED 0x00000065 +#define CKR_KEY_NEEDED 0x00000066 +#define CKR_KEY_INDIGESTIBLE 0x00000067 +#define CKR_KEY_FUNCTION_NOT_PERMITTED 0x00000068 +#define CKR_KEY_NOT_WRAPPABLE 0x00000069 +#define CKR_KEY_UNEXTRACTABLE 0x0000006A +#define CKR_MECHANISM_INVALID 0x00000070 +#define CKR_MECHANISM_PARAM_INVALID 0x00000071 +#define CKR_OBJECT_HANDLE_INVALID 0x00000082 +#define CKR_OPERATION_ACTIVE 0x00000090 +#define CKR_OPERATION_NOT_INITIALIZED 0x00000091 +#define CKR_PIN_INCORRECT 0x000000A0 +#define CKR_PIN_INVALID 0x000000A1 +#define CKR_PIN_LEN_RANGE 0x000000A2 +#define CKR_PIN_EXPIRED 0x000000A3 +#define CKR_PIN_LOCKED 0x000000A4 +#define CKR_SESSION_CLOSED 0x000000B0 +#define CKR_SESSION_COUNT 0x000000B1 +#define CKR_SESSION_HANDLE_INVALID 0x000000B3 +#define CKR_SESSION_PARALLEL_NOT_SUPPORTED 0x000000B4 +#define CKR_SESSION_READ_ONLY 0x000000B5 +#define CKR_SESSION_EXISTS 0x000000B6 +#define CKR_SESSION_READ_ONLY_EXISTS 0x000000B7 +#define CKR_SESSION_READ_WRITE_SO_EXISTS 0x000000B8 +#define CKR_SIGNATURE_INVALID 0x000000C0 +#define CKR_SIGNATURE_LEN_RANGE 0x000000C1 +#define CKR_TEMPLATE_INCOMPLETE 0x000000D0 +#define CKR_TEMPLATE_INCONSISTENT 0x000000D1 +#define CKR_TOKEN_NOT_PRESENT 0x000000E0 +#define CKR_TOKEN_NOT_RECOGNIZED 0x000000E1 +#define CKR_TOKEN_WRITE_PROTECTED 0x000000E2 +#define CKR_UNWRAPPING_KEY_HANDLE_INVALID 0x000000F0 +#define CKR_UNWRAPPING_KEY_SIZE_RANGE 0x000000F1 +#define CKR_UNWRAPPING_KEY_TYPE_INCONSISTENT 0x000000F2 +#define CKR_USER_ALREADY_LOGGED_IN 0x00000100 +#define CKR_USER_NOT_LOGGED_IN 0x00000101 +#define CKR_USER_PIN_NOT_INITIALIZED 0x00000102 +#define CKR_USER_TYPE_INVALID 0x00000103 +#define CKR_USER_ANOTHER_ALREADY_LOGGED_IN 0x00000104 +#define CKR_USER_TOO_MANY_TYPES 0x00000105 +#define CKR_WRAPPED_KEY_INVALID 0x00000110 +#define CKR_WRAPPED_KEY_LEN_RANGE 0x00000112 +#define CKR_WRAPPING_KEY_HANDLE_INVALID 0x00000113 +#define CKR_WRAPPING_KEY_SIZE_RANGE 0x00000114 +#define CKR_WRAPPING_KEY_TYPE_INCONSISTENT 0x00000115 +#define CKR_RANDOM_SEED_NOT_SUPPORTED 0x00000120 +#define CKR_RANDOM_NO_RNG 0x00000121 +#define CKR_DOMAIN_PARAMS_INVALID 0x00000130 +#define CKR_CURVE_NOT_SUPPORTED 0x00000140 +#define CKR_BUFFER_TOO_SMALL 0x00000150 +#define CKR_SAVED_STATE_INVALID 0x00000160 +#define CKR_INFORMATION_SENSITIVE 0x00000170 +#define CKR_STATE_UNSAVEABLE 0x00000180 +#define CKR_CRYPTOKI_NOT_INITIALIZED 0x00000190 +#define CKR_CRYPTOKI_ALREADY_INITIALIZED 0x00000191 +#define CKR_MUTEX_BAD 0x000001A0 +#define CKR_MUTEX_NOT_LOCKED 0x000001A1 +#define CKR_NEW_PIN_MODE 0x000001B0 +#define CKR_NEXT_OTP 0x000001B1 +#define CKR_EXCEEDED_MAX_ITERATIONS 0x000001B5 +#define CKR_FIPS_SELF_TEST_FAILED 0x000001B6 +#define CKR_LIBRARY_LOAD_FAILED 0x000001B7 +#define CKR_PIN_TOO_WEAK 0x000001B8 +#define CKR_PUBLIC_KEY_INVALID 0x000001B9 +#define CKR_FUNCTION_REJECTED 0x00000200 +#define CKR_TOKEN_RESOURCE_EXCEEDED 0x00000201 +#define CKR_OPERATION_CANCEL_FAILED 0x00000202 +#define CKR_KEY_EXHAUSTED 0x00000203 +#define CKR_PENDING 0x00000204 +#define CKR_SESSION_ASYNC_NOT_SUPPORTED 0x00000205 +#define CKR_SEED_RANDOM_REQUIRED 0x00000206 +#define CKR_OPERATION_NOT_VALIDATED 0x00000207 +#define CKR_TOKEN_NOT_INITIALIZED 0x00000208 +#define CKR_PARAMETER_SET_NOT_SUPPORTED 0x00000209 + +typedef CK_CALLBACK_FUNCTION(CK_RV, CK_NOTIFY)( + CK_SESSION_HANDLE hSession, + CK_NOTIFICATION event, + CK_VOID_PTR pApplication + ); + +typedef CK_CALLBACK_FUNCTION(CK_RV, CK_CREATEMUTEX)( + CK_VOID_PTR_PTR ppMutex + ); + +typedef CK_CALLBACK_FUNCTION(CK_RV, CK_DESTROYMUTEX)( + CK_VOID_PTR pMutex + ); + +typedef CK_CALLBACK_FUNCTION(CK_RV, CK_LOCKMUTEX)( + CK_VOID_PTR pMutex + ); + +typedef CK_CALLBACK_FUNCTION(CK_RV, CK_UNLOCKMUTEX)( + CK_VOID_PTR pMutex + ); + +typedef struct CK_C_INITIALIZE_ARGS { + CK_CREATEMUTEX CreateMutex; + CK_DESTROYMUTEX DestroyMutex; + CK_LOCKMUTEX LockMutex; + CK_UNLOCKMUTEX UnlockMutex; + CK_FLAGS flags; + CK_VOID_PTR pReserved; +} CK_C_INITIALIZE_ARGS; + +#define CKF_LIBRARY_CANT_CREATE_OS_THREADS 0x00000001 +#define CKF_OS_LOCKING_OK 0x00000002 + +typedef CK_C_INITIALIZE_ARGS CK_PTR CK_C_INITIALIZE_ARGS_PTR; + +typedef struct CK_AES_CTR_PARAMS { + CK_ULONG ulCounterBits; + CK_BYTE cb[16]; +} CK_AES_CTR_PARAMS; + +typedef CK_AES_CTR_PARAMS CK_PTR CK_AES_CTR_PARAMS_PTR; + +typedef struct CK_GCM_PARAMS { + CK_BYTE_PTR pIv; + CK_ULONG ulIvLen; + CK_ULONG ulIvBits; + CK_BYTE_PTR pAAD; + CK_ULONG ulAADLen; + CK_ULONG ulTagBits; +} CK_GCM_PARAMS; + +typedef CK_GCM_PARAMS CK_PTR CK_GCM_PARAMS_PTR; + +typedef struct CK_EDDSA_PARAMS { + CK_BBOOL phFlag; + CK_ULONG ulContextDataLen; + CK_BYTE_PTR pContextData; +} CK_EDDSA_PARAMS; + +typedef CK_EDDSA_PARAMS CK_PTR CK_EDDSA_PARAMS_PTR; + +typedef struct CK_ASYNC_DATA { + CK_ULONG ulVersion; + CK_BYTE_PTR pValue; + CK_ULONG ulValue; + CK_OBJECT_HANDLE hObject; + CK_OBJECT_HANDLE hAdditionalObject; +} CK_ASYNC_DATA; + +typedef CK_ASYNC_DATA CK_PTR CK_ASYNC_DATA_PTR; + +typedef CK_ULONG CK_SESSION_VALIDATION_FLAGS_TYPE; + +#define CKF_INTERFACE_FORK_SAFE 0x00000001UL + +typedef struct CK_INTERFACE { + CK_UTF8CHAR_PTR pInterfaceName; + CK_VOID_PTR pFunctionList; + CK_FLAGS flags; +} CK_INTERFACE; + +typedef CK_INTERFACE CK_PTR CK_INTERFACE_PTR; +typedef CK_INTERFACE_PTR CK_PTR CK_INTERFACE_PTR_PTR; + +typedef struct CK_FUNCTION_LIST CK_FUNCTION_LIST; +typedef CK_FUNCTION_LIST CK_PTR CK_FUNCTION_LIST_PTR; +typedef CK_FUNCTION_LIST_PTR CK_PTR CK_FUNCTION_LIST_PTR_PTR; + +typedef struct CK_FUNCTION_LIST_3_0 CK_FUNCTION_LIST_3_0; +typedef CK_FUNCTION_LIST_3_0 CK_PTR CK_FUNCTION_LIST_3_0_PTR; +typedef CK_FUNCTION_LIST_3_0_PTR CK_PTR CK_FUNCTION_LIST_3_0_PTR_PTR; + +typedef struct CK_FUNCTION_LIST_3_2 CK_FUNCTION_LIST_3_2; +typedef CK_FUNCTION_LIST_3_2 CK_PTR CK_FUNCTION_LIST_3_2_PTR; +typedef CK_FUNCTION_LIST_3_2_PTR CK_PTR CK_FUNCTION_LIST_3_2_PTR_PTR; + +typedef struct CK_IBM_FUNCTION_LIST_1_0 CK_IBM_FUNCTION_LIST_1_0; +typedef struct CK_IBM_FUNCTION_LIST_1_0 CK_PTR CK_IBM_FUNCTION_LIST_1_0_PTR; +typedef CK_IBM_FUNCTION_LIST_1_0_PTR CK_PTR CK_IBM_FUNCTION_LIST_1_0_PTR_PTR; + +typedef CK_RV (CK_PTR CK_C_Initialize) (CK_VOID_PTR pReserved); +typedef CK_RV (CK_PTR CK_C_Finalize) (CK_VOID_PTR pReserved); +typedef CK_RV (CK_PTR CK_C_Terminate) (void); +typedef CK_RV (CK_PTR CK_C_GetInfo) (CK_INFO_PTR pInfo); +typedef CK_RV (CK_PTR CK_C_GetFunctionList) (CK_FUNCTION_LIST_PTR_PTR + ppFunctionList); +typedef CK_RV (CK_PTR CK_C_GetSlotList) (CK_BBOOL tokenPresent, + CK_SLOT_ID_PTR pSlotList, + CK_ULONG_PTR pusCount); +typedef CK_RV (CK_PTR CK_C_GetSlotInfo) (CK_SLOT_ID slotID, + CK_SLOT_INFO_PTR pInfo); +typedef CK_RV (CK_PTR CK_C_GetTokenInfo) (CK_SLOT_ID slotID, + CK_TOKEN_INFO_PTR pInfo); +typedef CK_RV (CK_PTR CK_C_GetMechanismList) (CK_SLOT_ID slotID, + CK_MECHANISM_TYPE_PTR + pMechanismList, + CK_ULONG_PTR pusCount); +typedef CK_RV (CK_PTR CK_C_GetMechanismInfo) (CK_SLOT_ID slotID, + CK_MECHANISM_TYPE type, + CK_MECHANISM_INFO_PTR pInfo); +typedef CK_RV (CK_PTR CK_C_InitToken) (CK_SLOT_ID slotID, + CK_CHAR_PTR pPin, + CK_ULONG usPinLen, CK_CHAR_PTR pLabel); +typedef CK_RV (CK_PTR CK_C_InitPIN) (CK_SESSION_HANDLE hSession, + CK_CHAR_PTR pPin, CK_ULONG usPinLen); +typedef CK_RV (CK_PTR CK_C_SetPIN) (CK_SESSION_HANDLE hSession, + CK_CHAR_PTR pOldPin, + CK_ULONG usOldLen, + CK_CHAR_PTR pNewPin, CK_ULONG usNewLen); +typedef CK_RV (CK_PTR CK_C_OpenSession) (CK_SLOT_ID slotID, CK_FLAGS flags, + CK_VOID_PTR pApplication, + CK_RV (*Notify) + (CK_SESSION_HANDLE hSession, + CK_NOTIFICATION event, + CK_VOID_PTR pApplication), + CK_SESSION_HANDLE_PTR phSession); +typedef CK_RV (CK_PTR CK_C_CloseSession) (CK_SESSION_HANDLE hSession); +typedef CK_RV (CK_PTR CK_C_CloseAllSessions) (CK_SLOT_ID slotID); +typedef CK_RV (CK_PTR CK_C_GetSessionInfo) (CK_SESSION_HANDLE hSession, + CK_SESSION_INFO_PTR pInfo); +typedef CK_RV (CK_PTR CK_C_GetOperationState) (CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pOperationState, + CK_ULONG_PTR + pulOperationStateLen); +typedef CK_RV (CK_PTR CK_C_SetOperationState) (CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pOperationState, + CK_ULONG ulOperationStateLen, + CK_OBJECT_HANDLE hEncryptionKey, + CK_OBJECT_HANDLE + hAuthenticationKey); +typedef CK_RV (CK_PTR CK_C_Login) (CK_SESSION_HANDLE hSession, + CK_USER_TYPE userType, + CK_CHAR_PTR pPin, CK_ULONG usPinLen); +typedef CK_RV (CK_PTR CK_C_Logout) (CK_SESSION_HANDLE hSession); +typedef CK_RV (CK_PTR CK_C_CreateObject) (CK_SESSION_HANDLE hSession, + CK_ATTRIBUTE_PTR pTemplate, + CK_ULONG usCount, + CK_OBJECT_HANDLE_PTR phObject); +typedef CK_RV (CK_PTR CK_C_CopyObject) (CK_SESSION_HANDLE hSession, + CK_OBJECT_HANDLE hObject, + CK_ATTRIBUTE_PTR pTemplate, + CK_ULONG usCount, + CK_OBJECT_HANDLE_PTR phNewObject); +typedef CK_RV (CK_PTR CK_C_DestroyObject) (CK_SESSION_HANDLE hSession, + CK_OBJECT_HANDLE hObject); +typedef CK_RV (CK_PTR CK_C_GetObjectSize) (CK_SESSION_HANDLE hSession, + CK_OBJECT_HANDLE hObject, + CK_ULONG_PTR pusSize); +typedef CK_RV (CK_PTR CK_C_GetAttributeValue) (CK_SESSION_HANDLE hSession, + CK_OBJECT_HANDLE hObject, + CK_ATTRIBUTE_PTR pTemplate, + CK_ULONG usCount); +typedef CK_RV (CK_PTR CK_C_SetAttributeValue) (CK_SESSION_HANDLE hSession, + CK_OBJECT_HANDLE hObject, + CK_ATTRIBUTE_PTR pTemplate, + CK_ULONG usCount); +typedef CK_RV (CK_PTR CK_C_FindObjectsInit) (CK_SESSION_HANDLE hSession, + CK_ATTRIBUTE_PTR pTemplate, + CK_ULONG usCount); +typedef CK_RV (CK_PTR CK_C_FindObjects) (CK_SESSION_HANDLE hSession, + CK_OBJECT_HANDLE_PTR phObject, + CK_ULONG usMaxObjectCount, + CK_ULONG_PTR pusObjectCount); +typedef CK_RV (CK_PTR CK_C_FindObjectsFinal) (CK_SESSION_HANDLE hSession); +typedef CK_RV (CK_PTR CK_C_EncryptInit) (CK_SESSION_HANDLE hSession, + CK_MECHANISM_PTR pMechanism, + CK_OBJECT_HANDLE hKey); +typedef CK_RV (CK_PTR CK_C_Encrypt) (CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pData, + CK_ULONG usDataLen, + CK_BYTE_PTR pEncryptedData, + CK_ULONG_PTR pusEncryptedDataLen); +typedef CK_RV (CK_PTR CK_C_EncryptUpdate) (CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pPart, + CK_ULONG usPartLen, + CK_BYTE_PTR pEncryptedPart, + CK_ULONG_PTR pusEncryptedPartLen); +typedef CK_RV (CK_PTR CK_C_EncryptFinal) (CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pLastEncryptedPart, + CK_ULONG_PTR pusLastEncryptedPartLen); +typedef CK_RV (CK_PTR CK_C_DecryptInit) (CK_SESSION_HANDLE hSession, + CK_MECHANISM_PTR pMechanism, + CK_OBJECT_HANDLE hKey); +typedef CK_RV (CK_PTR CK_C_Decrypt) (CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pEncryptedData, + CK_ULONG usEncryptedDataLen, + CK_BYTE_PTR pData, + CK_ULONG_PTR pusDataLen); +typedef CK_RV (CK_PTR CK_C_DecryptUpdate) (CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pEncryptedPart, + CK_ULONG usEncryptedPartLen, + CK_BYTE_PTR pPart, + CK_ULONG_PTR pusPartLen); +typedef CK_RV (CK_PTR CK_C_DecryptFinal) (CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pLastPart, + CK_ULONG_PTR pusLastPartLen); +typedef CK_RV (CK_PTR CK_C_DigestInit) (CK_SESSION_HANDLE hSession, + CK_MECHANISM_PTR pMechanism); +typedef CK_RV (CK_PTR CK_C_Digest) (CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pData, + CK_ULONG usDataLen, + CK_BYTE_PTR pDigest, + CK_ULONG_PTR pusDigestLen); +typedef CK_RV (CK_PTR CK_C_DigestUpdate) (CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pPart, + CK_ULONG usPartLen); +typedef CK_RV (CK_PTR CK_C_DigestKey) (CK_SESSION_HANDLE hSession, + CK_OBJECT_HANDLE hKey); +typedef CK_RV (CK_PTR CK_C_DigestFinal) (CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pDigest, + CK_ULONG_PTR pusDigestLen); +typedef CK_RV (CK_PTR CK_C_SignInit) (CK_SESSION_HANDLE hSession, + CK_MECHANISM_PTR pMechanism, + CK_OBJECT_HANDLE hKey); +typedef CK_RV (CK_PTR CK_C_Sign) (CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pData, + CK_ULONG usDataLen, + CK_BYTE_PTR pSignature, + CK_ULONG_PTR pusSignatureLen); +typedef CK_RV (CK_PTR CK_C_SignUpdate) (CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pPart, CK_ULONG usPartLen); +typedef CK_RV (CK_PTR CK_C_SignFinal) (CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pSignature, + CK_ULONG_PTR pusSignatureLen); +typedef CK_RV (CK_PTR CK_C_SignRecoverInit) (CK_SESSION_HANDLE hSession, + CK_MECHANISM_PTR pMechanism, + CK_OBJECT_HANDLE hKey); +typedef CK_RV (CK_PTR CK_C_SignRecover) (CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pData, + CK_ULONG usDataLen, + CK_BYTE_PTR pSignature, + CK_ULONG_PTR pusSignatureLen); +typedef CK_RV (CK_PTR CK_C_VerifyInit) (CK_SESSION_HANDLE hSession, + CK_MECHANISM_PTR pMechanism, + CK_OBJECT_HANDLE hKey); +typedef CK_RV (CK_PTR CK_C_Verify) (CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pData, + CK_ULONG usDataLen, + CK_BYTE_PTR pSignature, + CK_ULONG usSignatureLen); +typedef CK_RV (CK_PTR CK_C_VerifyUpdate) (CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pPart, + CK_ULONG usPartLen); +typedef CK_RV (CK_PTR CK_C_VerifyFinal) (CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pSignature, + CK_ULONG usSignatureLen); +typedef CK_RV (CK_PTR CK_C_VerifyRecoverInit) (CK_SESSION_HANDLE hSession, + CK_MECHANISM_PTR pMechanism, + CK_OBJECT_HANDLE hKey); +typedef CK_RV (CK_PTR CK_C_VerifyRecover) (CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pSignature, + CK_ULONG usSignatureLen, + CK_BYTE_PTR pData, + CK_ULONG_PTR pusDataLen); +typedef CK_RV (CK_PTR CK_C_DigestEncryptUpdate) (CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pPart, + CK_ULONG ulPartLen, + CK_BYTE_PTR pEncryptedPart, + CK_ULONG_PTR + pulEncryptedPartLen); +typedef CK_RV (CK_PTR CK_C_DecryptDigestUpdate) (CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pEncryptedPart, + CK_ULONG ulEncryptedPartLen, + CK_BYTE_PTR pPart, + CK_ULONG_PTR pulPartLen); +typedef CK_RV (CK_PTR CK_C_SignEncryptUpdate) (CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pPart, + CK_ULONG ulPartLen, + CK_BYTE_PTR pEncryptedPart, + CK_ULONG_PTR + pulEncryptedPartLen); +typedef CK_RV (CK_PTR CK_C_DecryptVerifyUpdate) (CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pEncryptedPart, + CK_ULONG ulEncryptedPartLen, + CK_BYTE_PTR pPart, + CK_ULONG_PTR pulPartLen); +typedef CK_RV (CK_PTR CK_C_GenerateKey) (CK_SESSION_HANDLE hSession, + CK_MECHANISM_PTR pMechanism, + CK_ATTRIBUTE_PTR pTemplate, + CK_ULONG usCount, + CK_OBJECT_HANDLE_PTR phKey); +typedef CK_RV (CK_PTR CK_C_GenerateKeyPair) (CK_SESSION_HANDLE hSession, + CK_MECHANISM_PTR pMechanism, + CK_ATTRIBUTE_PTR + pPublicKeyTemplate, + CK_ULONG usPublicKeyAttributeCount, + CK_ATTRIBUTE_PTR + pPrivateKeyTemplate, + CK_ULONG + usPrivateKeyAttributeCount, + CK_OBJECT_HANDLE_PTR phPrivateKey, + CK_OBJECT_HANDLE_PTR phPublicKey); +typedef CK_RV (CK_PTR CK_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 pusWrappedKeyLen); +typedef CK_RV (CK_PTR CK_C_UnwrapKey) (CK_SESSION_HANDLE hSession, + CK_MECHANISM_PTR pMechanism, + CK_OBJECT_HANDLE hUnwrappingKey, + CK_BYTE_PTR pWrappedKey, + CK_ULONG usWrappedKeyLen, + CK_ATTRIBUTE_PTR pTemplate, + CK_ULONG usAttributeCount, + CK_OBJECT_HANDLE_PTR phKey); +typedef CK_RV (CK_PTR CK_C_DeriveKey) (CK_SESSION_HANDLE hSession, + CK_MECHANISM_PTR pMechanism, + CK_OBJECT_HANDLE hBaseKey, + CK_ATTRIBUTE_PTR pTemplate, + CK_ULONG usAttributeCount, + CK_OBJECT_HANDLE_PTR phKey); +typedef CK_RV (CK_PTR CK_C_SeedRandom) (CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pSeed, CK_ULONG usSeedLen); +typedef CK_RV (CK_PTR CK_C_GenerateRandom) (CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pRandomData, + CK_ULONG usRandomLen); +typedef CK_RV (CK_PTR CK_C_GetFunctionStatus) (CK_SESSION_HANDLE hSession); +typedef CK_RV (CK_PTR CK_C_CancelFunction) (CK_SESSION_HANDLE hSession); +typedef CK_RV (CK_PTR CK_Notify) (CK_SESSION_HANDLE hSession, + CK_NOTIFICATION event, + CK_VOID_PTR pApplication); +typedef CK_RV (CK_PTR CK_C_WaitForSlotEvent) (CK_FLAGS flags, + CK_SLOT_ID_PTR pSlot, + CK_VOID_PTR pReserved); + +typedef CK_RV (CK_PTR CK_C_GetInterfaceList) (CK_INTERFACE *pInterfaceList, + CK_ULONG *pulCount); +typedef CK_RV (CK_PTR CK_C_GetInterface) (CK_UTF8CHAR *pInterfaceName, + CK_VERSION *pVersion, + CK_INTERFACE **ppInterface, + CK_FLAGS flags); +typedef CK_RV (CK_PTR CK_C_LoginUser) (CK_SESSION_HANDLE hSession, + CK_USER_TYPE userType, + CK_UTF8CHAR *pPin, CK_ULONG ulPinLen, + CK_UTF8CHAR *pUsername, + CK_ULONG ulUsernameLen); +typedef CK_RV (CK_PTR CK_C_SessionCancel) (CK_SESSION_HANDLE hSession, + CK_FLAGS flags); +typedef CK_RV (CK_PTR CK_C_MessageEncryptInit) (CK_SESSION_HANDLE hSession, + CK_MECHANISM *pMechanism, + CK_OBJECT_HANDLE hKey); +typedef CK_RV (CK_PTR CK_C_EncryptMessage) (CK_SESSION_HANDLE hSession, + void *pParameter, + CK_ULONG ulParameterLen, + CK_BYTE *pAssociatedData, + CK_ULONG ulAssociatedDataLen, + CK_BYTE *pPlaintext, + CK_ULONG ulPlaintextLen, + CK_BYTE *pCiphertext, + CK_ULONG *pulCiphertextLen); +typedef CK_RV (CK_PTR CK_C_EncryptMessageBegin) (CK_SESSION_HANDLE hSession, + void *pParameter, + CK_ULONG ulParameterLen, + CK_BYTE *pAssociatedData, + CK_ULONG ulAssociatedDataLen); +typedef CK_RV (CK_PTR CK_C_EncryptMessageNext) (CK_SESSION_HANDLE hSession, + void *pParameter, + CK_ULONG ulParameterLen, + CK_BYTE *pPlaintextPart, + CK_ULONG ulPlaintextPartLen, + CK_BYTE *pCiphertextPart, + CK_ULONG *pulCiphertextPartLen, + CK_ULONG flags); +typedef CK_RV (CK_PTR CK_C_MessageEncryptFinal) (CK_SESSION_HANDLE hSession); +typedef CK_RV (CK_PTR CK_C_MessageDecryptInit) (CK_SESSION_HANDLE hSession, + CK_MECHANISM *pMechanism, + CK_OBJECT_HANDLE hKey); +typedef CK_RV (CK_PTR CK_C_DecryptMessage) (CK_SESSION_HANDLE hSession, + void *pParameter, + CK_ULONG ulParameterLen, + CK_BYTE *pAssociatedData, + CK_ULONG ulAssociatedDataLen, + CK_BYTE *pCiphertext, + CK_ULONG ulCiphertextLen, + CK_BYTE *pPlaintext, + CK_ULONG *pulPlaintextLen); +typedef CK_RV (CK_PTR CK_C_DecryptMessageBegin) (CK_SESSION_HANDLE hSession, + void *pParameter, + CK_ULONG ulParameterLen, + CK_BYTE *pAssociatedData, + CK_ULONG ulAssociatedDataLen); +typedef CK_RV (CK_PTR CK_C_DecryptMessageNext) (CK_SESSION_HANDLE hSession, + void *pParameter, + CK_ULONG ulParameterLen, + CK_BYTE *pCiphertextPart, + CK_ULONG ulCiphertextPartLen, + CK_BYTE *pPlaintextPart, + CK_ULONG *pulPlaintextPartLen, + CK_FLAGS flags); +typedef CK_RV (CK_PTR CK_C_MessageDecryptFinal) (CK_SESSION_HANDLE hSession); +typedef CK_RV (CK_PTR CK_C_MessageSignInit) (CK_SESSION_HANDLE hSession, + CK_MECHANISM *pMechanism, + CK_OBJECT_HANDLE hKey); +typedef CK_RV (CK_PTR CK_C_SignMessage) (CK_SESSION_HANDLE hSession, + void *pParameter, + CK_ULONG ulParameterLen, + CK_BYTE *pData, + CK_ULONG ulDataLen, + CK_BYTE *pSignature, + CK_ULONG *pulSignatureLen); +typedef CK_RV (CK_PTR CK_C_SignMessageBegin) (CK_SESSION_HANDLE hSession, + void *pParameter, + CK_ULONG ulParameterLen); +typedef CK_RV (CK_PTR CK_C_SignMessageNext) (CK_SESSION_HANDLE hSession, + void *pParameter, + CK_ULONG ulParameterLen, + CK_BYTE *pDataPart, + CK_ULONG ulDataPartLen, + CK_BYTE *pSignature, + CK_ULONG *pulSignatureLen); +typedef CK_RV (CK_PTR CK_C_MessageSignFinal) (CK_SESSION_HANDLE hSession); +typedef CK_RV (CK_PTR CK_C_MessageVerifyInit) (CK_SESSION_HANDLE hSession, + CK_MECHANISM *pMechanism, + CK_OBJECT_HANDLE hKey); +typedef CK_RV (CK_PTR CK_C_VerifyMessage) (CK_SESSION_HANDLE hSession, + void *pParameter, + CK_ULONG ulParameterLen, + CK_BYTE *pData, + CK_ULONG ulDataLen, + CK_BYTE *pSignature, + CK_ULONG ulSignatureLen); +typedef CK_RV (CK_PTR CK_C_VerifyMessageBegin) (CK_SESSION_HANDLE hSession, + void *pParameter, + CK_ULONG ulParameterLen); +typedef CK_RV (CK_PTR CK_C_VerifyMessageNext) (CK_SESSION_HANDLE hSession, + void *pParameter, + CK_ULONG ulParameterLen, + CK_BYTE *pDataPart, + CK_ULONG ulDataPartLen, + CK_BYTE *pSignature, + CK_ULONG ulSignatureLen); +typedef CK_RV (CK_PTR CK_C_MessageVerifyFinal) (CK_SESSION_HANDLE hSession); + +typedef CK_RV (CK_PTR CK_C_EncapsulateKey) (CK_SESSION_HANDLE hSession, + CK_MECHANISM_PTR pMechanism, + CK_OBJECT_HANDLE hPublicKey, + CK_ATTRIBUTE_PTR pTemplate, + CK_ULONG ulAttributeCount, + CK_BYTE_PTR pCiphertext, + CK_ULONG_PTR pulCiphertextLen, + CK_OBJECT_HANDLE_PTR phKey); + +typedef CK_RV (CK_PTR CK_C_DecapsulateKey) (CK_SESSION_HANDLE hSession, + CK_MECHANISM_PTR pMechanism, + CK_OBJECT_HANDLE hPrivateKey, + CK_ATTRIBUTE_PTR pTemplate, + CK_ULONG ulAttributeCount, + CK_BYTE_PTR pCiphertext, + CK_ULONG ulCiphertextLen, + CK_OBJECT_HANDLE_PTR phKey); + +typedef CK_RV (CK_PTR CK_C_VerifySignatureInit) (CK_SESSION_HANDLE hSession, + CK_MECHANISM_PTR pMechanism, + CK_OBJECT_HANDLE hKey, + CK_BYTE_PTR pSignature, + CK_ULONG ulSignatureLen); + +typedef CK_RV (CK_PTR CK_C_VerifySignature) (CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pData, + CK_ULONG ulDataLen); + +typedef CK_RV (CK_PTR CK_C_VerifySignatureUpdate) (CK_SESSION_HANDLE hSession, + CK_BYTE_PTR pPart, + CK_ULONG ulPartLen); + +typedef CK_RV (CK_PTR CK_C_VerifySignatureFinal) (CK_SESSION_HANDLE hSession); + +typedef CK_RV (CK_PTR CK_C_GetSessionValidationFlags) (CK_SESSION_HANDLE hSession, + CK_SESSION_VALIDATION_FLAGS_TYPE type, + CK_FLAGS_PTR pFlags); + +typedef CK_RV (CK_PTR CK_C_AsyncComplete) (CK_SESSION_HANDLE hSession, + CK_UTF8CHAR_PTR pFunctionName, + CK_ASYNC_DATA_PTR pResult); + +typedef CK_RV (CK_PTR CK_C_AsyncGetID) (CK_SESSION_HANDLE hSession, + CK_UTF8CHAR_PTR pFunctionName, + CK_ULONG_PTR pulID); + +typedef CK_RV (CK_PTR CK_C_AsyncJoin) (CK_SESSION_HANDLE hSession, + CK_UTF8CHAR_PTR pFunctionName, + CK_ULONG ulID, + CK_BYTE_PTR pData, + CK_ULONG ulData); + +typedef CK_RV (CK_PTR CK_C_WrapKeyAuthenticated) (CK_SESSION_HANDLE hSession, + CK_MECHANISM_PTR pMechanism, + CK_OBJECT_HANDLE hWrappingKey, + CK_OBJECT_HANDLE hKey, + CK_BYTE_PTR pAssociatedData, + CK_ULONG ulAssociatedDataLen, + CK_BYTE_PTR pWrappedKey, + CK_ULONG_PTR pulWrappedKeyLen); + +typedef CK_RV (CK_PTR CK_C_UnwrapKeyAuthenticated) (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 ulAttributeCount, + CK_BYTE_PTR pAssociatedData, + CK_ULONG ulAssociatedDataLen, + CK_OBJECT_HANDLE_PTR phKey); + +struct CK_FUNCTION_LIST { + CK_VERSION version; + CK_C_Initialize C_Initialize; + CK_C_Finalize C_Finalize; + CK_C_GetInfo C_GetInfo; + CK_C_GetFunctionList C_GetFunctionList; + CK_C_GetSlotList C_GetSlotList; + CK_C_GetSlotInfo C_GetSlotInfo; + CK_C_GetTokenInfo C_GetTokenInfo; + CK_C_GetMechanismList C_GetMechanismList; + CK_C_GetMechanismInfo C_GetMechanismInfo; + CK_C_InitToken C_InitToken; + CK_C_InitPIN C_InitPIN; + CK_C_SetPIN C_SetPIN; + CK_C_OpenSession C_OpenSession; + CK_C_CloseSession C_CloseSession; + CK_C_CloseAllSessions C_CloseAllSessions; + CK_C_GetSessionInfo C_GetSessionInfo; + CK_C_GetOperationState C_GetOperationState; + CK_C_SetOperationState C_SetOperationState; + CK_C_Login C_Login; + CK_C_Logout C_Logout; + CK_C_CreateObject C_CreateObject; + CK_C_CopyObject C_CopyObject; + CK_C_DestroyObject C_DestroyObject; + CK_C_GetObjectSize C_GetObjectSize; + CK_C_GetAttributeValue C_GetAttributeValue; + CK_C_SetAttributeValue C_SetAttributeValue; + CK_C_FindObjectsInit C_FindObjectsInit; + CK_C_FindObjects C_FindObjects; + CK_C_FindObjectsFinal C_FindObjectsFinal; + CK_C_EncryptInit C_EncryptInit; + CK_C_Encrypt C_Encrypt; + CK_C_EncryptUpdate C_EncryptUpdate; + CK_C_EncryptFinal C_EncryptFinal; + CK_C_DecryptInit C_DecryptInit; + CK_C_Decrypt C_Decrypt; + CK_C_DecryptUpdate C_DecryptUpdate; + CK_C_DecryptFinal C_DecryptFinal; + CK_C_DigestInit C_DigestInit; + CK_C_Digest C_Digest; + CK_C_DigestUpdate C_DigestUpdate; + CK_C_DigestKey C_DigestKey; + CK_C_DigestFinal C_DigestFinal; + CK_C_SignInit C_SignInit; + CK_C_Sign C_Sign; + CK_C_SignUpdate C_SignUpdate; + CK_C_SignFinal C_SignFinal; + CK_C_SignRecoverInit C_SignRecoverInit; + CK_C_SignRecover C_SignRecover; + CK_C_VerifyInit C_VerifyInit; + CK_C_Verify C_Verify; + CK_C_VerifyUpdate C_VerifyUpdate; + CK_C_VerifyFinal C_VerifyFinal; + CK_C_VerifyRecoverInit C_VerifyRecoverInit; + CK_C_VerifyRecover C_VerifyRecover; + CK_C_DigestEncryptUpdate C_DigestEncryptUpdate; + CK_C_DecryptDigestUpdate C_DecryptDigestUpdate; + CK_C_SignEncryptUpdate C_SignEncryptUpdate; + CK_C_DecryptVerifyUpdate C_DecryptVerifyUpdate; + CK_C_GenerateKey C_GenerateKey; + CK_C_GenerateKeyPair C_GenerateKeyPair; + CK_C_WrapKey C_WrapKey; + CK_C_UnwrapKey C_UnwrapKey; + CK_C_DeriveKey C_DeriveKey; + CK_C_SeedRandom C_SeedRandom; + CK_C_GenerateRandom C_GenerateRandom; + CK_C_GetFunctionStatus C_GetFunctionStatus; + CK_C_CancelFunction C_CancelFunction; + CK_C_WaitForSlotEvent C_WaitForSlotEvent; +}; + +struct CK_FUNCTION_LIST_3_0 { + CK_VERSION version; + CK_C_Initialize C_Initialize; + CK_C_Finalize C_Finalize; + CK_C_GetInfo C_GetInfo; + CK_C_GetFunctionList C_GetFunctionList; + CK_C_GetSlotList C_GetSlotList; + CK_C_GetSlotInfo C_GetSlotInfo; + CK_C_GetTokenInfo C_GetTokenInfo; + CK_C_GetMechanismList C_GetMechanismList; + CK_C_GetMechanismInfo C_GetMechanismInfo; + CK_C_InitToken C_InitToken; + CK_C_InitPIN C_InitPIN; + CK_C_SetPIN C_SetPIN; + CK_C_OpenSession C_OpenSession; + CK_C_CloseSession C_CloseSession; + CK_C_CloseAllSessions C_CloseAllSessions; + CK_C_GetSessionInfo C_GetSessionInfo; + CK_C_GetOperationState C_GetOperationState; + CK_C_SetOperationState C_SetOperationState; + CK_C_Login C_Login; + CK_C_Logout C_Logout; + CK_C_CreateObject C_CreateObject; + CK_C_CopyObject C_CopyObject; + CK_C_DestroyObject C_DestroyObject; + CK_C_GetObjectSize C_GetObjectSize; + CK_C_GetAttributeValue C_GetAttributeValue; + CK_C_SetAttributeValue C_SetAttributeValue; + CK_C_FindObjectsInit C_FindObjectsInit; + CK_C_FindObjects C_FindObjects; + CK_C_FindObjectsFinal C_FindObjectsFinal; + CK_C_EncryptInit C_EncryptInit; + CK_C_Encrypt C_Encrypt; + CK_C_EncryptUpdate C_EncryptUpdate; + CK_C_EncryptFinal C_EncryptFinal; + CK_C_DecryptInit C_DecryptInit; + CK_C_Decrypt C_Decrypt; + CK_C_DecryptUpdate C_DecryptUpdate; + CK_C_DecryptFinal C_DecryptFinal; + CK_C_DigestInit C_DigestInit; + CK_C_Digest C_Digest; + CK_C_DigestUpdate C_DigestUpdate; + CK_C_DigestKey C_DigestKey; + CK_C_DigestFinal C_DigestFinal; + CK_C_SignInit C_SignInit; + CK_C_Sign C_Sign; + CK_C_SignUpdate C_SignUpdate; + CK_C_SignFinal C_SignFinal; + CK_C_SignRecoverInit C_SignRecoverInit; + CK_C_SignRecover C_SignRecover; + CK_C_VerifyInit C_VerifyInit; + CK_C_Verify C_Verify; + CK_C_VerifyUpdate C_VerifyUpdate; + CK_C_VerifyFinal C_VerifyFinal; + CK_C_VerifyRecoverInit C_VerifyRecoverInit; + CK_C_VerifyRecover C_VerifyRecover; + CK_C_DigestEncryptUpdate C_DigestEncryptUpdate; + CK_C_DecryptDigestUpdate C_DecryptDigestUpdate; + CK_C_SignEncryptUpdate C_SignEncryptUpdate; + CK_C_DecryptVerifyUpdate C_DecryptVerifyUpdate; + CK_C_GenerateKey C_GenerateKey; + CK_C_GenerateKeyPair C_GenerateKeyPair; + CK_C_WrapKey C_WrapKey; + CK_C_UnwrapKey C_UnwrapKey; + CK_C_DeriveKey C_DeriveKey; + CK_C_SeedRandom C_SeedRandom; + CK_C_GenerateRandom C_GenerateRandom; + CK_C_GetFunctionStatus C_GetFunctionStatus; + CK_C_CancelFunction C_CancelFunction; + CK_C_WaitForSlotEvent C_WaitForSlotEvent; + + CK_C_GetInterfaceList C_GetInterfaceList; + CK_C_GetInterface C_GetInterface; + CK_C_LoginUser C_LoginUser; + CK_C_SessionCancel C_SessionCancel; + CK_C_MessageEncryptInit C_MessageEncryptInit; + CK_C_EncryptMessage C_EncryptMessage; + CK_C_EncryptMessageBegin C_EncryptMessageBegin; + CK_C_EncryptMessageNext C_EncryptMessageNext; + CK_C_MessageEncryptFinal C_MessageEncryptFinal; + CK_C_MessageDecryptInit C_MessageDecryptInit; + CK_C_DecryptMessage C_DecryptMessage; + CK_C_DecryptMessageBegin C_DecryptMessageBegin; + CK_C_DecryptMessageNext C_DecryptMessageNext; + CK_C_MessageDecryptFinal C_MessageDecryptFinal; + CK_C_MessageSignInit C_MessageSignInit; + CK_C_SignMessage C_SignMessage; + CK_C_SignMessageBegin C_SignMessageBegin; + CK_C_SignMessageNext C_SignMessageNext; + CK_C_MessageSignFinal C_MessageSignFinal; + CK_C_MessageVerifyInit C_MessageVerifyInit; + CK_C_VerifyMessage C_VerifyMessage; + CK_C_VerifyMessageBegin C_VerifyMessageBegin; + CK_C_VerifyMessageNext C_VerifyMessageNext; + CK_C_MessageVerifyFinal C_MessageVerifyFinal; +}; + +struct CK_FUNCTION_LIST_3_2 { + CK_VERSION version; + CK_C_Initialize C_Initialize; + CK_C_Finalize C_Finalize; + CK_C_GetInfo C_GetInfo; + CK_C_GetFunctionList C_GetFunctionList; + CK_C_GetSlotList C_GetSlotList; + CK_C_GetSlotInfo C_GetSlotInfo; + CK_C_GetTokenInfo C_GetTokenInfo; + CK_C_GetMechanismList C_GetMechanismList; + CK_C_GetMechanismInfo C_GetMechanismInfo; + CK_C_InitToken C_InitToken; + CK_C_InitPIN C_InitPIN; + CK_C_SetPIN C_SetPIN; + CK_C_OpenSession C_OpenSession; + CK_C_CloseSession C_CloseSession; + CK_C_CloseAllSessions C_CloseAllSessions; + CK_C_GetSessionInfo C_GetSessionInfo; + CK_C_GetOperationState C_GetOperationState; + CK_C_SetOperationState C_SetOperationState; + CK_C_Login C_Login; + CK_C_Logout C_Logout; + CK_C_CreateObject C_CreateObject; + CK_C_CopyObject C_CopyObject; + CK_C_DestroyObject C_DestroyObject; + CK_C_GetObjectSize C_GetObjectSize; + CK_C_GetAttributeValue C_GetAttributeValue; + CK_C_SetAttributeValue C_SetAttributeValue; + CK_C_FindObjectsInit C_FindObjectsInit; + CK_C_FindObjects C_FindObjects; + CK_C_FindObjectsFinal C_FindObjectsFinal; + CK_C_EncryptInit C_EncryptInit; + CK_C_Encrypt C_Encrypt; + CK_C_EncryptUpdate C_EncryptUpdate; + CK_C_EncryptFinal C_EncryptFinal; + CK_C_DecryptInit C_DecryptInit; + CK_C_Decrypt C_Decrypt; + CK_C_DecryptUpdate C_DecryptUpdate; + CK_C_DecryptFinal C_DecryptFinal; + CK_C_DigestInit C_DigestInit; + CK_C_Digest C_Digest; + CK_C_DigestUpdate C_DigestUpdate; + CK_C_DigestKey C_DigestKey; + CK_C_DigestFinal C_DigestFinal; + CK_C_SignInit C_SignInit; + CK_C_Sign C_Sign; + CK_C_SignUpdate C_SignUpdate; + CK_C_SignFinal C_SignFinal; + CK_C_SignRecoverInit C_SignRecoverInit; + CK_C_SignRecover C_SignRecover; + CK_C_VerifyInit C_VerifyInit; + CK_C_Verify C_Verify; + CK_C_VerifyUpdate C_VerifyUpdate; + CK_C_VerifyFinal C_VerifyFinal; + CK_C_VerifyRecoverInit C_VerifyRecoverInit; + CK_C_VerifyRecover C_VerifyRecover; + CK_C_DigestEncryptUpdate C_DigestEncryptUpdate; + CK_C_DecryptDigestUpdate C_DecryptDigestUpdate; + CK_C_SignEncryptUpdate C_SignEncryptUpdate; + CK_C_DecryptVerifyUpdate C_DecryptVerifyUpdate; + CK_C_GenerateKey C_GenerateKey; + CK_C_GenerateKeyPair C_GenerateKeyPair; + CK_C_WrapKey C_WrapKey; + CK_C_UnwrapKey C_UnwrapKey; + CK_C_DeriveKey C_DeriveKey; + CK_C_SeedRandom C_SeedRandom; + CK_C_GenerateRandom C_GenerateRandom; + CK_C_GetFunctionStatus C_GetFunctionStatus; + CK_C_CancelFunction C_CancelFunction; + CK_C_WaitForSlotEvent C_WaitForSlotEvent; + + CK_C_GetInterfaceList C_GetInterfaceList; + CK_C_GetInterface C_GetInterface; + CK_C_LoginUser C_LoginUser; + CK_C_SessionCancel C_SessionCancel; + CK_C_MessageEncryptInit C_MessageEncryptInit; + CK_C_EncryptMessage C_EncryptMessage; + CK_C_EncryptMessageBegin C_EncryptMessageBegin; + CK_C_EncryptMessageNext C_EncryptMessageNext; + CK_C_MessageEncryptFinal C_MessageEncryptFinal; + CK_C_MessageDecryptInit C_MessageDecryptInit; + CK_C_DecryptMessage C_DecryptMessage; + CK_C_DecryptMessageBegin C_DecryptMessageBegin; + CK_C_DecryptMessageNext C_DecryptMessageNext; + CK_C_MessageDecryptFinal C_MessageDecryptFinal; + CK_C_MessageSignInit C_MessageSignInit; + CK_C_SignMessage C_SignMessage; + CK_C_SignMessageBegin C_SignMessageBegin; + CK_C_SignMessageNext C_SignMessageNext; + CK_C_MessageSignFinal C_MessageSignFinal; + CK_C_MessageVerifyInit C_MessageVerifyInit; + CK_C_VerifyMessage C_VerifyMessage; + CK_C_VerifyMessageBegin C_VerifyMessageBegin; + CK_C_VerifyMessageNext C_VerifyMessageNext; + CK_C_MessageVerifyFinal C_MessageVerifyFinal; + + CK_C_EncapsulateKey C_EncapsulateKey; + CK_C_DecapsulateKey C_DecapsulateKey; + CK_C_VerifySignatureInit C_VerifySignatureInit; + CK_C_VerifySignature C_VerifySignature; + CK_C_VerifySignatureUpdate C_VerifySignatureUpdate; + CK_C_VerifySignatureFinal C_VerifySignatureFinal; + CK_C_GetSessionValidationFlags C_GetSessionValidationFlags; + CK_C_AsyncComplete C_AsyncComplete; + CK_C_AsyncGetID C_AsyncGetID; + CK_C_AsyncJoin C_AsyncJoin; + CK_C_WrapKeyAuthenticated C_WrapKeyAuthenticated; + CK_C_UnwrapKeyAuthenticated C_UnwrapKeyAuthenticated; +}; + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/zpcpkcs11.map b/zpcpkcs11.map new file mode 100644 index 00000000..695b7e03 --- /dev/null +++ b/zpcpkcs11.map @@ -0,0 +1,110 @@ +ZPCPKCS11_1.0 { +global: + C_CancelFunction; + C_CloseAllSessions; + C_CloseSession; + C_CopyObject; + C_CreateObject; + C_Decrypt; + C_DecryptDigestUpdate; + C_DecryptFinal; + C_DecryptInit; + C_DecryptUpdate; + C_DecryptVerifyUpdate; + C_DeriveKey; + C_DestroyObject; + C_Digest; + C_DigestEncryptUpdate; + C_DigestFinal; + C_DigestInit; + C_DigestKey; + C_DigestUpdate; + C_Encrypt; + C_EncryptFinal; + C_EncryptInit; + C_EncryptUpdate; + C_Finalize; + C_FindObjects; + C_FindObjectsFinal; + C_FindObjectsInit; + C_GenerateKey; + C_GenerateKeyPair; + C_GenerateRandom; + C_GetAttributeValue; + C_GetFunctionList; + C_GetFunctionStatus; + C_GetInfo; + C_GetMechanismInfo; + C_GetMechanismList; + C_GetObjectSize; + C_GetOperationState; + C_GetSessionInfo; + C_GetSlotInfo; + C_GetSlotList; + C_GetTokenInfo; + C_InitPIN; + C_InitToken; + C_Initialize; + C_Login; + C_Logout; + C_OpenSession; + C_SeedRandom; + C_SetAttributeValue; + C_SetOperationState; + C_SetPIN; + C_Sign; + C_SignEncryptUpdate; + C_SignFinal; + C_SignInit; + C_SignRecover; + C_SignRecoverInit; + C_SignUpdate; + C_WrapKey; + C_UnwrapKey; + C_Verify; + C_VerifyFinal; + C_VerifyInit; + C_VerifyRecover; + C_VerifyRecoverInit; + C_VerifyUpdate; + C_WaitForSlotEvent; + C_GetInterfaceList; + C_GetInterface; + C_LoginUser; + C_SessionCancel; + C_MessageEncryptInit; + C_EncryptMessage; + C_EncryptMessageBegin; + C_EncryptMessageNext; + C_MessageEncryptFinal; + C_MessageDecryptInit; + C_DecryptMessage; + C_DecryptMessageBegin; + C_DecryptMessageNext; + C_MessageDecryptFinal; + C_MessageSignInit; + C_SignMessage; + C_SignMessageBegin; + C_SignMessageNext; + C_MessageSignFinal; + C_MessageVerifyInit; + C_VerifyMessage; + C_VerifyMessageBegin; + C_VerifyMessageNext; + C_MessageVerifyFinal; + C_EncapsulateKey; + C_DecapsulateKey; + C_VerifySignatureInit; + C_VerifySignature; + C_VerifySignatureUpdate; + C_VerifySignatureFinal; + C_GetSessionValidationFlags; + C_AsyncComplete; + C_AsyncGetID; + C_AsyncJoin; + C_WrapKeyAuthenticated; + C_UnwrapKeyAuthenticated; + +local: + *; +}; From 04363cf5f1a5db91e96480a3fd118b7ea3ab49a0 Mon Sep 17 00:00:00 2001 From: Ingo Franzki Date: Mon, 4 May 2026 13:40:30 +0200 Subject: [PATCH 02/17] pkcs11: Implement C_GetSlotList, C_GetSlotInfo, C_GetTokenInfo Report a single slot (ID 0) and a read-only token named "ZPC" as present and initialized. Signed-off-by: Ingo Franzki --- src/pkcs11/pkcs11.c | 97 ++++++++++++++++++++++++++++++++++++++++----- 1 file changed, 88 insertions(+), 9 deletions(-) diff --git a/src/pkcs11/pkcs11.c b/src/pkcs11/pkcs11.c index e0f0742c..ad6045eb 100644 --- a/src/pkcs11/pkcs11.c +++ b/src/pkcs11/pkcs11.c @@ -6,6 +6,11 @@ #define PKCS11_MANUFACTURER "IBM" #define PKCS11_LIBRARY_DESC "ZPC PKCS#11 provider" +#define PKCS11_SLOT_DESC "ZPC PKCS#11 slot" +#define PKCS11_TOKEN_LABEL "ZPC" +#define PKCS11_TOKEN_MODEL "ZPC" +#define PKCS11_TOKEN_SN "01" +#define PKCS11_SLOT_NUMBER 0 CK_RV C_Finalize(CK_VOID_PTR pReserved); @@ -98,24 +103,98 @@ CK_RV C_GetInfo(CK_INFO_PTR pInfo) CK_RV C_GetSlotList(CK_BBOOL tokenPresent, CK_SLOT_ID_PTR pSlotList, CK_ULONG_PTR pulCount) { + if (pulCount == NULL) + return CKR_ARGUMENTS_BAD; + if (!api_initialized) + return CKR_CRYPTOKI_NOT_INITIALIZED; + (void)tokenPresent; - (void)pSlotList; - (void)pulCount; - return CKR_FUNCTION_NOT_SUPPORTED; + + if (pSlotList != NULL) { + if (*pulCount < 1) + return CKR_BUFFER_TOO_SMALL; + + pSlotList[0] = PKCS11_SLOT_NUMBER; + } + + *pulCount = 1; + + return CKR_OK; } CK_RV C_GetSlotInfo(CK_SLOT_ID slotID, CK_SLOT_INFO_PTR pInfo) { - (void)slotID; - (void)pInfo; - return CKR_FUNCTION_NOT_SUPPORTED; + if (pInfo == NULL) + return CKR_ARGUMENTS_BAD; + if (!api_initialized) + return CKR_CRYPTOKI_NOT_INITIALIZED; + if (slotID != PKCS11_SLOT_NUMBER) + return CKR_SLOT_ID_INVALID; + + memset(pInfo->slotDescription, ' ', sizeof(pInfo->slotDescription)); + memcpy(pInfo->slotDescription, PKCS11_SLOT_DESC, + strlen(PKCS11_SLOT_DESC)); + + memset(pInfo->manufacturerID, ' ', sizeof(pInfo->manufacturerID)); + memcpy(pInfo->manufacturerID, PKCS11_MANUFACTURER, + strlen(PKCS11_MANUFACTURER)); + + pInfo->flags = CKF_TOKEN_PRESENT | CKF_HW_SLOT; + + pInfo->hardwareVersion.major = ZPCPKCS11_VERSION_MAJOR; + pInfo->hardwareVersion.minor = ZPCPKCS11_VERSION_MINOR; + + pInfo->firmwareVersion.major = ZPCPKCS11_VERSION_MAJOR; + pInfo->firmwareVersion.minor = ZPCPKCS11_VERSION_MINOR; + + return CKR_OK; } CK_RV C_GetTokenInfo(CK_SLOT_ID slotID, CK_TOKEN_INFO_PTR pInfo) { - (void)slotID; - (void)pInfo; - return CKR_FUNCTION_NOT_SUPPORTED; + if (pInfo == NULL) + return CKR_ARGUMENTS_BAD; + if (!api_initialized) + return CKR_CRYPTOKI_NOT_INITIALIZED; + if (slotID != PKCS11_SLOT_NUMBER) + return CKR_SLOT_ID_INVALID; + + memset(pInfo->label, ' ', sizeof(pInfo->label)); + memcpy(pInfo->label, PKCS11_TOKEN_LABEL, strlen(PKCS11_TOKEN_LABEL)); + + memset(pInfo->manufacturerID, ' ', sizeof(pInfo->manufacturerID)); + memcpy(pInfo->manufacturerID, PKCS11_MANUFACTURER, + strlen(PKCS11_MANUFACTURER)); + + memset(pInfo->model, ' ', sizeof(pInfo->model)); + memcpy(pInfo->model, PKCS11_TOKEN_MODEL, strlen(PKCS11_TOKEN_MODEL)); + + memset(pInfo->serialNumber, ' ', sizeof(pInfo->serialNumber)); + memcpy(pInfo->serialNumber, PKCS11_TOKEN_SN, strlen(PKCS11_TOKEN_SN)); + + pInfo->flags = CKF_WRITE_PROTECTED | CKF_USER_PIN_INITIALIZED | + CKF_TOKEN_INITIALIZED; + + pInfo->ulMaxSessionCount = CK_EFFECTIVELY_INFINITE; + pInfo->ulSessionCount = CK_UNAVAILABLE_INFORMATION; + pInfo->ulMaxRwSessionCount = CK_EFFECTIVELY_INFINITE; + pInfo->ulRwSessionCount = CK_UNAVAILABLE_INFORMATION; + pInfo->ulMaxPinLen = CK_EFFECTIVELY_INFINITE; + pInfo->ulMinPinLen = 0; + pInfo->ulTotalPublicMemory = CK_UNAVAILABLE_INFORMATION; + pInfo->ulFreePublicMemory = CK_UNAVAILABLE_INFORMATION; + pInfo->ulTotalPrivateMemory = CK_UNAVAILABLE_INFORMATION; + pInfo->ulFreePrivateMemory = CK_UNAVAILABLE_INFORMATION; + + pInfo->hardwareVersion.major = ZPCPKCS11_VERSION_MAJOR; + pInfo->hardwareVersion.minor = ZPCPKCS11_VERSION_MINOR; + + pInfo->firmwareVersion.major = ZPCPKCS11_VERSION_MAJOR; + pInfo->firmwareVersion.minor = ZPCPKCS11_VERSION_MINOR; + + memset(pInfo->utcTime, ' ', sizeof(pInfo->utcTime)); + + return CKR_OK; } CK_RV C_WaitForSlotEvent(CK_FLAGS flags, CK_SLOT_ID_PTR pSlot, From 1762dfcfb5514c146fe454d2f3ea99871d7a1058 Mon Sep 17 00:00:00 2001 From: Ingo Franzki Date: Mon, 4 May 2026 14:20:32 +0200 Subject: [PATCH 03/17] pkcs11: Add openssl initialization Create a dedicated OpenSSL library context and load the default, base, and zpc provider into it. The context is used for all subsequent key loading and cryptographic operations. Signed-off-by: Ingo Franzki --- CMakeLists.txt | 4 +++ src/pkcs11/openssl.c | 71 ++++++++++++++++++++++++++++++++++++++++++++ src/pkcs11/openssl.h | 10 +++++++ src/pkcs11/pkcs11.c | 10 +++++++ 4 files changed, 95 insertions(+) create mode 100644 src/pkcs11/openssl.c create mode 100644 src/pkcs11/openssl.h diff --git a/CMakeLists.txt b/CMakeLists.txt index 22fee41f..c5e79a17 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -394,6 +394,8 @@ if (${CMAKE_SYSTEM_PROCESSOR} STREQUAL s390x) set(ZPCPKCS11_SOURCES src/pkcs11/pkcs11.c + src/pkcs11/openssl.c + src/pkcs11/config.c ) add_library(zpcpkcs11 SHARED ${ZPCPKCS11_SOURCES}) @@ -403,6 +405,8 @@ set_target_properties(zpcpkcs11 C_VISIBILITY_PRESET default LINK_FLAGS "-Wl,--version-script=${CMAKE_SOURCE_DIR}/zpcpkcs11.map" ) +target_include_directories(zpcpkcs11 PRIVATE src/pkcs11 ${OPENSSL_INCLUDE_DIR}) +target_link_libraries(zpcpkcs11 PRIVATE OpenSSL::Crypto) target_compile_definitions( zpcpkcs11 PRIVATE ZPCPKCS11_VERSION_MAJOR=${ZPC_VERSION_MAJOR} diff --git a/src/pkcs11/openssl.c b/src/pkcs11/openssl.c new file mode 100644 index 00000000..46e53f31 --- /dev/null +++ b/src/pkcs11/openssl.c @@ -0,0 +1,71 @@ +// SPDX-License-Identifier: MIT +// Copyright contributors to the libzpc project +#include +#include +#include + +#include "openssl.h" + +#define DEFAULT_PROVIDER_NAME "default" +#define BASE_PROVIDER_NAME "base" +#define ZPC_PROVIDER_NAME "zpcprovider" + +static OSSL_LIB_CTX *ossl_lib_context = NULL; +static OSSL_PROVIDER *ossl_default_provider = NULL; +static OSSL_PROVIDER *ossl_base_provider = NULL; +static OSSL_PROVIDER *ossl_hbkzpc_provider = NULL; + +int openssl_init(void) +{ + OPENSSL_init_crypto(OPENSSL_INIT_LOAD_CONFIG, NULL); + + ossl_lib_context = OSSL_LIB_CTX_new(); + if (ossl_lib_context == NULL) + return 0; + + ossl_default_provider = OSSL_PROVIDER_load(ossl_lib_context, + DEFAULT_PROVIDER_NAME); + if (ossl_default_provider == NULL) { + ERR_print_errors_fp(stderr); + openssl_term(); + return 0; + } + + ossl_base_provider = OSSL_PROVIDER_load(ossl_lib_context, + BASE_PROVIDER_NAME); + if (ossl_base_provider == NULL) { + ERR_print_errors_fp(stderr); + openssl_term(); + return 0; + } + + ossl_hbkzpc_provider = OSSL_PROVIDER_load(ossl_lib_context, + ZPC_PROVIDER_NAME); + if (ossl_hbkzpc_provider == NULL) { + ERR_print_errors_fp(stderr); + openssl_term(); + return 0; + } + + return 1; +} + +void openssl_term(void) +{ + if (ossl_hbkzpc_provider != NULL) + OSSL_PROVIDER_unload(ossl_hbkzpc_provider); + ossl_hbkzpc_provider = NULL; + + if (ossl_base_provider != NULL) + OSSL_PROVIDER_unload(ossl_base_provider); + ossl_base_provider = NULL; + + if (ossl_default_provider != NULL) + OSSL_PROVIDER_unload(ossl_default_provider); + ossl_default_provider = NULL; + + if (ossl_lib_context != NULL) + OSSL_LIB_CTX_free(ossl_lib_context); + ossl_lib_context = NULL; +} + diff --git a/src/pkcs11/openssl.h b/src/pkcs11/openssl.h new file mode 100644 index 00000000..7a9a663d --- /dev/null +++ b/src/pkcs11/openssl.h @@ -0,0 +1,10 @@ +// SPDX-License-Identifier: MIT +// Copyright contributors to the libzpc project +#ifndef OPENSSL_H +#define OPENSSL_H + +int openssl_init(void); + +void openssl_term(void); + +#endif diff --git a/src/pkcs11/pkcs11.c b/src/pkcs11/pkcs11.c index ad6045eb..741d74c8 100644 --- a/src/pkcs11/pkcs11.c +++ b/src/pkcs11/pkcs11.c @@ -3,6 +3,7 @@ #include #include #include "pkcs11.h" +#include "openssl.h" #define PKCS11_MANUFACTURER "IBM" #define PKCS11_LIBRARY_DESC "ZPC PKCS#11 provider" @@ -53,10 +54,17 @@ CK_RV C_Initialize(CK_VOID_PTR pInitArgs) return CKR_CANT_LOCK; } + if (openssl_init() != 1) + goto cleanup; + pthread_once(&atfork_once, register_atfork); api_initialized = CK_TRUE; return CKR_OK; + +cleanup: + openssl_term(); + return CKR_FUNCTION_FAILED; } CK_RV C_Finalize(CK_VOID_PTR pReserved) @@ -67,6 +75,8 @@ CK_RV C_Finalize(CK_VOID_PTR pReserved) if (!api_initialized) return CKR_CRYPTOKI_NOT_INITIALIZED; + openssl_term(); + api_initialized = CK_FALSE; return CKR_OK; } From 0648d657160c59c3535ec3d8fb664e9db8564495 Mon Sep 17 00:00:00 2001 From: Ingo Franzki Date: Mon, 4 May 2026 16:05:18 +0200 Subject: [PATCH 04/17] pkcs11: Add config file parser to load key objects Add config.c which parses the PKCS#11 configuration file (default: /etc/zpcpkcs11/zpcpkcs11.conf, overridden via ZPCPKCS11_CONFIG). Each non-comment line is expected in the form '