diff --git a/CMakeLists.txt b/CMakeLists.txt
index 74e3684..9e3d58f 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -387,6 +387,63 @@ install(
     DESTINATION ${CMAKE_INSTALL_MANDIR}/man1
 )
 
+###########################################################
+# zpckcs11
+
+if (${CMAKE_SYSTEM_PROCESSOR} STREQUAL s390x)
+
+set(ZPCPKCS11_SOURCES
+    src/pkcs11/pkcs11.c
+    src/pkcs11/openssl.c
+    src/pkcs11/config.c
+    src/pkcs11/utils.c
+    src/pkcs11/object.c
+    src/pkcs11/session.c
+    src/pkcs11/signature.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_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}
+    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}
+)
+
+install(
+    FILES ${CMAKE_SOURCE_DIR}/man/zpcpkcs11.conf.5
+    DESTINATION ${CMAKE_INSTALL_MANDIR}/man5
+)
+
+install(
+    FILES ${CMAKE_SOURCE_DIR}/man/zpcpkcs11.7
+    DESTINATION ${CMAKE_INSTALL_MANDIR}/man7
+)
+
+endif() # CMAKE_SYSTEM_PROCESSOR == s390x
+
 ###########################################################
 # Test
 
diff --git a/man/zpcpkcs11.7 b/man/zpcpkcs11.7
new file mode 100644
index 0000000..2c53baf
--- /dev/null
+++ b/man/zpcpkcs11.7
@@ -0,0 +1,313 @@
+'\" t
+.\" Automatically generated by Pandoc 3.1.3
+.\"
+.\" Define V font for inline verbatim, using C font in formats
+.\" that render this, and otherwise B font.
+.ie "\f[CB]x\f[]"x" \{\
+. ftr V B
+. ftr VI BI
+. ftr VB B
+. ftr VBI BI
+.\}
+.el \{\
+. ftr V CR
+. ftr VI CI
+. ftr VB CB
+. ftr VBI CBI
+.\}
+.TH "ZPCPKCS11" "7" "2026" "LIBZPC v2" ""
+.hy
+.SH NAME
+.PP
+\f[V]zpcpkcs11\f[R] - A PKCS#11 library providing hardware-backed key
+cryptographic operations on IBM Z and IBM LinuxONE.
+.SH DESCRIPTION
+.PP
+The \f[V]zpcpkcs11\f[R] library (\f[V]zpcpkcs11.so\f[R]) is a PKCS#11
+v3.2 provider that exposes IBM Z protected-key cryptographic operations
+through the standard PKCS#11 Cryptoki API.
+It is the PKCS#11 counterpart to the \f[V]hbkzpc provider\f[R] for
+OpenSSL (hbkzpcprovider(7)), targeting applications that consume
+cryptographic services via PKCS#11 rather than OpenSSL directly.
+.PP
+The library implements the full PKCS#11 v3.2 function list.
+Functions that are not supported return
+\f[V]CKR_FUNCTION_NOT_SUPPORTED\f[R].
+See section \f[I]Supported Functions\f[R] for a complete listing.
+.SS Hardware-backed keys
+.PP
+Hardware-backed keys (\f[I]HBK\f[R]) are a generic concept where the
+secret information of cryptographic keys is never exposed to main
+memory, but cryptographic operations with such keys are still possible.
+Instead of the raw secret key information, opaque key objects are
+exposed to applications.
+The IBM Z platform uses IBM Crypto Express (\f[I]CEX\f[R]) adapters or
+the IBM Secure Execution for Linux ultravisor to securely store secret
+key material and securely export it to the firmware.
+.PP
+See hbkzpcprovider(7) for a detailed description of the protected-key
+concept and the HBKZPC URI format used to reference these keys.
+.SS Token and slot model
+.PP
+The library presents exactly one slot (slot ID \f[V]0\f[R]) containing
+one token (label \f[V]ZPC\f[R]).
+The token is permanently present, hardware-backed, and
+\f[B]read-only\f[R]: object creation, modification, and deletion are not
+supported.
+.PP
+All keys exposed by the token are loaded at initialization time from the
+configuration file.
+See zpcpkcs11.conf(5) for the configuration file format.
+.SS Session model
+.PP
+The library supports an unlimited number of concurrent read-only
+sessions (\f[V]CKF_SERIAL_SESSION\f[R]).
+Read-write sessions are accepted but behave identically to read-only
+sessions because the token is write-protected.
+Asynchronous sessions (\f[V]CKF_ASYNC_SESSION\f[R]) are not supported.
+.SS Login model
+.PP
+The library accepts \f[V]C_Login\f[R] and \f[V]C_LoginUser\f[R] with
+user type \f[V]CKU_USER\f[R].
+Login as the security officer (\f[V]CKU_SO\f[R]) or any other user type
+returns \f[V]CKR_USER_TYPE_INVALID\f[R].
+The PIN value is ignored.
+The library does not enforce login for any operation; the login state is
+maintained solely to satisfy the PKCS#11 state machine expected by
+callers.
+.PP
+PIN protection is not meaningful in this context: the protected key
+origins configured in zpcpkcs11.conf(5) are not access-restricted.
+Retrievable secrets and other protected key origins can be transformed
+into protected keys by any application via the PKEY ioctl interface,
+without any additional access control.
+.SH SUPPORTED FUNCTIONS
+.SS Implemented functions
+.PP
+The following functions are fully implemented:
+.PP
+\f[V]C_Initialize\f[R], \f[V]C_Finalize\f[R], \f[V]C_GetInfo\f[R],
+\f[V]C_GetFunctionList\f[R], \f[V]C_GetInterfaceList\f[R],
+\f[V]C_GetInterface\f[R] : Library lifecycle and introspection.
+.PP
+\f[V]C_GetSlotList\f[R], \f[V]C_GetSlotInfo\f[R],
+\f[V]C_GetTokenInfo\f[R], \f[V]C_GetMechanismList\f[R],
+\f[V]C_GetMechanismInfo\f[R] : Slot, token, and mechanism introspection.
+.PP
+\f[V]C_OpenSession\f[R], \f[V]C_CloseSession\f[R],
+\f[V]C_CloseAllSessions\f[R], \f[V]C_GetSessionInfo\f[R],
+\f[V]C_SessionCancel\f[R] : Session management.
+.TP
+\f[V]C_Login\f[R], \f[V]C_LoginUser\f[R], \f[V]C_Logout\f[R]
+Login state management (PIN is not verified; only \f[V]CKU_USER\f[R] is
+supported).
+.TP
+\f[V]C_FindObjectsInit\f[R], \f[V]C_FindObjects\f[R], \f[V]C_FindObjectsFinal\f[R]
+Object enumeration and search by template attributes.
+.TP
+\f[V]C_GetObjectSize\f[R], \f[V]C_GetAttributeValue\f[R]
+Object attribute retrieval.
+.TP
+\f[V]C_SignInit\f[R], \f[V]C_Sign\f[R], \f[V]C_SignUpdate\f[R], \f[V]C_SignFinal\f[R]
+One-shot and multi-part signing.
+.TP
+\f[V]C_VerifyInit\f[R], \f[V]C_Verify\f[R], \f[V]C_VerifyUpdate\f[R], \f[V]C_VerifyFinal\f[R]
+One-shot and multi-part signature verification.
+.PP
+\f[V]C_VerifySignatureInit\f[R], \f[V]C_VerifySignature\f[R],
+\f[V]C_VerifySignatureUpdate\f[R], \f[V]C_VerifySignatureFinal\f[R] :
+PKCS#11 v3.2 combined-signature verify operations.
+.TP
+\f[V]C_GetOperationState\f[R], \f[V]C_SetOperationState\f[R]
+Always return \f[V]CKR_STATE_UNSAVEABLE\f[R].
+.TP
+\f[V]C_GetFunctionStatus\f[R], \f[V]C_CancelFunction\f[R]
+Always return \f[V]CKR_FUNCTION_NOT_PARALLEL\f[R].
+.SS Unsupported functions
+.PP
+All functions not listed above return
+\f[V]CKR_FUNCTION_NOT_SUPPORTED\f[R] or
+\f[V]CKR_TOKEN_WRITE_PROTECTED\f[R] where applicable.
+This includes: encryption, decryption, digesting, key generation, key
+wrapping/unwrapping, key derivation, random number generation, and all
+message-based operation variants.
+.SH SUPPORTED MECHANISMS
+.PP
+The library registers the following PKCS#11 mechanisms, all supporting
+the \f[V]CKF_SIGN\f[R] and \f[V]CKF_VERIFY\f[R] flags:
+.PP
+.TS
+tab(@);
+l l.
+T{
+Mechanism
+T}@T{
+Key sizes (bits)
+T}
+_
+T{
+\f[V]CKM_ECDSA\f[R]
+T}@T{
+256 \[en] 521
+T}
+T{
+\f[V]CKM_ECDSA_SHA1\f[R]
+T}@T{
+256 \[en] 521
+T}
+T{
+\f[V]CKM_ECDSA_SHA224\f[R]
+T}@T{
+256 \[en] 521
+T}
+T{
+\f[V]CKM_ECDSA_SHA256\f[R]
+T}@T{
+256 \[en] 521
+T}
+T{
+\f[V]CKM_ECDSA_SHA384\f[R]
+T}@T{
+256 \[en] 521
+T}
+T{
+\f[V]CKM_ECDSA_SHA512\f[R]
+T}@T{
+256 \[en] 521
+T}
+T{
+\f[V]CKM_ECDSA_SHA3_224\f[R]
+T}@T{
+256 \[en] 521
+T}
+T{
+\f[V]CKM_ECDSA_SHA3_256\f[R]
+T}@T{
+256 \[en] 521
+T}
+T{
+\f[V]CKM_ECDSA_SHA3_384\f[R]
+T}@T{
+256 \[en] 521
+T}
+T{
+\f[V]CKM_ECDSA_SHA3_512\f[R]
+T}@T{
+256 \[en] 521
+T}
+T{
+\f[V]CKM_EDDSA\f[R]
+T}@T{
+255 \[en] 448
+T}
+.TE
+.PP
+All ECDSA mechanisms support \f[V]CKF_EC_OID\f[R], \f[V]CKF_EC_F_P\f[R],
+\f[V]CKF_EC_UNCOMPRESS\f[R], and \f[V]CKF_EC_COMPRESS\f[R].
+\f[V]CKM_EDDSA\f[R] supports \f[V]CKF_EC_OID\f[R], \f[V]CKF_EC_F_P\f[R],
+and \f[V]CKF_EC_COMPRESS\f[R].
+.SS Mechanism parameter restrictions
+.TP
+\f[B]\f[VB]CKM_EDDSA\f[B]\f[R]
+The \f[V]CK_EDDSA_PARAMS\f[R] structure is optional.
+If provided, the following restrictions apply; violating either returns
+\f[V]CKR_MECHANISM_PARAM_INVALID\f[R]:
+.RS
+.IP \[bu] 2
+\f[V]phFlag\f[R] must be \f[V]CK_FALSE\f[R]: pre-hash mode (HashEdDSA)
+is not supported.
+.IP \[bu] 2
+\f[V]ulContextDataLen\f[R] must be \f[V]0\f[R]: non-empty context data
+is not supported.
+.RE
+.SS Supported ECC curves
+.IP \[bu] 2
+\f[B]ECDSA\f[R]: prime256v1 (P-256), secp384r1 (P-384), secp521r1
+(P-521)
+.IP \[bu] 2
+\f[B]EdDSA\f[R]: ED25519, ED448
+.SH INITIALIZATION
+.PP
+When \f[V]C_Initialize\f[R] is called, the library loads and processes
+the configuration file (see zpcpkcs11.conf(5)), creating PKCS#11 key
+objects for each valid entry.
+If initialization fails, \f[V]CKR_FUNCTION_FAILED\f[R] is returned.
+.PP
+\f[V]C_Initialize\f[R] requires \f[V]CKF_OS_LOCKING_OK\f[R] to be set in
+the flags of the \f[V]CK_C_INITIALIZE_ARGS\f[R] structure when arguments
+are provided.
+\f[V]CKF_LIBRARY_CANT_CREATE_OS_THREADS\f[R] is not supported and causes
+\f[V]CKR_ARGUMENTS_BAD\f[R] to be returned.
+.SH USAGE
+.PP
+To use \f[V]zpcpkcs11\f[R] with a PKCS#11-aware application, configure
+the application to load \f[V]zpcpkcs11.so\f[R] as its PKCS#11 module.
+The exact configuration method depends on the application.
+.SS p11-kit
+.PP
+When using \f[V]p11-kit\f[R], create a module configuration file:
+.IP
+.nf
+\f[C]
+[p11-kit-module]
+module: /path/to/zpcpkcs11.so
+\f[R]
+.fi
+.SS p11tool
+.PP
+Keys available in the token can be enumerated using \f[V]p11tool\f[R]:
+.IP
+.nf
+\f[C]
+$ p11tool --provider /path/to/zpcpkcs11.so --list-all
+Object 0:
+    URL: pkcs11:model=ZPC;manufacturer=IBM;serial=01;token=ZPC;...
+    Type: Private Key (EC/ECDSA)
+    Label: my-signing-key
+    ...
+\f[R]
+.fi
+.SH CONFIGURATION
+.PP
+The library reads its key configuration from:
+.IP
+.nf
+\f[C]
+/etc/zpcpkcs11/zpcpkcs11.conf
+\f[R]
+.fi
+.PP
+The path can be overridden with the \f[V]ZPCPKCS11_CONFIG\f[R]
+environment variable.
+See zpcpkcs11.conf(5) for the full configuration file format.
+.SH ENVIRONMENT
+.TP
+\f[B]ZPCPKCS11_CONFIG\f[R]
+Overrides the default configuration file path.
+Ignored in privileged processes (see \f[I]secure_getenv\f[R](3)).
+.SH FILES
+.TP
+\f[V]/etc/zpcpkcs11/zpcpkcs11.conf\f[R]
+Default key configuration file.
+.TP
+\f[V]zpcpkcs11.so\f[R]
+The PKCS#11 shared library.
+.SH GLOSSARY
+.TP
+CEX
+IBM Crypto Express
+.TP
+CPACF
+CP Assist for Cryptographic Functions
+.TP
+HBK
+hardware-backed key
+.TP
+SEL
+IBM Secure Execution for Linux
+.TP
+ZPC
+IBM Z protected key cryptography
+.SH SEE ALSO
+.PP
+zpcpkcs11.conf(5), hbkzpcprovider(7), hbkzpcprovider.conf(5), zpckey(1).
diff --git a/man/zpcpkcs11.7.md b/man/zpcpkcs11.7.md
new file mode 100644
index 0000000..2287ad6
--- /dev/null
+++ b/man/zpcpkcs11.7.md
@@ -0,0 +1,229 @@
+% ZPCPKCS11(7) LIBZPC v2
+%
+% 2026
+
+# NAME
+
+`zpcpkcs11` - A PKCS#11 library providing hardware-backed key cryptographic
+operations on IBM Z and IBM LinuxONE.
+
+# DESCRIPTION
+
+The `zpcpkcs11` library (`zpcpkcs11.so`) is a PKCS#11 v3.2 provider that
+exposes IBM Z protected-key cryptographic operations through the standard
+PKCS#11 Cryptoki API. It is the PKCS#11 counterpart to the `hbkzpc provider`
+for OpenSSL (hbkzpcprovider(7)), targeting applications that consume
+cryptographic services via PKCS#11 rather than OpenSSL directly.
+
+The library implements the full PKCS#11 v3.2 function list. Functions that are
+not supported return `CKR_FUNCTION_NOT_SUPPORTED`. See section *Supported
+Functions* for a complete listing.
+
+## Hardware-backed keys
+
+Hardware-backed keys (*HBK*) are a generic concept where the secret information
+of cryptographic keys is never exposed to main memory, but cryptographic
+operations with such keys are still possible. Instead of the raw secret key
+information, opaque key objects are exposed to applications. The IBM Z platform
+uses IBM Crypto Express (*CEX*) adapters or the IBM Secure Execution for Linux
+ultravisor to securely store secret key material and securely export it to the
+firmware.
+
+See hbkzpcprovider(7) for a detailed description of the protected-key
+concept and the HBKZPC URI format used to reference these keys.
+
+## Token and slot model
+
+The library presents exactly one slot (slot ID `0`) containing one token
+(label `ZPC`). The token is permanently present, hardware-backed, and
+**read-only**: object creation, modification, and deletion are not supported.
+
+All keys exposed by the token are loaded at initialization time from the
+configuration file. See zpcpkcs11.conf(5) for the configuration file format.
+
+## Session model
+
+The library supports an unlimited number of concurrent read-only sessions
+(`CKF_SERIAL_SESSION`). Read-write sessions are accepted but behave
+identically to read-only sessions because the token is write-protected.
+Asynchronous sessions (`CKF_ASYNC_SESSION`) are not supported.
+
+## Login model
+
+The library accepts `C_Login` and `C_LoginUser` with user type `CKU_USER`.
+Login as the security officer (`CKU_SO`) or any other user type returns
+`CKR_USER_TYPE_INVALID`. The PIN value is ignored. The library does not
+enforce login for any operation; the login state is maintained solely to
+satisfy the PKCS#11 state machine expected by callers.
+
+PIN protection is not meaningful in this context: the protected key origins
+configured in zpcpkcs11.conf(5) are not access-restricted. Retrievable secrets
+and other protected key origins can be transformed into protected keys by any
+application via the PKEY ioctl interface, without any additional access control.
+
+# SUPPORTED FUNCTIONS
+
+## Implemented functions
+
+The following functions are fully implemented:
+
+`C_Initialize`, `C_Finalize`, `C_GetInfo`, `C_GetFunctionList`,
+`C_GetInterfaceList`, `C_GetInterface`
+:   Library lifecycle and introspection.
+
+`C_GetSlotList`, `C_GetSlotInfo`, `C_GetTokenInfo`, `C_GetMechanismList`,
+`C_GetMechanismInfo`
+:   Slot, token, and mechanism introspection.
+
+`C_OpenSession`, `C_CloseSession`, `C_CloseAllSessions`, `C_GetSessionInfo`,
+`C_SessionCancel`
+:   Session management.
+
+`C_Login`, `C_LoginUser`, `C_Logout`
+:   Login state management (PIN is not verified; only `CKU_USER` is supported).
+
+`C_FindObjectsInit`, `C_FindObjects`, `C_FindObjectsFinal`
+:   Object enumeration and search by template attributes.
+
+`C_GetObjectSize`, `C_GetAttributeValue`
+:   Object attribute retrieval.
+
+`C_SignInit`, `C_Sign`, `C_SignUpdate`, `C_SignFinal`
+:   One-shot and multi-part signing.
+
+`C_VerifyInit`, `C_Verify`, `C_VerifyUpdate`, `C_VerifyFinal`
+:   One-shot and multi-part signature verification.
+
+`C_VerifySignatureInit`, `C_VerifySignature`, `C_VerifySignatureUpdate`,
+`C_VerifySignatureFinal`
+:   PKCS#11 v3.2 combined-signature verify operations.
+
+`C_GetOperationState`, `C_SetOperationState`
+:   Always return `CKR_STATE_UNSAVEABLE`.
+
+`C_GetFunctionStatus`, `C_CancelFunction`
+:   Always return `CKR_FUNCTION_NOT_PARALLEL`.
+
+## Unsupported functions
+
+All functions not listed above return `CKR_FUNCTION_NOT_SUPPORTED` or
+`CKR_TOKEN_WRITE_PROTECTED` where applicable. This includes: encryption,
+decryption, digesting, key generation, key wrapping/unwrapping, key
+derivation, random number generation, and all message-based operation
+variants.
+
+# SUPPORTED MECHANISMS
+
+The library registers the following PKCS#11 mechanisms, all supporting the
+`CKF_SIGN` and `CKF_VERIFY` flags:
+
+| Mechanism | Key sizes (bits) |
+|---|---|
+| `CKM_ECDSA` | 256 – 521 |
+| `CKM_ECDSA_SHA1` | 256 – 521 |
+| `CKM_ECDSA_SHA224` | 256 – 521 |
+| `CKM_ECDSA_SHA256` | 256 – 521 |
+| `CKM_ECDSA_SHA384` | 256 – 521 |
+| `CKM_ECDSA_SHA512` | 256 – 521 |
+| `CKM_ECDSA_SHA3_224` | 256 – 521 |
+| `CKM_ECDSA_SHA3_256` | 256 – 521 |
+| `CKM_ECDSA_SHA3_384` | 256 – 521 |
+| `CKM_ECDSA_SHA3_512` | 256 – 521 |
+| `CKM_EDDSA` | 255 – 448 |
+
+All ECDSA mechanisms support `CKF_EC_OID`, `CKF_EC_F_P`,
+`CKF_EC_UNCOMPRESS`, and `CKF_EC_COMPRESS`. `CKM_EDDSA` supports
+`CKF_EC_OID`, `CKF_EC_F_P`, and `CKF_EC_COMPRESS`.
+
+## Mechanism parameter restrictions
+
+**`CKM_EDDSA`**
+:   The `CK_EDDSA_PARAMS` structure is optional. If provided, the following
+    restrictions apply; violating either returns `CKR_MECHANISM_PARAM_INVALID`:
+
+    - `phFlag` must be `CK_FALSE`: pre-hash mode (HashEdDSA) is not supported.
+    - `ulContextDataLen` must be `0`: non-empty context data is not supported.
+
+## Supported ECC curves
+
+- **ECDSA**: prime256v1 (P-256), secp384r1 (P-384), secp521r1 (P-521)
+- **EdDSA**: ED25519, ED448
+
+# INITIALIZATION
+
+When `C_Initialize` is called, the library loads and processes the
+configuration file (see zpcpkcs11.conf(5)), creating PKCS#11 key objects for
+each valid entry. If initialization fails, `CKR_FUNCTION_FAILED` is returned.
+
+`C_Initialize` requires `CKF_OS_LOCKING_OK` to be set in the flags of the
+`CK_C_INITIALIZE_ARGS` structure when arguments are provided.
+`CKF_LIBRARY_CANT_CREATE_OS_THREADS` is not supported and causes
+`CKR_ARGUMENTS_BAD` to be returned.
+
+# USAGE
+
+To use `zpcpkcs11` with a PKCS#11-aware application, configure the
+application to load `zpcpkcs11.so` as its PKCS#11 module. The exact
+configuration method depends on the application.
+
+## p11-kit
+
+When using `p11-kit`, create a module configuration file:
+
+    [p11-kit-module]
+    module: /path/to/zpcpkcs11.so
+
+## p11tool
+
+Keys available in the token can be enumerated using `p11tool`:
+
+    $ p11tool --provider /path/to/zpcpkcs11.so --list-all
+    Object 0:
+        URL: pkcs11:model=ZPC;manufacturer=IBM;serial=01;token=ZPC;...
+        Type: Private Key (EC/ECDSA)
+        Label: my-signing-key
+        ...
+
+# CONFIGURATION
+
+The library reads its key configuration from:
+
+    /etc/zpcpkcs11/zpcpkcs11.conf
+
+The path can be overridden with the `ZPCPKCS11_CONFIG` environment variable.
+See zpcpkcs11.conf(5) for the full configuration file format.
+
+# ENVIRONMENT
+
+**ZPCPKCS11_CONFIG**
+:   Overrides the default configuration file path. Ignored in privileged
+    processes (see *secure_getenv*(3)).
+
+# FILES
+
+`/etc/zpcpkcs11/zpcpkcs11.conf`
+:   Default key configuration file.
+
+`zpcpkcs11.so`
+:   The PKCS#11 shared library.
+
+# GLOSSARY
+
+CEX
+:   IBM Crypto Express
+
+CPACF
+:   CP Assist for Cryptographic Functions
+
+HBK
+:   hardware-backed key
+
+SEL
+:   IBM Secure Execution for Linux
+
+ZPC
+:   IBM Z protected key cryptography
+
+# SEE ALSO
+
+zpcpkcs11.conf(5), hbkzpcprovider(7), hbkzpcprovider.conf(5), zpckey(1).
diff --git a/man/zpcpkcs11.conf.5 b/man/zpcpkcs11.conf.5
new file mode 100644
index 0000000..ad8ec16
--- /dev/null
+++ b/man/zpcpkcs11.conf.5
@@ -0,0 +1,161 @@
+.\" Automatically generated by Pandoc 3.1.3
+.\"
+.\" Define V font for inline verbatim, using C font in formats
+.\" that render this, and otherwise B font.
+.ie "\f[CB]x\f[]"x" \{\
+. ftr V B
+. ftr VI BI
+. ftr VB B
+. ftr VBI BI
+.\}
+.el \{\
+. ftr V CR
+. ftr VI CI
+. ftr VB CB
+. ftr VBI CBI
+.\}
+.TH "ZPCPKCS11.CONF" "5" "2026" "LIBZPC v2" ""
+.hy
+.SH NAME
+.PP
+zpcpkcs11.conf - Configuration file for the \f[V]zpcpkcs11\f[R] PKCS#11
+library
+.SH DESCRIPTION
+.PP
+This page documents the format of the configuration file read by the
+\f[V]zpcpkcs11\f[R] PKCS#11 library on initialization.
+The configuration file maps PKCS#11 key labels to OpenSSL URIs that
+reference the corresponding protected-key origin files.
+Each entry becomes a PKCS#11 object accessible to applications that load
+\f[V]zpcpkcs11.so\f[R] as their PKCS#11 provider.
+.SH FILE LOCATION
+.PP
+The default configuration file path is:
+.IP
+.nf
+\f[C]
+/etc/zpcpkcs11/zpcpkcs11.conf
+\f[R]
+.fi
+.PP
+The path can be overridden by setting the environment variable
+\f[B]ZPCPKCS11_CONFIG\f[R] to an alternative file path.
+The environment variable is read using \f[I]secure_getenv\f[R](3), so it
+is ignored in set-user-ID and set-group-ID programs.
+.SH FILE FORMAT
+.PP
+The configuration file is a plain-text file.
+Each non-empty, non-comment line specifies one key entry with the
+following syntax:
+.IP
+.nf
+\f[C]
+<label>=<uri>
+\f[R]
+.fi
+.TP
+\f[I]label\f[R]
+An arbitrary string that identifies the key.
+It is used as the PKCS#11 \f[I]CKA_LABEL\f[R] attribute of the resulting
+key objects.
+The label must not contain \f[V]=\f[R], space, or newline characters.
+.TP
+\f[I]uri\f[R]
+An OpenSSL URI that references the key material.
+The URI is passed to the OpenSSL store loader
+(\f[I]OSSL_STORE_open_ex\f[R](3ossl)).
+Supported URI schemes depend on the configured OpenSSL store loaders;
+the most common forms are:
+.RS
+.IP \[bu] 2
+A plain file path (e.g.\ \f[V]/path/to/mykey.pem\f[R]).
+.IP \[bu] 2
+A \f[V]file:\f[R] URI (e.g.\ \f[V]file:///path/to/mykey.pem\f[R]).
+.IP \[bu] 2
+An \f[V]hbkzpc:\f[R] URI as described in hbkzpcprovider(7).
+.PP
+The referenced object may be a protected-key origin private key (or
+keypair), a clear private key PEM file, or a public-key-only PEM file.
+When a private key or keypair is loaded, both a private-key object and
+(if public material is present) a public-key object are created.
+When a public-key-only PEM file is loaded, only a public-key object is
+created.
+Keys with unsupported algorithms are skipped with a diagnostic message
+written to \f[I]stderr\f[R].
+.RE
+.PP
+\f[B]Comment lines\f[R] start with \f[V]#\f[R] in the first column and
+are ignored.
+.PP
+\f[B]Blank lines\f[R] (empty or containing only a newline) are ignored.
+.PP
+Any line that does not match the \f[V]<label>=<uri>\f[R] syntax is
+treated as a syntax error.
+Processing stops at the first syntax error and \f[V]C_Initialize\f[R](3)
+returns \f[V]CKR_FUNCTION_FAILED\f[R].
+.SH SUPPORTED KEY TYPES
+.PP
+The library loads EC and Edwards-curve keys.
+Depending on the type of key material referenced by the URI, it creates
+private-key objects, public-key objects, or both (see \f[I]PKCS#11
+OBJECTS\f[R] below).
+The following algorithms are supported:
+.IP \[bu] 2
+\f[B]ECDSA\f[R]: prime256v1 (P-256), secp384r1 (P-384), secp521r1
+(P-521)
+.IP \[bu] 2
+\f[B]EdDSA\f[R]: ED25519, ED448
+.PP
+Keys of any other type produce an error message on \f[I]stderr\f[R] and
+are skipped; the remaining entries in the configuration file continue to
+be processed.
+.SH PKCS#11 OBJECTS
+.PP
+For each successfully loaded key, the library creates one or two PKCS#11
+objects in the single token provided by \f[V]zpcpkcs11\f[R], depending
+on the type of key material referenced by the URI:
+.IP \[bu] 2
+A \f[B]private key\f[R] object (\f[V]CKO_PRIVATE_KEY\f[R]): created when
+the URI references a private key or keypair (e.g.\ an \f[V]hbkzpc:\f[R]
+URI or a clear private-key PEM file).
+.IP \[bu] 2
+A \f[B]public key\f[R] object (\f[V]CKO_PUBLIC_KEY\f[R]): created when
+public-key material is available (i.e.\ always for public-key-only PEM
+files, and for private-key PEM files or \f[V]hbkzpc:\f[R] URIs that
+include the public portion).
+.PP
+Both objects share the same \f[V]CKA_LABEL\f[R] (the \f[I]label\f[R]
+from the config entry) and the same \f[V]CKA_ID\f[R] (derived from the
+line number of the entry in the configuration file).
+.PP
+The token is read-only: \f[V]C_CreateObject\f[R],
+\f[V]C_CopyObject\f[R], \f[V]C_DestroyObject\f[R], and
+\f[V]C_SetAttributeValue\f[R] all return
+\f[V]CKR_TOKEN_WRITE_PROTECTED\f[R].
+.SH EXAMPLES
+.PP
+A minimal configuration file with two keys:
+.IP
+.nf
+\f[C]
+# Signing key for service A
+service-a-key = /etc/zpcpkcs11/keys/service-a.pem
+
+# Signing key for service B (using an hbkzpc URI)
+service-b-key = hbkzpc:origin-type=uv;origin-alg=1.2.840.10045.3.1.7;origin-blob=0102...
+\f[R]
+.fi
+.SH ENVIRONMENT
+.TP
+\f[B]ZPCPKCS11_CONFIG\f[R]
+If set, overrides the default configuration file path
+\f[V]/etc/zpcpkcs11/zpcpkcs11.conf\f[R].
+Ignored in privileged processes (see \f[I]secure_getenv\f[R](3)).
+.SH FILES
+.TP
+\f[V]/etc/zpcpkcs11/zpcpkcs11.conf\f[R]
+Default configuration file.
+.SH SEE ALSO
+.PP
+hbkzpcprovider(7), hbkzpcprovider.conf(5), zpckey(1),
+\f[I]secure_getenv\f[R](3), \f[I]OSSL_STORE_open_ex\f[R](3ossl).
diff --git a/man/zpcpkcs11.conf.5.md b/man/zpcpkcs11.conf.5.md
new file mode 100644
index 0000000..de1e263
--- /dev/null
+++ b/man/zpcpkcs11.conf.5.md
@@ -0,0 +1,122 @@
+% ZPCPKCS11.CONF(5) LIBZPC v2
+%
+% 2026
+
+# NAME
+
+zpcpkcs11.conf - Configuration file for the `zpcpkcs11` PKCS#11 library
+
+# DESCRIPTION
+
+This page documents the format of the configuration file read by the
+`zpcpkcs11` PKCS#11 library on initialization. The configuration file maps
+PKCS#11 key labels to OpenSSL URIs that reference the corresponding
+protected-key origin files. Each entry becomes a PKCS#11 object accessible to
+applications that load `zpcpkcs11.so` as their PKCS#11 provider.
+
+# FILE LOCATION
+
+The default configuration file path is:
+
+    /etc/zpcpkcs11/zpcpkcs11.conf
+
+The path can be overridden by setting the environment variable
+**ZPCPKCS11_CONFIG** to an alternative file path. The environment variable is
+read using *secure_getenv*(3), so it is ignored in set-user-ID and
+set-group-ID programs.
+
+# FILE FORMAT
+
+The configuration file is a plain-text file. Each non-empty, non-comment line
+specifies one key entry with the following syntax:
+
+    <label>=<uri>
+
+*label*
+:   An arbitrary string that identifies the key. It is used as the PKCS#11
+    *CKA_LABEL* attribute of the resulting key objects. The label must not
+    contain `=`, space, or newline characters.
+
+*uri*
+:   An OpenSSL URI that references the key material. The URI is passed to the
+    OpenSSL store loader (*OSSL_STORE_open_ex*(3ossl)). Supported URI schemes
+    depend on the configured OpenSSL store loaders; the most common forms are:
+
+    - A plain file path (e.g. `/path/to/mykey.pem`).
+    - A `file:` URI (e.g. `file:///path/to/mykey.pem`).
+    - An `hbkzpc:` URI as described in hbkzpcprovider(7).
+
+    The referenced object may be a protected-key origin private key (or keypair), a clear private
+    key PEM file, or a public-key-only PEM file. When a private key or keypair
+    is loaded, both a private-key object and (if public material is present) a
+    public-key object are created. When a public-key-only PEM file is loaded,
+    only a public-key object is created. Keys with unsupported algorithms are
+    skipped with a diagnostic message written to *stderr*.
+
+**Comment lines** start with `#` in the first column and are ignored.
+
+**Blank lines** (empty or containing only a newline) are ignored.
+
+Any line that does not match the `<label>=<uri>` syntax is treated as a
+syntax error. Processing stops at the first syntax error and
+`C_Initialize`(3) returns `CKR_FUNCTION_FAILED`.
+
+# SUPPORTED KEY TYPES
+
+The library loads EC and Edwards-curve keys. Depending on the type of key
+material referenced by the URI, it creates private-key objects, public-key
+objects, or both (see *PKCS#11 OBJECTS* below). The following algorithms are
+supported:
+
+- **ECDSA**: prime256v1 (P-256), secp384r1 (P-384), secp521r1 (P-521)
+- **EdDSA**: ED25519, ED448
+
+Keys of any other type produce an error message on *stderr* and are skipped;
+the remaining entries in the configuration file continue to be processed.
+
+# PKCS#11 OBJECTS
+
+For each successfully loaded key, the library creates one or two PKCS#11
+objects in the single token provided by `zpcpkcs11`, depending on the type of
+key material referenced by the URI:
+
+- A **private key** object (`CKO_PRIVATE_KEY`): created when the URI
+  references a private key or keypair (e.g. an `hbkzpc:` URI or a clear
+  private-key PEM file).
+- A **public key** object (`CKO_PUBLIC_KEY`): created when public-key material
+  is available (i.e. always for public-key-only PEM files, and for private-key
+  PEM files or `hbkzpc:` URIs that include the public portion).
+
+Both objects share the same `CKA_LABEL` (the *label* from the config entry)
+and the same `CKA_ID` (derived from the line number of the entry in the
+configuration file).
+
+The token is read-only: `C_CreateObject`, `C_CopyObject`, `C_DestroyObject`,
+and `C_SetAttributeValue` all return `CKR_TOKEN_WRITE_PROTECTED`.
+
+# EXAMPLES
+
+A minimal configuration file with two keys:
+
+    # Signing key for service A
+    service-a-key = /etc/zpcpkcs11/keys/service-a.pem
+
+    # Signing key for service B (using an hbkzpc URI)
+    service-b-key = hbkzpc:origin-type=uv;origin-alg=1.2.840.10045.3.1.7;origin-blob=0102...
+
+# ENVIRONMENT
+
+**ZPCPKCS11_CONFIG**
+:   If set, overrides the default configuration file path
+    `/etc/zpcpkcs11/zpcpkcs11.conf`. Ignored in privileged processes (see
+    *secure_getenv*(3)).
+
+# FILES
+
+`/etc/zpcpkcs11/zpcpkcs11.conf`
+:   Default configuration file.
+
+# SEE ALSO
+
+hbkzpcprovider(7), hbkzpcprovider.conf(5), zpckey(1), *secure_getenv*(3),
+*OSSL_STORE_open_ex*(3ossl).
diff --git a/src/pkcs11/config.c b/src/pkcs11/config.c
new file mode 100644
index 0000000..25e7061
--- /dev/null
+++ b/src/pkcs11/config.c
@@ -0,0 +1,60 @@
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the libzpc project
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+
+#include "config.h"
+
+#define CONFIG_FILE_NAME "/etc/zpcpkcs11/zpcpkcs11.conf"
+#define CONFIG_ENV_VAR "ZPCPKCS11_CONFIG"
+
+int config_process(int (*cb)(const char *label, const char *uri,
+			     size_t lineno))
+{
+	FILE *fp;
+	int rc = 1;
+	char *line = NULL;
+	size_t size = 0, lineno = 0;
+	ssize_t nread;
+	char *label, *uri, *saveptr;
+	const char *config_filename;
+
+	config_filename = secure_getenv(CONFIG_ENV_VAR);
+	if (config_filename == NULL)
+		config_filename = CONFIG_FILE_NAME;
+
+	fp = fopen(config_filename, "r");
+	if (fp == NULL) {
+		fprintf(stderr,
+			"zpcpkcs11: Failed to read config file '%s': %s",
+			 config_filename, strerror(errno));
+		return 0;
+	}
+
+	while ((nread = getline(&line, &size, fp)) != -1) {
+		lineno++;
+
+		if (line[0] == '#' || line[0] == '\0' || line[0] == '\n')
+			continue;
+
+		label = strtok_r(line, "= ", &saveptr);
+		uri = strtok_r(NULL, "\n ", &saveptr);
+		if (label == NULL || uri == NULL ||
+		    strtok_r(NULL, "\n ", &saveptr) != NULL) {
+			fprintf(stderr, "zpcpkcs11: Syntax error in '%s' line "
+				"%zu: expected '<label>=<uri>.\n",
+				config_filename, lineno);
+			rc = 0;
+			break;
+		}
+
+		if (cb != NULL && cb(label, uri, lineno) != 1)
+			fprintf(stderr, "zpcpkcs11: Failed to add key '%s'"
+				" in line %zu\n", label, lineno);
+	}
+
+	free(line);
+	fclose(fp);
+	return rc;
+}
diff --git a/src/pkcs11/config.h b/src/pkcs11/config.h
new file mode 100644
index 0000000..31b3330
--- /dev/null
+++ b/src/pkcs11/config.h
@@ -0,0 +1,11 @@
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the libzpc project
+#ifndef CONFIG_H
+#define CONFIG_H
+
+#include <stdio.h>
+
+int config_process(int (*cb)(const char *label, const char *uri,
+			     size_t lineno));
+
+#endif
diff --git a/src/pkcs11/object.c b/src/pkcs11/object.c
new file mode 100644
index 0000000..cc96662
--- /dev/null
+++ b/src/pkcs11/object.c
@@ -0,0 +1,487 @@
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the libzpc project
+#include <stddef.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include "object.h"
+#include "utils.h"
+
+static CK_BBOOL ck_true = CK_TRUE;
+static CK_BBOOL ck_false = CK_FALSE;
+
+/*
+ * The object list is populated exclusively during C_Initialize and torn down
+ * during C_Finalize. Both are single-threaded by the PKCS#11 spec. After
+ * C_Initialize returns the list is read-only, so no locking is needed for
+ * concurrent read access from multiple threads.
+ */
+static struct dyn_array objects;
+static object_id_t object_id_counter = 0;
+
+static int object_add_attr(struct pkcs11_object *obj, CK_ATTRIBUTE_TYPE type,
+			   CK_VOID_PTR value, CK_ULONG len)
+{
+	if (obj == NULL)
+		return 0;
+
+	if (obj->num_attrs >= MAX_ATTRIBUTES)
+		return 0;
+
+	obj->attrs[obj->num_attrs].type = type;
+	obj->attrs[obj->num_attrs].pValue = value;
+	obj->attrs[obj->num_attrs].ulValueLen = len;
+	obj->num_attrs++;
+
+	return 1;
+}
+
+static int object_add_ulong_attr(struct pkcs11_object *obj,
+				 CK_ATTRIBUTE_TYPE type, CK_ULONG *val)
+{
+	return object_add_attr(obj, type, val, sizeof(*val));
+}
+
+static int object_add_bool_attr(struct pkcs11_object *obj,
+				CK_ATTRIBUTE_TYPE type, CK_BBOOL *val)
+{
+	return object_add_attr(obj, type, val, sizeof(*val));
+}
+
+static int object_setup_public_key_default_attrs(struct pkcs11_object *obj)
+{
+	if (obj == NULL)
+		return 0;
+
+	/* Public key object attributes */
+	if (!object_add_attr(obj, CKA_SUBJECT, NULL, 0))
+		return 0;
+	if (!object_add_bool_attr(obj, CKA_ENCRYPT, &ck_false))
+		return 0;
+	if (!object_add_bool_attr(obj, CKA_VERIFY, &ck_true))
+		return 0;
+	if (!object_add_bool_attr(obj, CKA_VERIFY_RECOVER, &ck_false))
+		return 0;
+	if (!object_add_bool_attr(obj, CKA_WRAP, &ck_false))
+		return 0;
+	if (!object_add_bool_attr(obj, CKA_ENCAPSULATE, &ck_false))
+		return 0;
+	if (!object_add_bool_attr(obj, CKA_TRUSTED, &ck_false))
+		return 0;
+	if (!object_add_attr(obj, CKA_WRAP_TEMPLATE, NULL, 0))
+		return 0;
+
+	return 1;
+}
+
+static int object_setup_private_key_default_attrs(struct pkcs11_object *obj)
+{
+	if (obj == NULL)
+		return 0;
+
+	/* Private key object attributes */
+	if (!object_add_attr(obj, CKA_SUBJECT, NULL, 0))
+		return 0;
+	if (!object_add_bool_attr(obj, CKA_SENSITIVE, &ck_true))
+		return 0;
+	if (!object_add_bool_attr(obj, CKA_ALWAYS_SENSITIVE, &ck_true))
+		return 0;
+	if (!object_add_bool_attr(obj, CKA_EXTRACTABLE, &ck_false))
+		return 0;
+	if (!object_add_bool_attr(obj, CKA_NEVER_EXTRACTABLE, &ck_true))
+		return 0;
+	if (!object_add_bool_attr(obj, CKA_DECRYPT, &ck_false))
+		return 0;
+	if (!object_add_bool_attr(obj, CKA_SIGN, &ck_true))
+		return 0;
+	if (!object_add_bool_attr(obj, CKA_SIGN_RECOVER, &ck_false))
+		return 0;
+	if (!object_add_bool_attr(obj, CKA_UNWRAP, &ck_false))
+		return 0;
+	if (!object_add_bool_attr(obj, CKA_DECAPSULATE, &ck_false))
+		return 0;
+	if (!object_add_bool_attr(obj, CKA_WRAP_WITH_TRUSTED, &ck_false))
+		return 0;
+	if (!object_add_bool_attr(obj, CKA_ALWAYS_AUTHENTICATE, &ck_false))
+		return 0;
+	if (!object_add_attr(obj, CKA_UNWRAP_TEMPLATE, NULL, 0))
+		return 0;
+	if (!object_add_attr(obj, CKA_DERIVE_TEMPLATE, NULL, 0))
+		return 0;
+
+	return 1;
+}
+
+static int object_setup_default_attrs(struct pkcs11_object *obj)
+{
+	if (obj == NULL)
+		return 0;
+
+	/* Common object attributes */
+	if (!object_add_ulong_attr(obj, CKA_CLASS, &obj->class))
+		return 0;
+
+	/* Storage object attributes */
+	if (!object_add_bool_attr(obj, CKA_TOKEN, &ck_true))
+		return 0;
+	if (!object_add_bool_attr(obj, CKA_PRIVATE, &ck_false))
+		return 0;
+	if (!object_add_bool_attr(obj, CKA_MODIFIABLE, &ck_false))
+		return 0;
+	if (!object_add_bool_attr(obj, CKA_COPYABLE, &ck_false))
+		return 0;
+	if (!object_add_bool_attr(obj, CKA_DESTROYABLE, &ck_false))
+		return 0;
+	if (!object_add_attr(obj, CKA_LABEL, (void *)obj->label,
+			     strlen(obj->label)))
+		return 0;
+	snprintf(obj->unique_id, sizeof(obj->unique_id), "%0*lx",
+		 (int)(sizeof(object_id_t) * 2),
+		 __atomic_add_fetch(&object_id_counter, 1, __ATOMIC_RELAXED));
+	if (!object_add_attr(obj, CKA_UNIQUE_ID, obj->unique_id,
+			     sizeof(obj->unique_id) - 1))
+		return 0;
+
+	/* Key object attributes */
+	if (!object_add_ulong_attr(obj, CKA_KEY_TYPE, &obj->keytype))
+		return 0;
+	if (!object_add_attr(obj, CKA_ID, &obj->id, sizeof(obj->id)))
+		return 0;
+	if (!object_add_attr(obj, CKA_START_DATE, NULL, 0))
+		return 0;
+	if (!object_add_attr(obj, CKA_END_DATE, NULL, 0))
+		return 0;
+	if (!object_add_bool_attr(obj, CKA_LOCAL, &ck_true))
+		return 0;
+	if (!object_add_bool_attr(obj, CKA_DERIVE, &ck_false))
+		return 0;
+
+	if (obj->class == CKO_PUBLIC_KEY &&
+	    !object_setup_public_key_default_attrs(obj))
+		return 0;
+	if (obj->class == CKO_PRIVATE_KEY &&
+	    !object_setup_private_key_default_attrs(obj))
+		return 0;
+
+	return 1;
+}
+
+int object_init(struct pkcs11_object **obj, const char *label, CK_ULONG id,
+		CK_OBJECT_CLASS class, CK_KEY_TYPE keytype)
+{
+	struct pkcs11_object *o;
+
+	if (obj == NULL || label == NULL)
+		return 0;
+
+	o = calloc(1, sizeof(*o));
+	if (o == NULL)
+		return 0;
+
+	o->class = class;
+
+	o->label = strdup(label);
+	if (o->label == NULL)
+		goto err;
+
+	o->keytype = keytype;
+	o->id = id;
+
+	if (object_setup_default_attrs(o) != 1)
+		goto err;
+
+	*obj = o;
+	return 1;
+
+err:
+	object_free(o);
+	return 0;
+}
+
+static CK_ATTRIBUTE *object_find_attr(struct pkcs11_object *obj,
+				      CK_ATTRIBUTE_TYPE type)
+{
+	CK_ULONG i;
+
+	for (i = 0; i < obj->num_attrs; i++) {
+		if (obj->attrs[i].type == type)
+			return &obj->attrs[i];
+	}
+
+	return NULL;
+}
+
+int object_get_size(struct pkcs11_object *obj, CK_ULONG *obj_size)
+{
+	CK_ULONG i, size = 0, attr_size;
+
+	if (obj == NULL || obj_size == NULL)
+		return 0;
+
+	for (i = 0; i < obj->num_attrs; i++) {
+		attr_size = (CK_ULONG)sizeof(CK_ATTRIBUTE) + obj->attrs[i].ulValueLen;
+		if (attr_size < obj->attrs[i].ulValueLen)
+			return 0;
+		if (size + attr_size < size)
+			return 0;
+		size += attr_size;
+	}
+
+	*obj_size = size;
+
+	return 1;
+}
+
+CK_RV object_get_attributes(struct pkcs11_object *obj, CK_ATTRIBUTE_PTR pTemplate,
+			   CK_ULONG ulCount)
+{
+	CK_ULONG i;
+	CK_RV rc = CKR_OK;
+	CK_ATTRIBUTE *attr;
+
+	if (obj == NULL || (pTemplate == NULL && ulCount != 0))
+		return CKR_ARGUMENTS_BAD;
+
+	for (i = 0; i < ulCount; i++) {
+		attr = object_find_attr(obj, pTemplate[i].type);
+		if (attr == NULL) {
+			pTemplate[i].ulValueLen = CK_UNAVAILABLE_INFORMATION;
+			rc = CKR_ATTRIBUTE_TYPE_INVALID;
+			continue;
+		}
+
+		if (pTemplate[i].type == CKA_VALUE &&
+		    obj->class == CKO_PRIVATE_KEY) {
+			pTemplate[i].ulValueLen = CK_UNAVAILABLE_INFORMATION;
+			rc = CKR_ATTRIBUTE_SENSITIVE;
+			continue;
+		}
+
+		if (pTemplate[i].pValue == NULL) {
+			pTemplate[i].ulValueLen = attr->ulValueLen;
+			continue;
+		}
+
+		if (pTemplate[i].ulValueLen < attr->ulValueLen) {
+			pTemplate[i].ulValueLen = CK_UNAVAILABLE_INFORMATION;
+			rc = CKR_BUFFER_TOO_SMALL;
+			continue;
+		}
+
+		memcpy(pTemplate[i].pValue, attr->pValue, attr->ulValueLen);
+		pTemplate[i].ulValueLen = attr->ulValueLen;
+	}
+
+	return rc;
+}
+
+void object_free(struct pkcs11_object *obj)
+{
+	if (obj == NULL)
+		return;
+
+	if (obj->label != NULL)
+		free((void *)obj->label);
+
+	if (obj->keytype == CKK_EC || obj->keytype == CKK_EC_EDWARDS) {
+		if (obj->data.ec_ed.ec_params != NULL)
+			free(obj->data.ec_ed.ec_params);
+		if (obj->data.ec_ed.ec_point != NULL)
+			free(obj->data.ec_ed.ec_point);
+		if (obj->data.ec_ed.spki != NULL)
+			free(obj->data.ec_ed.spki);
+		if (obj->data.ec_ed.pkey != NULL)
+			EVP_PKEY_free(obj->data.ec_ed.pkey);
+	}
+
+	free(obj);
+}
+
+int object_list_init(void)
+{
+	if (!dyn_array_init(&objects))
+		return 0;
+
+	return 1;
+}
+
+void object_list_term(void)
+{
+	struct pkcs11_object *obj;
+	size_t i;
+
+	for (i = 0; i < dyn_array_size(&objects); i++) {
+		if (!dyn_array_get(&objects, i, (void **)&obj))
+			break;
+		if (obj != NULL)
+			object_free(obj);
+	}
+
+	dyn_array_free(&objects);
+}
+
+
+int object_add_ec_ed_private_key(const char *label, CK_ULONG id,
+				 CK_KEY_TYPE keytype,
+				 const unsigned char *ec_params,
+				 size_t ec_params_len,
+				 const unsigned char *spki, size_t spki_len,
+				 size_t prime_len,
+				 EVP_PKEY *pkey)
+{
+	struct pkcs11_object *obj = NULL;
+	size_t index;
+
+	if (!object_init(&obj, label, id, CKO_PRIVATE_KEY, keytype))
+		goto err;
+
+	obj->data.ec_ed.ec_params = memdup(ec_params, ec_params_len);
+	obj->data.ec_ed.ec_params_len = ec_params_len;
+	if (obj->data.ec_ed.ec_params == NULL)
+		goto err;
+	obj->data.ec_ed.spki = memdup(spki, spki_len);
+	obj->data.ec_ed.spki_len = spki_len;
+	if (obj->data.ec_ed.spki == NULL && obj->data.ec_ed.spki_len != 0)
+		goto err;
+	obj->data.ec_ed.prime_len = prime_len;
+
+	if (!object_add_attr(obj, CKA_EC_PARAMS, obj->data.ec_ed.ec_params,
+			     obj->data.ec_ed.ec_params_len))
+		goto err;
+	if (!object_add_attr(obj, CKA_VALUE, NULL, 0))
+		goto err;
+	if (!object_add_attr(obj, CKA_PUBLIC_KEY_INFO, obj->data.ec_ed.spki,
+			     obj->data.ec_ed.spki_len))
+		goto err;
+
+	if (!EVP_PKEY_up_ref(pkey))
+		goto err;
+	obj->data.ec_ed.pkey = pkey;
+
+	if (!dyn_array_add(&objects, obj, &index))
+		goto err;
+
+	obj->handle = index + 1; /* zero handle = invalid */
+
+	return 1;
+
+err:
+	object_free(obj);
+	return 0;
+}
+
+int object_add_ec_ed_public_key(const char *label, CK_ULONG id,
+				CK_KEY_TYPE keytype,
+				const unsigned char *ec_params,
+				size_t ec_params_len,
+				const unsigned char *ec_point,
+				size_t ec_point_len,
+				const unsigned char *spki, size_t spki_len,
+				size_t prime_len,
+				EVP_PKEY *pkey)
+{
+	struct pkcs11_object *obj = NULL;
+	size_t index;
+
+	if (!object_init(&obj, label, id, CKO_PUBLIC_KEY, keytype))
+		goto err;
+
+	obj->data.ec_ed.ec_params = memdup(ec_params, ec_params_len);
+	obj->data.ec_ed.ec_params_len = ec_params_len;
+	if (obj->data.ec_ed.ec_params == NULL)
+		goto err;
+	obj->data.ec_ed.ec_point = memdup(ec_point, ec_point_len);
+	obj->data.ec_ed.ec_point_len = ec_point_len;
+	if (obj->data.ec_ed.ec_point == NULL)
+		goto err;
+	obj->data.ec_ed.spki = memdup(spki, spki_len);
+	obj->data.ec_ed.spki_len = spki_len;
+	if (obj->data.ec_ed.spki == NULL && obj->data.ec_ed.spki_len != 0)
+		goto err;
+	obj->data.ec_ed.prime_len = prime_len;
+
+	if (!object_add_attr(obj, CKA_EC_PARAMS, obj->data.ec_ed.ec_params,
+			     obj->data.ec_ed.ec_params_len))
+		goto err;
+	if (!object_add_attr(obj, CKA_EC_POINT, obj->data.ec_ed.ec_point,
+			     obj->data.ec_ed.ec_point_len))
+		goto err;
+	if (!object_add_attr(obj, CKA_PUBLIC_KEY_INFO, obj->data.ec_ed.spki,
+			     obj->data.ec_ed.spki_len))
+		goto err;
+
+	if (!EVP_PKEY_up_ref(pkey))
+		goto err;
+	obj->data.ec_ed.pkey = pkey;
+
+	if (!dyn_array_add(&objects, obj, &index))
+		goto err;
+
+	obj->handle = index + 1; /* zero handle = invalid */
+
+	return 1;
+
+err:
+	object_free(obj);
+	return 0;
+}
+
+static int object_match_attrs(CK_ATTRIBUTE *pTemplate, CK_ULONG ulCount,
+			      struct pkcs11_object *obj)
+{
+	CK_ULONG i;
+	CK_ATTRIBUTE *attr;
+
+	for (i = 0; i < ulCount; i++) {
+		attr = object_find_attr(obj, pTemplate[i].type);
+		if (attr == NULL)
+			return 0;
+		if (attr->ulValueLen != pTemplate[i].ulValueLen)
+			return 0;
+		if (attr->ulValueLen == 0)
+			continue;
+		if (attr->pValue == NULL || pTemplate[i].pValue == NULL)
+			return 0;
+		if (memcmp(attr->pValue, pTemplate[i].pValue,
+			   attr->ulValueLen) != 0)
+			return 0;
+	}
+
+	return 1;
+}
+
+int object_list_find(CK_ATTRIBUTE *pTemplate, CK_ULONG ulCount,
+		     struct dyn_array *result)
+{
+	struct pkcs11_object *obj;
+	size_t i;
+
+	for (i = 0; i < dyn_array_size(&objects); i++) {
+		if (!dyn_array_get(&objects, i, (void **)&obj))
+			break;
+		if (obj == NULL)
+			continue;
+
+		if (!object_match_attrs(pTemplate, ulCount, obj))
+			continue;
+
+		if (!dyn_array_add(result, obj, NULL))
+			return 0;
+	}
+
+	return 1;
+}
+
+int object_list_get(CK_OBJECT_HANDLE handle, struct pkcs11_object **obj)
+{
+	if (handle == CK_INVALID_HANDLE)
+		return 0;
+
+	if (!dyn_array_get(&objects, handle - 1, (void **)obj))
+		return 0;
+
+	if (*obj == NULL)
+		return 0;
+
+	return 1;
+}
diff --git a/src/pkcs11/object.h b/src/pkcs11/object.h
new file mode 100644
index 0000000..e3b017b
--- /dev/null
+++ b/src/pkcs11/object.h
@@ -0,0 +1,71 @@
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the libzpc project
+#ifndef OBJECT_H
+#define OBJECT_H
+
+#include <openssl/evp.h>
+#include "pkcs11.h"
+#include "utils.h"
+
+#define MAX_ATTRIBUTES	64
+
+typedef unsigned long object_id_t;
+
+struct pkcs11_object {
+	CK_OBJECT_HANDLE handle;
+	CK_OBJECT_CLASS class;
+	const char *label;
+	char unique_id[sizeof(object_id_t) * 2 + 1];
+	CK_KEY_TYPE keytype;
+	CK_ULONG id;
+
+	CK_ATTRIBUTE attrs[MAX_ATTRIBUTES];
+	CK_ULONG num_attrs;
+
+	union {
+		struct {
+			unsigned char *ec_params;
+			size_t ec_params_len;
+			unsigned char *ec_point;
+			size_t ec_point_len;
+			unsigned char *spki;
+			size_t spki_len;
+			size_t prime_len;
+			EVP_PKEY *pkey;
+		} ec_ed;
+	} data;
+};
+
+int object_init(struct pkcs11_object **obj, const char *label, CK_ULONG id,
+		CK_OBJECT_CLASS class, CK_KEY_TYPE keytype);
+int object_get_size(struct pkcs11_object *obj, CK_ULONG *obj_size);
+CK_RV object_get_attributes(struct pkcs11_object *obj, CK_ATTRIBUTE_PTR pTemplate,
+			   CK_ULONG ulCount);
+void object_free(struct pkcs11_object *obj);
+
+int object_list_init(void);
+void object_list_term(void);
+
+int object_add_ec_ed_private_key(const char *label, CK_ULONG id,
+				 CK_KEY_TYPE keytype,
+				 const unsigned char *ec_params,
+				 size_t ec_params_len,
+				 const unsigned char *spki, size_t spki_len,
+				 size_t prime_len,
+				 EVP_PKEY *pkey);
+int object_add_ec_ed_public_key(const char *label, CK_ULONG id,
+				CK_KEY_TYPE keytype,
+				const unsigned char *ec_params,
+				size_t ec_params_len,
+				const unsigned char *ec_point,
+				size_t ec_point_len,
+				const unsigned char *spki, size_t spki_len,
+				size_t prime_len,
+				EVP_PKEY *pkey);
+
+int object_list_find(CK_ATTRIBUTE *pTemplate, CK_ULONG ulCount,
+		     struct dyn_array *result);
+
+int object_list_get(CK_OBJECT_HANDLE handle, struct pkcs11_object **obj);
+
+#endif
diff --git a/src/pkcs11/openssl.c b/src/pkcs11/openssl.c
new file mode 100644
index 0000000..7d5e36e
--- /dev/null
+++ b/src/pkcs11/openssl.c
@@ -0,0 +1,360 @@
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the libzpc project
+#include <stdbool.h>
+
+#include <openssl/crypto.h>
+#include <openssl/provider.h>
+#include <openssl/err.h>
+#include <openssl/store.h>
+#include <openssl/core_names.h>
+
+#include "openssl.h"
+#include "object.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;
+
+static const unsigned char oid_p256[] = {
+	0x06, 0x08, 0x2A, 0x86, 0x48, 0xCE, 0x3D, 0x03, 0x01, 0x07
+};
+
+static const unsigned char oid_p384[] = {
+	0x06, 0x05, 0x2B, 0x81, 0x04, 0x00, 0x22
+};
+
+static const unsigned char oid_p521[] = {
+	0x06, 0x05, 0x2B, 0x81, 0x04, 0x00, 0x23
+};
+
+static const unsigned char oid_ed25519[] = {
+	0x06, 0x03, 0x2B, 0x65, 0x70
+};
+
+static const unsigned char oid_ed448[] = {
+	0x06, 0x03, 0x2B, 0x65, 0x71
+};
+
+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;
+}
+
+static int openssl_process_ec_key(const char *label, EVP_PKEY *pkey,
+				  size_t lineno, bool keypair)
+{
+	char group[200] = { 0 };
+	const unsigned char *ec_params = NULL;
+	size_t ec_params_len = 0;
+	unsigned char point[200] = { 0 };
+	size_t ec_point_len = 0;
+	unsigned char *ec_point = NULL;
+	unsigned char *spki = NULL;
+	int spki_len = 0;
+	size_t prime_len = 0;
+	int rc = 0;
+
+	if (!EVP_PKEY_get_utf8_string_param(pkey, OSSL_PKEY_PARAM_GROUP_NAME,
+					    group, sizeof(group), NULL))
+		return 0;
+
+	switch (OBJ_sn2nid(group)) {
+	case NID_X9_62_prime256v1:
+		ec_params = oid_p256;
+		ec_params_len = sizeof(oid_p256);
+		prime_len = 256 / 8;
+		break;
+	case NID_secp384r1:
+		ec_params = oid_p384;
+		ec_params_len = sizeof(oid_p384);
+		prime_len = 384 / 8;
+		break;
+	case NID_secp521r1:
+		ec_params = oid_p521;
+		ec_params_len = sizeof(oid_p521);
+		prime_len = 521 / 8 + 1;
+		break;
+	}
+	if (ec_params == NULL)
+		return 0;
+
+	if (EVP_PKEY_get_octet_string_param(pkey,
+					    OSSL_PKEY_PARAM_ENCODED_PUBLIC_KEY,
+					    point + 3, sizeof(point) - 3,
+					    &ec_point_len) == 1) {
+		/* CKA_EC_POINT needs DER encoded EC point */
+		if (ec_point_len < 0x80) {
+			point[1] = 0x04; /* OCTET-STRING */
+			point[2] = ec_point_len & 0x7f;
+			ec_point_len += 2;
+			ec_point = &point[1];
+		} else if (ec_point_len < 0x0100) {
+			point[0] = 0x04; /* OCTET-STRING */
+			point[1] = 0x81; /* 1 byte length field */
+			point[2] = ec_point_len & 0xff;
+			ec_point_len += 3;
+			ec_point = &point[0];
+		} else {
+			return 0;
+		}
+
+		spki_len = i2d_PUBKEY(pkey, &spki);
+		if (spki_len <= 0 || spki == NULL)
+			return 0;
+	}
+
+	if (keypair &&
+	    !object_add_ec_ed_private_key(label, lineno, CKK_EC,
+					  ec_params, ec_params_len,
+					  spki, spki_len, prime_len, pkey))
+		goto out;
+
+	if (ec_point != NULL &&
+	    !object_add_ec_ed_public_key(label, lineno, CKK_EC,
+					 ec_params, ec_params_len,
+					 ec_point, ec_point_len,
+					 spki, spki_len, prime_len, pkey))
+		goto out;
+
+	rc = 1;
+
+out:
+	if (spki != NULL)
+		OPENSSL_free(spki);
+
+	return rc;
+}
+
+static int openssl_process_ed_key(const char *label, EVP_PKEY *pkey,
+				  size_t lineno, bool keypair)
+{
+	const unsigned char *ec_params = NULL;
+	size_t ec_params_len = 0;
+	unsigned char ec_point[200] = { 0 };
+	size_t ec_point_len = 0;
+	unsigned char *spki = NULL;
+	int spki_len = 0;
+	int rc = 0;
+
+	if (EVP_PKEY_is_a(pkey, "ED25519")) {
+		ec_params = oid_ed25519;
+		ec_params_len = sizeof(oid_ed25519);
+	} else if (EVP_PKEY_is_a(pkey, "ED448")) {
+		ec_params = oid_ed448;
+		ec_params_len = sizeof(oid_ed448);
+	}
+	if (ec_params == NULL)
+		return 0;
+
+	if (EVP_PKEY_get_octet_string_param(pkey, OSSL_PKEY_PARAM_PUB_KEY,
+					    ec_point, sizeof(ec_point),
+					    &ec_point_len)) {
+		spki_len = i2d_PUBKEY(pkey, &spki);
+		if (spki_len <= 0 || spki == NULL)
+			return 0;
+	}
+
+	if (keypair &&
+	    !object_add_ec_ed_private_key(label, lineno, CKK_EC_EDWARDS,
+					  ec_params, ec_params_len,
+					  spki, spki_len, 0, pkey))
+		goto out;
+
+	if (ec_point_len > 0 &&
+	    !object_add_ec_ed_public_key(label, lineno, CKK_EC_EDWARDS,
+					 ec_params, ec_params_len,
+					 ec_point, ec_point_len,
+					 spki, spki_len, 0, pkey))
+		goto out;
+
+	rc = 1;
+
+out:
+	if (spki != NULL)
+		OPENSSL_free(spki);
+
+	return rc;
+}
+
+static int openssl_process_pkey(const char *label, EVP_PKEY *pkey,
+				size_t lineno, bool keypair)
+{
+	if (EVP_PKEY_is_a(pkey, "EC"))
+		return openssl_process_ec_key(label, pkey, lineno, keypair);
+	if (EVP_PKEY_is_a(pkey, "ED25519"))
+		return openssl_process_ed_key(label, pkey, lineno, keypair);
+	if (EVP_PKEY_is_a(pkey, "ED448"))
+		return openssl_process_ed_key(label, pkey, lineno, keypair);
+
+	fprintf(stderr, "zpcpkcs11: Unsupported key type [label=%s]\n", label);
+	return 0;
+}
+
+int openssl_process_config(const char *label, const char *uri, size_t lineno)
+{
+	OSSL_STORE_CTX *sctx;
+	EVP_PKEY *pkey;
+	int rc = 0;
+	int found = 0;
+
+	sctx = OSSL_STORE_open_ex(uri, ossl_lib_context, NULL, NULL, NULL,
+				  NULL, NULL, NULL);
+	if (!sctx) {
+		fprintf(stderr, "zpcpkcs11: OSSL_STORE_open() [uri=%s]\n", uri);
+		ERR_print_errors_fp(stderr);
+		goto out;
+	}
+
+	while (!OSSL_STORE_eof(sctx)) {
+		OSSL_STORE_INFO *info = OSSL_STORE_load(sctx);
+		if (!info) {
+			fprintf(stderr,
+				"zpcpkcs11: OSSL_STORE_load() [uri=%s]\n", uri);
+			ERR_print_errors_fp(stderr);
+			goto out_close;
+		}
+
+		switch (OSSL_STORE_INFO_get_type(info)) {
+		case OSSL_STORE_INFO_PKEY:
+			pkey = OSSL_STORE_INFO_get1_PKEY(info);
+			rc = openssl_process_pkey(label, pkey, lineno, true);
+			EVP_PKEY_free(pkey);
+			found = 1;
+			break;
+		case OSSL_STORE_INFO_PUBKEY:
+			pkey = OSSL_STORE_INFO_get1_PUBKEY(info);
+			rc = openssl_process_pkey(label, pkey, lineno, false);
+			EVP_PKEY_free(pkey);
+			found = 1;
+			break;
+		default:
+			OSSL_STORE_INFO_free(info);
+			continue;
+		}
+
+		OSSL_STORE_INFO_free(info);
+		break;
+	}
+
+	if (!found) {
+		fprintf(stderr,
+			"zpcpkcs11: No key found in store [uri=%s]\n", uri);
+		goto out_close;
+	}
+
+out_close:
+	OSSL_STORE_close(sctx);
+out:
+	return rc;
+}
+
+EVP_PKEY_CTX *openssl_get_pkey_context(EVP_PKEY *pkey)
+{
+	EVP_PKEY_CTX *ctx;
+
+	ctx = EVP_PKEY_CTX_new_from_pkey(ossl_lib_context, pkey, NULL);
+	if (ctx == NULL) {
+		fprintf(stderr,
+			"zpcpkcs11: EVP_PKEY_CTX_new_from_pkey failed\n");
+		ERR_print_errors_fp(stderr);
+		return NULL;
+	}
+
+	return ctx;
+}
+
+EVP_MD_CTX *openssl_get_digest_sign_context(EVP_PKEY *pkey,
+					    const char *mdname)
+{
+	EVP_MD_CTX *ctx;
+
+	ctx = EVP_MD_CTX_new();
+	if (ctx == NULL)
+		return NULL;
+
+	if (EVP_DigestSignInit_ex(ctx, NULL, mdname, ossl_lib_context, NULL,
+				  pkey, NULL) != 1) {
+		fprintf(stderr,
+			"zpcpkcs11: EVP_DigestSignInit_ex failed\n");
+		ERR_print_errors_fp(stderr);
+		EVP_MD_CTX_free(ctx);
+		return NULL;
+	}
+
+	return ctx;
+}
+
+EVP_MD_CTX *openssl_get_digest_verify_context(EVP_PKEY *pkey,
+					      const char *mdname)
+{
+	EVP_MD_CTX *ctx = NULL;
+
+	ctx = EVP_MD_CTX_new();
+	if (ctx == NULL)
+		return NULL;
+
+	if (EVP_DigestVerifyInit_ex(ctx, NULL, mdname, ossl_lib_context, NULL,
+				    pkey, NULL) != 1) {
+		fprintf(stderr,
+			"zpcpkcs11: EVP_DigestVerifyInit_ex failed\n");
+		ERR_print_errors_fp(stderr);
+		EVP_MD_CTX_free(ctx);
+		return NULL;
+	}
+
+	return ctx;
+}
diff --git a/src/pkcs11/openssl.h b/src/pkcs11/openssl.h
new file mode 100644
index 0000000..0592cfe
--- /dev/null
+++ b/src/pkcs11/openssl.h
@@ -0,0 +1,21 @@
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the libzpc project
+#ifndef OPENSSL_H
+#define OPENSSL_H
+
+#include <stdio.h>
+#include <openssl/evp.h>
+
+int openssl_init(void);
+
+void openssl_term(void);
+
+int openssl_process_config(const char *label, const char *uri, size_t lineno);
+
+EVP_PKEY_CTX *openssl_get_pkey_context(EVP_PKEY *pkey);
+EVP_MD_CTX *openssl_get_digest_sign_context(EVP_PKEY *pkey,
+					    const char *mdname);
+EVP_MD_CTX *openssl_get_digest_verify_context(EVP_PKEY *pkey,
+					      const char *mdname);
+
+#endif
diff --git a/src/pkcs11/pkcs11.c b/src/pkcs11/pkcs11.c
new file mode 100644
index 0000000..cb3b559
--- /dev/null
+++ b/src/pkcs11/pkcs11.c
@@ -0,0 +1,2106 @@
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the libzpc project
+#include <string.h>
+#include <pthread.h>
+#include "pkcs11.h"
+#include "openssl.h"
+#include "config.h"
+#include "object.h"
+#include "session.h"
+#include "signature.h"
+
+#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);
+
+/*
+ * 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;
+
+static struct {
+	CK_MECHANISM_TYPE type;
+	CK_MECHANISM_INFO info;
+} mech_list[] = {
+	{ CKM_ECDSA, {256, 521, CKF_SIGN | CKF_VERIFY | CKF_EC_OID |
+			CKF_EC_F_P | CKF_EC_UNCOMPRESS | CKF_EC_COMPRESS}},
+	{ CKM_ECDSA_SHA1, {256, 521, CKF_SIGN | CKF_VERIFY | CKF_EC_OID |
+			CKF_EC_F_P | CKF_EC_UNCOMPRESS | CKF_EC_COMPRESS}},
+	{ CKM_ECDSA_SHA224, {256, 521, CKF_SIGN | CKF_VERIFY | CKF_EC_OID |
+			CKF_EC_F_P | CKF_EC_UNCOMPRESS | CKF_EC_COMPRESS}},
+	{ CKM_ECDSA_SHA256, {256, 521, CKF_SIGN | CKF_VERIFY | CKF_EC_OID |
+			CKF_EC_F_P | CKF_EC_UNCOMPRESS | CKF_EC_COMPRESS}},
+	{ CKM_ECDSA_SHA384, {256, 521, CKF_SIGN | CKF_VERIFY | CKF_EC_OID |
+			CKF_EC_F_P | CKF_EC_UNCOMPRESS | CKF_EC_COMPRESS}},
+	{ CKM_ECDSA_SHA512, {256, 521, CKF_SIGN | CKF_VERIFY | CKF_EC_OID |
+			CKF_EC_F_P | CKF_EC_UNCOMPRESS | CKF_EC_COMPRESS}},
+	{ CKM_ECDSA_SHA3_224, {256, 521, CKF_SIGN | CKF_VERIFY | CKF_EC_OID |
+			CKF_EC_F_P | CKF_EC_UNCOMPRESS | CKF_EC_COMPRESS}},
+	{ CKM_ECDSA_SHA3_256, {256, 521, CKF_SIGN | CKF_VERIFY | CKF_EC_OID |
+			CKF_EC_F_P | CKF_EC_UNCOMPRESS | CKF_EC_COMPRESS}},
+	{ CKM_ECDSA_SHA3_384, {256, 521, CKF_SIGN | CKF_VERIFY | CKF_EC_OID |
+			CKF_EC_F_P | CKF_EC_UNCOMPRESS | CKF_EC_COMPRESS}},
+	{ CKM_ECDSA_SHA3_512, {256, 521, CKF_SIGN | CKF_VERIFY | CKF_EC_OID |
+			CKF_EC_F_P | CKF_EC_UNCOMPRESS | CKF_EC_COMPRESS}},
+	{ CKM_EDDSA, {255, 448, CKF_SIGN | CKF_VERIFY | CKF_EC_OID |
+			CKF_EC_F_P | CKF_EC_COMPRESS}},
+};
+static size_t mech_list_len = sizeof(mech_list) / sizeof(mech_list[0]);
+
+/* 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;
+	}
+
+	if (openssl_init() != 1)
+		goto cleanup;
+
+	if (session_list_init() != 1)
+		goto cleanup;
+
+	if (object_list_init() != 1)
+		goto cleanup;
+
+	if (config_process(openssl_process_config) != 1)
+		goto cleanup;
+
+	pthread_once(&atfork_once, register_atfork);
+
+	api_initialized = CK_TRUE;
+	return CKR_OK;
+
+cleanup:
+	object_list_term();
+	session_list_term();
+	openssl_term();
+	return CKR_FUNCTION_FAILED;
+}
+
+CK_RV C_Finalize(CK_VOID_PTR pReserved)
+{
+	if (pReserved != NULL)
+		return CKR_ARGUMENTS_BAD;
+
+	if (!api_initialized)
+		return CKR_CRYPTOKI_NOT_INITIALIZED;
+
+	object_list_term();
+	session_list_term();
+	openssl_term();
+
+	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)
+{
+	if (pulCount == NULL)
+		return CKR_ARGUMENTS_BAD;
+	if (!api_initialized)
+		return CKR_CRYPTOKI_NOT_INITIALIZED;
+
+	(void)tokenPresent;
+
+	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)
+{
+	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)
+{
+	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->ulMaxRwSessionCount = CK_EFFECTIVELY_INFINITE;
+
+	if (!session_get_counts(&pInfo->ulSessionCount,
+				&pInfo->ulRwSessionCount))
+		return CKR_FUNCTION_FAILED;
+
+	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,
+			 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)
+{
+	CK_ULONG i;
+
+	if (pulCount == NULL)
+		return CKR_ARGUMENTS_BAD;
+	if (!api_initialized)
+		return CKR_CRYPTOKI_NOT_INITIALIZED;
+	if (slotID != PKCS11_SLOT_NUMBER)
+		return CKR_SLOT_ID_INVALID;
+
+	if (pMechanismList == NULL) {
+		*pulCount = mech_list_len;
+		return CKR_OK;
+	}
+
+	if (*pulCount < mech_list_len) {
+		*pulCount = mech_list_len;
+		return CKR_BUFFER_TOO_SMALL;
+	}
+
+	for (i = 0; i < mech_list_len; i++)
+		pMechanismList[i] = mech_list[i].type;
+	*pulCount = mech_list_len;
+
+	return CKR_OK;
+}
+
+CK_RV C_GetMechanismInfo(CK_SLOT_ID slotID, CK_MECHANISM_TYPE type,
+			 CK_MECHANISM_INFO_PTR pInfo)
+{
+	CK_ULONG i;
+
+	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;
+
+	for (i = 0; i < mech_list_len; i++) {
+		if (mech_list[i].type == type) {
+			*pInfo = mech_list[i].info;
+			return CKR_OK;
+		}
+	}
+
+	return CKR_MECHANISM_INVALID;
+}
+
+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)Notify;
+	(void)pApplication;
+
+	if (phSession == NULL)
+		return CKR_ARGUMENTS_BAD;
+	if (!api_initialized)
+		return CKR_CRYPTOKI_NOT_INITIALIZED;
+	if (slotID != PKCS11_SLOT_NUMBER)
+		return CKR_SLOT_ID_INVALID;
+	if ((flags & CKF_SERIAL_SESSION) == 0)
+		return CKR_SESSION_PARALLEL_NOT_SUPPORTED;
+	if ((flags & CKF_ASYNC_SESSION) != 0)
+		return CKR_SESSION_ASYNC_NOT_SUPPORTED;
+
+	if (!session_add_session(slotID, flags, phSession))
+		return CKR_FUNCTION_FAILED;
+
+	return CKR_OK;
+}
+
+CK_RV C_CloseSession(CK_SESSION_HANDLE hSession)
+{
+	if (!api_initialized)
+		return CKR_CRYPTOKI_NOT_INITIALIZED;
+
+	if (!session_remove_session(hSession))
+		return CKR_SESSION_HANDLE_INVALID;
+
+	return CKR_OK;
+}
+
+CK_RV C_CloseAllSessions(CK_SLOT_ID slotID)
+{
+	if (!api_initialized)
+		return CKR_CRYPTOKI_NOT_INITIALIZED;
+	if (slotID != PKCS11_SLOT_NUMBER)
+		return CKR_SLOT_ID_INVALID;
+
+	if (!session_remove_all())
+		return CKR_FUNCTION_FAILED;
+
+	return CKR_OK;
+}
+
+CK_RV C_GetSessionInfo(CK_SESSION_HANDLE hSession, CK_SESSION_INFO_PTR pInfo)
+{
+	struct pkcs11_session *sess;
+
+	if (pInfo == NULL)
+		return CKR_ARGUMENTS_BAD;
+	if (!api_initialized)
+		return CKR_CRYPTOKI_NOT_INITIALIZED;
+
+	if (!session_get_session(hSession, &sess))
+		return CKR_SESSION_HANDLE_INVALID;
+
+	*pInfo = sess->info;
+	return CKR_OK;
+}
+
+CK_RV C_GetOperationState(CK_SESSION_HANDLE hSession,
+			  CK_BYTE_PTR pOperationState,
+			  CK_ULONG_PTR pulOperationStateLen)
+{
+	(void)hSession;
+	(void)pOperationState;
+	(void)pulOperationStateLen;
+
+	if (!api_initialized)
+		return CKR_CRYPTOKI_NOT_INITIALIZED;
+
+	return CKR_STATE_UNSAVEABLE;
+}
+
+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;
+
+	if (!api_initialized)
+		return CKR_CRYPTOKI_NOT_INITIALIZED;
+
+	return CKR_STATE_UNSAVEABLE;
+}
+
+CK_RV C_Login(CK_SESSION_HANDLE hSession, CK_USER_TYPE userType,
+	      CK_UTF8CHAR_PTR pPin, CK_ULONG ulPinLen)
+{
+	struct pkcs11_session *sess;
+
+	(void)pPin;
+	(void)ulPinLen;
+
+	if (!api_initialized)
+		return CKR_CRYPTOKI_NOT_INITIALIZED;
+	if (userType != CKU_USER)
+		return CKR_USER_TYPE_INVALID;
+
+	if (!session_get_session(hSession, &sess))
+		return CKR_SESSION_HANDLE_INVALID;
+
+	if (session_get_login_state() == CK_TRUE)
+		return CKR_USER_ALREADY_LOGGED_IN;
+
+	session_set_login_state(CK_TRUE);
+
+	return CKR_OK;
+}
+
+CK_RV C_Logout(CK_SESSION_HANDLE hSession)
+{
+	struct pkcs11_session *sess;
+
+	if (!api_initialized)
+		return CKR_CRYPTOKI_NOT_INITIALIZED;
+
+	if (!session_get_session(hSession, &sess))
+		return CKR_SESSION_HANDLE_INVALID;
+
+	if (session_get_login_state() == CK_FALSE)
+		return CKR_USER_NOT_LOGGED_IN;
+
+	session_set_login_state(CK_FALSE);
+
+	return CKR_OK;
+}
+
+CK_RV C_SessionCancel(CK_SESSION_HANDLE hSession, CK_FLAGS flags)
+{
+	struct pkcs11_session *sess;
+
+	if (!api_initialized)
+		return CKR_CRYPTOKI_NOT_INITIALIZED;
+
+	if (!session_get_session(hSession, &sess))
+		return CKR_SESSION_HANDLE_INVALID;
+
+	if (!session_op_cleanup(sess, flags))
+		return CKR_OPERATION_CANCEL_FAILED;
+
+	return CKR_OK;
+}
+
+/* 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_TOKEN_WRITE_PROTECTED;
+}
+
+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_TOKEN_WRITE_PROTECTED;
+}
+
+CK_RV C_DestroyObject(CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE hObject)
+{
+	(void)hSession;
+	(void)hObject;
+	return CKR_TOKEN_WRITE_PROTECTED;
+}
+
+CK_RV C_GetObjectSize(CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE hObject,
+		      CK_ULONG_PTR pulSize)
+{
+	struct pkcs11_session *sess;
+	struct pkcs11_object *obj;
+
+	if (pulSize == NULL)
+		return CKR_ARGUMENTS_BAD;
+	if (!api_initialized)
+		return CKR_CRYPTOKI_NOT_INITIALIZED;
+
+	if (!session_get_session(hSession, &sess))
+		return CKR_SESSION_HANDLE_INVALID;
+
+	if (!object_list_get(hObject, &obj))
+		return CKR_OBJECT_HANDLE_INVALID;
+
+	if (!object_get_size(obj, pulSize))
+		return CKR_FUNCTION_FAILED;
+
+	return CKR_OK;
+}
+
+CK_RV C_GetAttributeValue(CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE hObject,
+			  CK_ATTRIBUTE_PTR pTemplate, CK_ULONG ulCount)
+{
+	struct pkcs11_session *sess;
+	struct pkcs11_object *obj;
+
+	if (pTemplate == NULL && ulCount != 0)
+		return CKR_ARGUMENTS_BAD;
+	if (!api_initialized)
+		return CKR_CRYPTOKI_NOT_INITIALIZED;
+
+	if (!session_get_session(hSession, &sess))
+		return CKR_SESSION_HANDLE_INVALID;
+
+	if (!object_list_get(hObject, &obj))
+		return CKR_OBJECT_HANDLE_INVALID;
+
+	return object_get_attributes(obj, pTemplate, ulCount);
+}
+
+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_TOKEN_WRITE_PROTECTED;
+}
+
+CK_RV C_FindObjectsInit(CK_SESSION_HANDLE hSession, CK_ATTRIBUTE_PTR pTemplate,
+			CK_ULONG ulCount)
+{
+	struct pkcs11_session *sess;
+	CK_RV rc;
+
+	if (pTemplate == NULL && ulCount != 0)
+		return CKR_ARGUMENTS_BAD;
+	if (!api_initialized)
+		return CKR_CRYPTOKI_NOT_INITIALIZED;
+
+	if (!session_get_session(hSession, &sess))
+		return CKR_SESSION_HANDLE_INVALID;
+
+	rc = session_op_init(sess, CKF_FIND_OBJECTS);
+	if (rc != CKR_OK)
+		return rc;
+
+	sess->find.pos = 0;
+	if (!dyn_array_init(&sess->find.found)) {
+		rc = CKR_FUNCTION_FAILED;
+		goto done;
+	}
+
+	if (!object_list_find(pTemplate, ulCount, &sess->find.found)) {
+		rc = CKR_FUNCTION_FAILED;
+		goto done;
+	}
+
+done:
+	if (rc != CKR_OK)
+		session_op_cleanup(sess, CKF_FIND_OBJECTS);
+
+	return rc;
+}
+
+CK_RV C_FindObjects(CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE_PTR phObject,
+		    CK_ULONG ulMaxObjectCount, CK_ULONG_PTR pulObjectCount)
+{
+	struct pkcs11_session *sess;
+	struct pkcs11_object *obj;
+	CK_ULONG i;
+	CK_RV rc;
+
+	if (phObject == NULL || pulObjectCount == NULL)
+		return CKR_ARGUMENTS_BAD;
+	if (!api_initialized)
+		return CKR_CRYPTOKI_NOT_INITIALIZED;
+
+	if (!session_get_session(hSession, &sess))
+		return CKR_SESSION_HANDLE_INVALID;
+
+	rc = session_op_multi(sess, CKF_FIND_OBJECTS);
+	if (rc != CKR_OK)
+		return rc;
+
+	*pulObjectCount = 0;
+	for (i = 0; i < ulMaxObjectCount; i++) {
+		if (!dyn_array_get(&sess->find.found, sess->find.pos,
+				   (void **)&obj))
+			break;
+
+		phObject[i] = obj->handle;
+		(*pulObjectCount)++;
+		sess->find.pos++;
+	}
+
+	return CKR_OK;
+}
+
+CK_RV C_FindObjectsFinal(CK_SESSION_HANDLE hSession)
+{
+	struct pkcs11_session *sess;
+	CK_RV rc;
+
+	if (!api_initialized)
+		return CKR_CRYPTOKI_NOT_INITIALIZED;
+
+	if (!session_get_session(hSession, &sess))
+		return CKR_SESSION_HANDLE_INVALID;
+
+	rc = session_op_multi(sess, CKF_FIND_OBJECTS);
+	if (rc != CKR_OK)
+		return rc;
+
+	session_op_cleanup(sess, CKF_FIND_OBJECTS);
+
+	return CKR_OK;
+}
+
+/* Encryption functions */
+
+CK_RV C_EncryptInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechanism,
+	      CK_OBJECT_HANDLE hKey)
+{
+	(void)hKey;
+
+	if (pMechanism == NULL)
+		return C_SessionCancel(hSession, CKF_ENCRYPT);
+
+	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)hKey;
+
+	if (pMechanism == NULL)
+		return C_SessionCancel(hSession, CKF_DECRYPT);
+
+	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)
+{
+	if (pMechanism == NULL)
+		return C_SessionCancel(hSession, CKF_DIGEST);
+
+	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)
+{
+	struct pkcs11_session *sess;
+	struct pkcs11_object *key;
+	CK_RV rc;
+
+	if (!api_initialized)
+		return CKR_CRYPTOKI_NOT_INITIALIZED;
+
+	if (pMechanism == NULL)
+		return C_SessionCancel(hSession, CKF_SIGN);
+
+	if (!session_get_session(hSession, &sess))
+		return CKR_SESSION_HANDLE_INVALID;
+
+	if (!object_list_get(hKey, &key))
+		return CKR_OBJECT_HANDLE_INVALID;
+
+	rc = session_op_init(sess, CKF_SIGN);
+	if (rc != CKR_OK)
+		return rc;
+
+	rc = signature_sign_init(sess, key, pMechanism);
+	if (rc != CKR_OK)
+		session_op_cleanup(sess, CKF_SIGN);
+
+	return rc;
+}
+
+CK_RV C_Sign(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pData, CK_ULONG ulDataLen,
+	     CK_BYTE_PTR pSignature, CK_ULONG_PTR pulSignatureLen)
+{
+	struct pkcs11_session *sess;
+	CK_RV rc;
+
+	if (pulSignatureLen == NULL || (pData == NULL && ulDataLen != 0))
+		return CKR_ARGUMENTS_BAD;
+	if (!api_initialized)
+		return CKR_CRYPTOKI_NOT_INITIALIZED;
+
+	if (!session_get_session(hSession, &sess))
+		return CKR_SESSION_HANDLE_INVALID;
+
+	rc = session_op_single(sess, CKF_SIGN);
+	if (rc != CKR_OK)
+		return rc;
+
+	rc = signature_sign(sess, pData, ulDataLen,
+			    pSignature, pulSignatureLen);
+
+	if (!((rc == CKR_OK && pSignature == NULL) || rc == CKR_BUFFER_TOO_SMALL))
+		session_op_cleanup(sess, CKF_SIGN);
+
+	return rc;
+}
+
+CK_RV C_SignUpdate(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pPart,
+		   CK_ULONG ulPartLen)
+{
+	struct pkcs11_session *sess;
+	CK_RV rc;
+
+	if (pPart == NULL && ulPartLen != 0)
+		return CKR_ARGUMENTS_BAD;
+	if (!api_initialized)
+		return CKR_CRYPTOKI_NOT_INITIALIZED;
+
+	if (!session_get_session(hSession, &sess))
+		return CKR_SESSION_HANDLE_INVALID;
+
+	rc = session_op_multi(sess, CKF_SIGN);
+	if (rc != CKR_OK)
+		return rc;
+
+	return signature_sign_update(sess, pPart, ulPartLen);
+}
+
+CK_RV C_SignFinal(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pSignature,
+		  CK_ULONG_PTR pulSignatureLen)
+{
+	struct pkcs11_session *sess;
+	CK_RV rc;
+
+	if (pulSignatureLen == NULL)
+		return CKR_ARGUMENTS_BAD;
+	if (!api_initialized)
+		return CKR_CRYPTOKI_NOT_INITIALIZED;
+
+	if (!session_get_session(hSession, &sess))
+		return CKR_SESSION_HANDLE_INVALID;
+
+	rc = session_op_multi(sess, CKF_SIGN);
+	if (rc != CKR_OK)
+		return rc;
+
+	rc = signature_sign_final(sess, pSignature, pulSignatureLen);
+
+	if (!((rc == CKR_OK && pSignature == NULL) || rc == CKR_BUFFER_TOO_SMALL))
+		session_op_cleanup(sess, CKF_SIGN);
+
+	return rc;
+}
+
+CK_RV C_SignRecoverInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechanism,
+			CK_OBJECT_HANDLE hKey)
+{
+	(void)hKey;
+
+	if (pMechanism == NULL)
+		return C_SessionCancel(hSession, CKF_SIGN_RECOVER);
+
+	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)
+{
+	struct pkcs11_session *sess;
+	struct pkcs11_object *key;
+	CK_RV rc;
+
+	if (!api_initialized)
+		return CKR_CRYPTOKI_NOT_INITIALIZED;
+
+	if (pMechanism == NULL)
+		return C_SessionCancel(hSession, CKF_VERIFY);
+
+	if (!session_get_session(hSession, &sess))
+		return CKR_SESSION_HANDLE_INVALID;
+
+	if (!object_list_get(hKey, &key))
+		return CKR_OBJECT_HANDLE_INVALID;
+
+	rc = session_op_init(sess, CKF_VERIFY);
+	if (rc != CKR_OK)
+		return rc;
+
+	rc = signature_verify_init(sess, key, pMechanism, NULL, 0);
+	if (rc != CKR_OK)
+		session_op_cleanup(sess, CKF_VERIFY);
+
+	return rc;
+}
+
+CK_RV C_Verify(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pData,
+	       CK_ULONG ulDataLen, CK_BYTE_PTR pSignature,
+	       CK_ULONG ulSignatureLen)
+{
+	struct pkcs11_session *sess;
+	CK_RV rc;
+
+	if (pSignature == NULL || ulSignatureLen == 0 ||
+	    (pData == NULL && ulDataLen != 0))
+		return CKR_ARGUMENTS_BAD;
+	if (!api_initialized)
+		return CKR_CRYPTOKI_NOT_INITIALIZED;
+
+	if (!session_get_session(hSession, &sess))
+		return CKR_SESSION_HANDLE_INVALID;
+
+	rc = session_op_single(sess, CKF_VERIFY);
+	if (rc != CKR_OK)
+		return rc;
+
+	rc = signature_verify(sess, pData, ulDataLen,
+			      pSignature, ulSignatureLen);
+
+	session_op_cleanup(sess, CKF_VERIFY);
+
+	return rc;
+}
+
+CK_RV C_VerifyUpdate(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pPart,
+		     CK_ULONG ulPartLen)
+{
+	struct pkcs11_session *sess;
+	CK_RV rc;
+
+	if (pPart == NULL && ulPartLen != 0)
+		return CKR_ARGUMENTS_BAD;
+	if (!api_initialized)
+		return CKR_CRYPTOKI_NOT_INITIALIZED;
+
+	if (!session_get_session(hSession, &sess))
+		return CKR_SESSION_HANDLE_INVALID;
+
+	rc = session_op_multi(sess, CKF_VERIFY);
+	if (rc != CKR_OK)
+		return rc;
+
+	return signature_verify_update(sess, pPart, ulPartLen);
+}
+
+CK_RV C_VerifyFinal(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pSignature,
+		    CK_ULONG ulSignatureLen)
+{
+	struct pkcs11_session *sess;
+	CK_RV rc;
+
+	if (pSignature == NULL || ulSignatureLen == 0)
+		return CKR_ARGUMENTS_BAD;
+	if (!api_initialized)
+		return CKR_CRYPTOKI_NOT_INITIALIZED;
+
+	if (!session_get_session(hSession, &sess))
+		return CKR_SESSION_HANDLE_INVALID;
+
+	rc = session_op_multi(sess, CKF_VERIFY);
+	if (rc != CKR_OK)
+		return rc;
+
+	rc = signature_verify_final(sess, pSignature, ulSignatureLen);
+
+	session_op_cleanup(sess, CKF_VERIFY);
+
+	return rc;
+}
+
+CK_RV C_VerifyRecoverInit(CK_SESSION_HANDLE hSession,
+			  CK_MECHANISM_PTR pMechanism,
+			  CK_OBJECT_HANDLE hKey)
+{
+	(void)hKey;
+
+	if (pMechanism == NULL)
+		return C_SessionCancel(hSession, CKF_VERIFY_RECOVER);
+
+	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_PARALLEL;
+}
+
+CK_RV C_CancelFunction(CK_SESSION_HANDLE hSession)
+{
+	(void)hSession;
+
+	return CKR_FUNCTION_NOT_PARALLEL;
+}
+
+/* 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)hKey;
+
+	if (pMechanism == NULL)
+		return C_SessionCancel(hSession, CKF_MESSAGE_ENCRYPT);
+
+	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)hKey;
+
+	if (pMechanism == NULL)
+		return C_SessionCancel(hSession, CKF_MESSAGE_DECRYPT);
+
+	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)hKey;
+
+	if (pMechanism == NULL)
+		return C_SessionCancel(hSession, CKF_MESSAGE_SIGN);
+
+	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)hKey;
+
+	if (pMechanism == NULL)
+		return C_SessionCancel(hSession, CKF_MESSAGE_VERIFY);
+
+	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)
+{
+	struct pkcs11_session *sess;
+
+	(void)pPin;
+	(void)ulPinLen;
+	(void)pUsername;
+	(void)ulUsernameLen;
+
+	if (!api_initialized)
+		return CKR_CRYPTOKI_NOT_INITIALIZED;
+	if (userType != CKU_USER)
+		return CKR_USER_TYPE_INVALID;
+
+	if (!session_get_session(hSession, &sess))
+		return CKR_SESSION_HANDLE_INVALID;
+
+	if (session_get_login_state() == CK_TRUE)
+		return CKR_USER_ALREADY_LOGGED_IN;
+
+	session_set_login_state(CK_TRUE);
+
+	return CKR_OK;
+}
+
+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)
+{
+	struct pkcs11_session *sess;
+	struct pkcs11_object *key;
+	CK_RV rc;
+
+	if (pSignature == NULL || ulSignatureLen == 0)
+		return CKR_ARGUMENTS_BAD;
+	if (!api_initialized)
+		return CKR_CRYPTOKI_NOT_INITIALIZED;
+
+	if (pMechanism == NULL)
+		return C_SessionCancel(hSession, CKF_VERIFY);
+
+	if (!session_get_session(hSession, &sess))
+		return CKR_SESSION_HANDLE_INVALID;
+
+	if (!object_list_get(hKey, &key))
+		return CKR_OBJECT_HANDLE_INVALID;
+
+	rc = session_op_init(sess, CKF_VERIFY);
+	if (rc != CKR_OK)
+		return rc;
+
+	rc = signature_verify_init(sess, key, pMechanism,
+				   pSignature, ulSignatureLen);
+	if (rc != CKR_OK)
+		session_op_cleanup(sess, CKF_VERIFY);
+
+	return rc;
+}
+
+CK_RV C_VerifySignature(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pData,
+			CK_ULONG ulDataLen)
+{
+	struct pkcs11_session *sess;
+	CK_RV rc;
+
+	if (pData == NULL && ulDataLen != 0)
+		return CKR_ARGUMENTS_BAD;
+	if (!api_initialized)
+		return CKR_CRYPTOKI_NOT_INITIALIZED;
+
+	if (!session_get_session(hSession, &sess))
+		return CKR_SESSION_HANDLE_INVALID;
+
+	rc = session_op_single(sess, CKF_VERIFY);
+	if (rc != CKR_OK)
+		return rc;
+
+	rc = signature_verify(sess, pData, ulDataLen,
+			      sess->verify.signature,
+			      sess->verify.signature_len);
+
+	session_op_cleanup(sess, CKF_VERIFY);
+
+	return rc;
+}
+
+CK_RV C_VerifySignatureUpdate(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pPart,
+			      CK_ULONG ulPartLen)
+{
+	struct pkcs11_session *sess;
+	CK_RV rc;
+
+	if (pPart == NULL && ulPartLen != 0)
+		return CKR_ARGUMENTS_BAD;
+	if (!api_initialized)
+		return CKR_CRYPTOKI_NOT_INITIALIZED;
+
+	if (!session_get_session(hSession, &sess))
+		return CKR_SESSION_HANDLE_INVALID;
+
+	rc = session_op_multi(sess, CKF_VERIFY);
+	if (rc != CKR_OK)
+		return rc;
+
+	return signature_verify_update(sess, pPart, ulPartLen);
+}
+
+CK_RV C_VerifySignatureFinal(CK_SESSION_HANDLE hSession)
+{
+	struct pkcs11_session *sess;
+	CK_RV rc;
+
+	if (!api_initialized)
+		return CKR_CRYPTOKI_NOT_INITIALIZED;
+
+	if (!session_get_session(hSession, &sess))
+		return CKR_SESSION_HANDLE_INVALID;
+
+	rc = session_op_multi(sess, CKF_VERIFY);
+	if (rc != CKR_OK)
+		return rc;
+
+	rc = signature_verify_final(sess, sess->verify.signature,
+				    sess->verify.signature_len);
+
+	session_op_cleanup(sess, CKF_VERIFY);
+
+	return rc;
+}
+
+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 0000000..e002a44
--- /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/src/pkcs11/session.c b/src/pkcs11/session.c
new file mode 100644
index 0000000..8fa293c
--- /dev/null
+++ b/src/pkcs11/session.c
@@ -0,0 +1,368 @@
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the libzpc project
+#include <stdlib.h>
+#include <stddef.h>
+#include <pthread.h>
+#include "session.h"
+#include "signature.h"
+#include "utils.h"
+
+/*
+ * The session mutex protects the list structure only. Per the PKCS#11
+ * spec a session may not be used concurrently by multiple threads,
+ * so a session remains valid for the duration of the caller's
+ * operation without holding the lock.
+ */
+static struct dyn_array sessions;
+static CK_BBOOL global_login_state = CK_FALSE;
+static pthread_mutex_t session_mutex = PTHREAD_MUTEX_INITIALIZER;
+
+static void session_set_state(struct pkcs11_session *sess)
+{
+	if (global_login_state) {
+		if ((sess->info.flags & CKF_RW_SESSION) != 0)
+			sess->info.state = CKS_RW_USER_FUNCTIONS;
+		else
+			sess->info.state = CKS_RO_USER_FUNCTIONS;
+	} else {
+		if ((sess->info.flags & CKF_RW_SESSION) != 0)
+			sess->info.state = CKS_RW_PUBLIC_SESSION;
+		else
+			sess->info.state = CKS_RO_PUBLIC_SESSION;
+	}
+}
+
+int session_init(struct pkcs11_session **sess, CK_SLOT_ID slot, CK_FLAGS flags)
+{
+	struct pkcs11_session *s;
+
+	if (sess == NULL)
+		return 0;
+
+	s = calloc(1, sizeof(*s));
+	if (s == NULL)
+		return 0;
+
+	s->info.slotID = slot;
+	s->info.flags = flags;
+
+	if (pthread_mutex_lock(&session_mutex) != 0) {
+		free(s);
+		return 0;
+	}
+
+	session_set_state(s);
+
+	pthread_mutex_unlock(&session_mutex);
+
+	*sess = s;
+	return 1;
+}
+
+CK_RV session_op_init(struct pkcs11_session *sess, CK_FLAGS op_flags)
+{
+	if (sess == NULL)
+		return CKR_ARGUMENTS_BAD;
+
+	if ((sess->op_active & op_flags) != 0)
+		return CKR_OPERATION_ACTIVE;
+
+	sess->op_active |= op_flags;
+
+	return CKR_OK;
+}
+
+CK_RV session_op_single(struct pkcs11_session *sess, CK_FLAGS op_flags)
+{
+	if (sess == NULL)
+		return CKR_ARGUMENTS_BAD;
+
+	if ((sess->op_active & op_flags) != op_flags)
+		return CKR_OPERATION_NOT_INITIALIZED;
+
+	if ((sess->op_multi_init & op_flags) == 0) {
+		sess->op_multi_init |= op_flags;
+		sess->op_multi &= ~op_flags;
+	}
+
+	if ((sess->op_multi & op_flags) != 0)
+		return CKR_OPERATION_ACTIVE;
+
+	return CKR_OK;
+}
+
+CK_RV session_op_multi(struct pkcs11_session *sess, CK_FLAGS op_flags)
+{
+	if (sess == NULL)
+		return CKR_ARGUMENTS_BAD;
+
+	if ((sess->op_active & op_flags) != op_flags)
+		return CKR_OPERATION_NOT_INITIALIZED;
+
+	if ((sess->op_multi_init & op_flags) == 0) {
+		sess->op_multi_init |= op_flags;
+		sess->op_multi |= op_flags;
+	}
+
+	if ((sess->op_multi & op_flags) != op_flags)
+		return CKR_OPERATION_ACTIVE;
+
+	return CKR_OK;
+}
+
+int session_op_cleanup(struct pkcs11_session *sess, CK_FLAGS op_flags)
+{
+	if (sess == NULL)
+		return 0;
+
+	if (sess->op_active & op_flags & CKF_FIND_OBJECTS) {
+		dyn_array_free(&sess->find.found);
+		sess->find.pos = 0;
+	}
+	if (sess->op_active & op_flags & CKF_SIGN)
+		signature_sign_cleanup(sess);
+	if (sess->op_active & op_flags & CKF_VERIFY)
+		signature_verify_cleanup(sess);
+
+	sess->op_active &= ~op_flags;
+	sess->op_multi_init &= ~op_flags;
+	sess->op_multi &= ~op_flags;
+
+	return 1;
+}
+
+void session_free(struct pkcs11_session *sess)
+{
+	if (sess == NULL)
+		return;
+
+	session_op_cleanup(sess, CKF_FIND_OBJECTS |
+				 CKF_ENCRYPT | CKF_DECRYPT | CKF_DIGEST |
+				 CKF_SIGN | CKF_SIGN_RECOVER | CKF_VERIFY |
+				 CKF_VERIFY_RECOVER | CKF_MESSAGE_ENCRYPT |
+				 CKF_MESSAGE_DECRYPT | CKF_MESSAGE_SIGN |
+				 CKF_MESSAGE_VERIFY);
+
+	free(sess);
+}
+
+int session_list_init(void)
+{
+	int rc;
+
+	if (pthread_mutex_lock(&session_mutex) != 0)
+		return 0;
+
+	rc = dyn_array_init(&sessions);
+
+	pthread_mutex_unlock(&session_mutex);
+
+	return rc;
+}
+
+void session_list_term(void)
+{
+	struct pkcs11_session *sess;
+	size_t i;
+
+	if (pthread_mutex_lock(&session_mutex) != 0)
+		return;
+
+	for (i = 0; i < dyn_array_size(&sessions); i++) {
+		if (!dyn_array_get(&sessions, i, (void **)&sess))
+			break;
+		if (sess != NULL)
+			session_free(sess);
+	}
+
+	dyn_array_free(&sessions);
+
+	pthread_mutex_unlock(&session_mutex);
+}
+
+int session_add_session(CK_SLOT_ID slot, CK_FLAGS flags,
+			CK_SESSION_HANDLE *handle)
+{
+	struct pkcs11_session *sess, *s;
+	size_t index;
+
+	if (handle == NULL)
+		return 0;
+
+	if (!session_init(&sess, slot, flags))
+		return 0;
+
+	if (pthread_mutex_lock(&session_mutex) != 0) {
+		session_free(sess);
+		return 0;
+	}
+
+	for (index = 0; index < dyn_array_size(&sessions); index++) {
+		if (!dyn_array_get(&sessions, index, (void **)&s))
+			break;
+		if (s == NULL) {
+			if (!dyn_array_set(&sessions, index, sess)) {
+				session_free(sess);
+				goto error;
+			}
+			goto done;
+		}
+	}
+
+	if (!dyn_array_add(&sessions, sess, &index)) {
+		session_free(sess);
+		goto error;
+	}
+
+done:
+	sess->handle = index + 1; /* zero handle = invalid */
+	*handle = sess->handle;
+
+	pthread_mutex_unlock(&session_mutex);
+	return 1;
+
+error:
+	pthread_mutex_unlock(&session_mutex);
+	return 0;
+}
+
+int session_get_session(CK_SESSION_HANDLE handle, struct pkcs11_session **sess)
+{
+	int rc = 0;
+
+	if (handle == CK_INVALID_HANDLE)
+		return 0;
+
+	if (pthread_mutex_lock(&session_mutex) != 0)
+		return 0;
+
+	if (!dyn_array_get(&sessions, handle - 1, (void **)sess))
+		goto unlock;
+
+	if (*sess == NULL)
+		goto unlock;
+
+	rc = 1;
+
+unlock:
+	pthread_mutex_unlock(&session_mutex);
+
+	return rc;
+}
+
+int session_remove_session(CK_SESSION_HANDLE handle)
+{
+	struct pkcs11_session *sess;
+	int rc = 0;
+
+	if (handle == CK_INVALID_HANDLE)
+		return 0;
+
+	if (pthread_mutex_lock(&session_mutex) != 0)
+		return 0;
+
+	if (!dyn_array_get(&sessions, handle - 1, (void **)&sess))
+		goto unlock;
+
+	if (sess == NULL)
+		goto unlock;
+
+	if (!dyn_array_set(&sessions, handle - 1, NULL))
+		goto unlock;
+
+	session_free(sess);
+
+	rc = 1;
+
+unlock:
+	pthread_mutex_unlock(&session_mutex);
+
+	return rc;
+}
+
+int session_remove_all(void)
+{
+	struct pkcs11_session *sess;
+	size_t i;
+	int rc = 0;
+
+	if (pthread_mutex_lock(&session_mutex) != 0)
+		return 0;
+
+	for (i = 0; i < dyn_array_size(&sessions); i++) {
+		if (!dyn_array_get(&sessions, i, (void **)&sess))
+			goto unlock;
+		if (sess != NULL) {
+			if (!dyn_array_set(&sessions, i, NULL))
+				goto unlock;
+			session_free(sess);
+		}
+	}
+
+	rc = 1;
+
+unlock:
+	pthread_mutex_unlock(&session_mutex);
+
+	return rc;
+}
+
+void session_set_login_state(CK_BBOOL login)
+{
+	struct pkcs11_session *sess;
+	size_t i;
+
+	if (pthread_mutex_lock(&session_mutex) != 0)
+		return;
+
+	global_login_state = login;
+
+	for (i = 0; i < dyn_array_size(&sessions); i++) {
+		if (!dyn_array_get(&sessions, i, (void **)&sess))
+			break;
+		if (sess != NULL)
+			session_set_state(sess);
+	}
+
+	pthread_mutex_unlock(&session_mutex);
+}
+
+CK_BBOOL session_get_login_state(void)
+{
+	CK_BBOOL ret;
+
+	if (pthread_mutex_lock(&session_mutex) != 0)
+		return CK_FALSE;
+
+	ret = global_login_state;
+
+	pthread_mutex_unlock(&session_mutex);
+
+	return ret;
+}
+
+int session_get_counts(CK_ULONG *count, CK_ULONG *rw_count)
+{
+	struct pkcs11_session *sess;
+	size_t i;
+
+	*count = 0;
+	*rw_count = 0;
+
+	if (pthread_mutex_lock(&session_mutex) != 0)
+		return 0;
+
+	for (i = 0; i < dyn_array_size(&sessions); i++) {
+		if (!dyn_array_get(&sessions, i, (void **)&sess))
+			break;
+		if (sess == NULL)
+			continue;
+
+		(*count)++;
+		if (sess->info.flags & CKF_RW_SESSION)
+			(*rw_count)++;
+	}
+
+	pthread_mutex_unlock(&session_mutex);
+	return 1;
+}
diff --git a/src/pkcs11/session.h b/src/pkcs11/session.h
new file mode 100644
index 0000000..e51b447
--- /dev/null
+++ b/src/pkcs11/session.h
@@ -0,0 +1,59 @@
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the libzpc project
+#ifndef SESSION_H
+#define SESSION_H
+
+#include <openssl/evp.h>
+#include "pkcs11.h"
+#include "utils.h"
+#include "object.h"
+
+struct pkcs11_session {
+	CK_SESSION_HANDLE handle;
+	CK_SESSION_INFO info;
+
+	CK_FLAGS op_active;
+	CK_FLAGS op_multi_init;
+	CK_FLAGS op_multi;
+
+	struct {
+		struct dyn_array found;
+		size_t pos;
+	} find;
+	struct {
+		CK_MECHANISM_TYPE mechanism;
+		struct pkcs11_object *key;
+		EVP_MD_CTX *md_ctx;
+		EVP_PKEY_CTX *pkey_ctx;
+	} sign;
+	struct {
+		CK_MECHANISM_TYPE mechanism;
+		struct pkcs11_object *key;
+		CK_BYTE *signature;
+		CK_ULONG signature_len;
+		EVP_MD_CTX *md_ctx;
+		EVP_PKEY_CTX *pkey_ctx;
+	} verify;
+};
+
+int session_init(struct pkcs11_session **sess, CK_SLOT_ID slot, CK_FLAGS flags);
+CK_RV session_op_init(struct pkcs11_session *sess, CK_FLAGS op_flags);
+CK_RV session_op_single(struct pkcs11_session *sess, CK_FLAGS op_flags);
+CK_RV session_op_multi(struct pkcs11_session *sess, CK_FLAGS op_flags);
+int session_op_cleanup(struct pkcs11_session *sess, CK_FLAGS op_flags);
+void session_free(struct pkcs11_session *sess);
+
+int session_list_init(void);
+void session_list_term(void);
+
+int session_add_session(CK_SLOT_ID slot, CK_FLAGS flags,
+			CK_SESSION_HANDLE *handle);
+int session_get_session(CK_SESSION_HANDLE handle, struct pkcs11_session **sess);
+int session_remove_session(CK_SESSION_HANDLE handle);
+int session_remove_all(void);
+
+void session_set_login_state(CK_BBOOL login);
+CK_BBOOL session_get_login_state(void);
+int session_get_counts(CK_ULONG *count, CK_ULONG *rw_count);
+
+#endif
diff --git a/src/pkcs11/signature.c b/src/pkcs11/signature.c
new file mode 100644
index 0000000..22f2992
--- /dev/null
+++ b/src/pkcs11/signature.c
@@ -0,0 +1,876 @@
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the libzpc project
+#include <stddef.h>
+#include <openssl/obj_mac.h>
+#include <openssl/err.h>
+#include <openssl/ec.h>
+#include "signature.h"
+#include "openssl.h"
+
+static CK_RV signature_check_operation(CK_FLAGS op, struct pkcs11_object *key)
+{
+	switch (op) {
+	case CKF_SIGN:
+		if (key->class != CKO_PRIVATE_KEY)
+			return CKR_KEY_FUNCTION_NOT_PERMITTED;
+		break;
+
+	case CKF_VERIFY:
+		if (key->class != CKO_PUBLIC_KEY)
+			return CKR_KEY_FUNCTION_NOT_PERMITTED;
+		break;
+
+	default:
+		return CKR_MECHANISM_INVALID;
+	}
+
+	return CKR_OK;
+}
+
+static CK_RV signature_check_mechanism(CK_MECHANISM *mech,
+				       struct pkcs11_object *key,
+				       CK_FLAGS op)
+{
+	CK_EDDSA_PARAMS *eddsa_param;
+
+	switch (mech->mechanism) {
+	case CKM_ECDSA:
+	case CKM_ECDSA_SHA1:
+	case CKM_ECDSA_SHA224:
+	case CKM_ECDSA_SHA256:
+	case CKM_ECDSA_SHA384:
+	case CKM_ECDSA_SHA512:
+	case CKM_ECDSA_SHA3_224:
+	case CKM_ECDSA_SHA3_256:
+	case CKM_ECDSA_SHA3_384:
+	case CKM_ECDSA_SHA3_512:
+		if (mech->pParameter != NULL || mech->ulParameterLen != 0)
+			return CKR_MECHANISM_PARAM_INVALID;
+
+		if (key->keytype != CKK_EC)
+			return CKR_KEY_TYPE_INCONSISTENT;
+
+		return signature_check_operation(op, key);
+
+	case CKM_EDDSA:
+		if (mech->pParameter != NULL &&
+		    mech->ulParameterLen != sizeof(CK_EDDSA_PARAMS))
+			return CKR_MECHANISM_PARAM_INVALID;
+		if (mech->pParameter == NULL && mech->ulParameterLen != 0)
+			return CKR_MECHANISM_PARAM_INVALID;
+
+		eddsa_param = mech->pParameter;
+		if (eddsa_param != NULL) {
+			if (eddsa_param->phFlag == CK_TRUE) {
+				fprintf(stderr,
+					"zpcpkcs11: EDDSA with pre-hash is not supported\n");
+				return CKR_MECHANISM_PARAM_INVALID;
+			}
+			if (eddsa_param->ulContextDataLen != 0) {
+				fprintf(stderr,
+					"zpcpkcs11: EDDSA with non-empty context is not supported\n");
+				return CKR_MECHANISM_PARAM_INVALID;
+			}
+		}
+
+		if (key->keytype != CKK_EC_EDWARDS)
+			return CKR_KEY_TYPE_INCONSISTENT;
+
+		return signature_check_operation(op, key);
+
+	default:
+		return CKR_MECHANISM_INVALID;
+	}
+
+	return CKR_OK;
+}
+
+static const char *signature_get_mdname_for_mech(CK_MECHANISM_TYPE mech)
+{
+	switch(mech) {
+	case CKM_ECDSA_SHA1:
+		return OBJ_nid2sn(NID_sha1);
+	case CKM_ECDSA_SHA224:
+		return OBJ_nid2sn(NID_sha224);
+	case CKM_ECDSA_SHA256:
+		return OBJ_nid2sn(NID_sha256);
+	case CKM_ECDSA_SHA384:
+		return OBJ_nid2sn(NID_sha384);
+	case CKM_ECDSA_SHA512:
+		return OBJ_nid2sn(NID_sha512);
+	case CKM_ECDSA_SHA3_224:
+		return OBJ_nid2sn(NID_sha3_224);
+	case CKM_ECDSA_SHA3_256:
+		return OBJ_nid2sn(NID_sha3_256);
+	case CKM_ECDSA_SHA3_384:
+		return OBJ_nid2sn(NID_sha3_384);
+	case CKM_ECDSA_SHA3_512:
+		return OBJ_nid2sn(NID_sha3_512);
+	default:
+		return NULL;
+	}
+}
+
+static EVP_MD_CTX *signature_get_digest_context(EVP_PKEY *pkey,
+						CK_MECHANISM_TYPE mech,
+						CK_FLAGS op)
+{
+	const char *mdname;
+
+	mdname = signature_get_mdname_for_mech(mech);
+	if (mdname == NULL && mech != CKM_EDDSA)
+		return NULL;
+
+	switch (op) {
+	case CKF_SIGN:
+		return openssl_get_digest_sign_context(pkey, mdname);
+	case CKF_VERIFY:
+		return openssl_get_digest_verify_context(pkey, mdname);
+	default:
+		return NULL;
+	}
+}
+
+static CK_RV signature_decode_ec_signature(size_t prime_len,
+					   const unsigned char *enc_sig,
+					   size_t enc_sig_len,
+					   unsigned char **raw_sig,
+					   size_t *raw_sig_len)
+{
+	ECDSA_SIG *sig = NULL;
+	const BIGNUM *r, *s;
+	CK_RV rc = CKR_OK;
+
+	if (enc_sig == NULL) {
+		*raw_sig_len = 2 * prime_len;
+		if (raw_sig != NULL)
+			*raw_sig = NULL;
+		return CKR_OK;
+	}
+
+	sig = d2i_ECDSA_SIG(NULL, &enc_sig, enc_sig_len);
+	if (sig == NULL) {
+		rc = CKR_FUNCTION_FAILED;
+		goto out;
+	}
+
+	ECDSA_SIG_get0(sig, &r, &s);
+
+	*raw_sig_len = 2 * prime_len;
+	*raw_sig = calloc(1, *raw_sig_len);
+	if (*raw_sig == NULL) {
+		rc = CKR_HOST_MEMORY;
+		goto out;
+	}
+
+	if (BN_bn2binpad(r, *raw_sig, prime_len) <= 0 ||
+	    BN_bn2binpad(s, (*raw_sig) + prime_len, prime_len) <= 0) {
+		rc = CKR_FUNCTION_FAILED;
+		goto out;
+	}
+
+out:
+	if (sig != NULL)
+		ECDSA_SIG_free(sig);
+	if (rc != CKR_OK && *raw_sig != NULL) {
+		free(*raw_sig);
+		*raw_sig = NULL;
+		*raw_sig_len = 0;
+	}
+
+	return rc;
+}
+
+static CK_RV signature_encode_ec_signature(size_t prime_len,
+					   const unsigned char *raw_sig,
+					   size_t raw_sig_len,
+					   unsigned char **enc_sig,
+					   size_t *enc_sig_len)
+{
+	ECDSA_SIG *sig = NULL;
+	BIGNUM *r = NULL, *s = NULL;
+	CK_RV rc = CKR_OK;
+	int len;
+
+	if (raw_sig_len != 2 * prime_len)
+		return CKR_SIGNATURE_LEN_RANGE;
+
+	sig = ECDSA_SIG_new();
+	if (sig == NULL) {
+		rc = CKR_HOST_MEMORY;
+		goto out;
+	}
+
+	r = BN_bin2bn(raw_sig, prime_len, NULL);
+	s = BN_bin2bn(raw_sig + prime_len, prime_len, NULL);
+	if (r == NULL || s == NULL) {
+		rc = CKR_FUNCTION_FAILED;
+		goto out;
+	}
+
+	if (!ECDSA_SIG_set0(sig, r, s)) {
+		rc = CKR_FUNCTION_FAILED;
+		goto out;
+	}
+	r = NULL;
+	s = NULL;
+
+	*enc_sig = NULL;
+	*enc_sig_len = 0;
+
+	len = i2d_ECDSA_SIG(sig, enc_sig);
+	if (len <= 0) {
+		rc = CKR_FUNCTION_FAILED;
+		goto out;
+	}
+	*enc_sig_len = len;
+
+out:
+	if (sig != NULL)
+		ECDSA_SIG_free(sig);
+	if (r != NULL)
+		BN_free(r);
+	if (s != NULL)
+		BN_free(s);
+
+	return rc;
+}
+
+static CK_RV signature_sign_verify_init_ctxs(struct pkcs11_object *key,
+					     CK_MECHANISM_PTR pMechanism,
+					     CK_FLAGS op,
+					     EVP_PKEY_CTX **pkey_ctx,
+					     EVP_MD_CTX **md_ctx)
+{
+	switch (pMechanism->mechanism) {
+	case CKM_ECDSA:
+		*md_ctx = NULL;
+		*pkey_ctx = openssl_get_pkey_context(key->data.ec_ed.pkey);
+		if (*pkey_ctx == NULL)
+			return CKR_FUNCTION_FAILED;
+
+		switch (op) {
+		case CKF_SIGN:
+			if (EVP_PKEY_sign_init(*pkey_ctx) != 1) {
+				fprintf(stderr,
+					"zpcpkcs11: EVP_PKEY_sign_init failed\n");
+				ERR_print_errors_fp(stderr);
+				EVP_PKEY_CTX_free(*pkey_ctx);
+				*pkey_ctx = NULL;
+				return CKR_FUNCTION_FAILED;
+			}
+			break;
+		case CKF_VERIFY:
+			if (EVP_PKEY_verify_init(*pkey_ctx) != 1) {
+				fprintf(stderr,
+					"zpcpkcs11: EVP_PKEY_verify_init failed\n");
+				ERR_print_errors_fp(stderr);
+				EVP_PKEY_CTX_free(*pkey_ctx);
+				*pkey_ctx = NULL;
+				return CKR_FUNCTION_FAILED;
+			}
+			break;
+		default:
+			return CKR_MECHANISM_INVALID;
+		}
+		break;
+
+	case CKM_ECDSA_SHA1:
+	case CKM_ECDSA_SHA224:
+	case CKM_ECDSA_SHA256:
+	case CKM_ECDSA_SHA384:
+	case CKM_ECDSA_SHA512:
+	case CKM_ECDSA_SHA3_224:
+	case CKM_ECDSA_SHA3_256:
+	case CKM_ECDSA_SHA3_384:
+	case CKM_ECDSA_SHA3_512:
+	case CKM_EDDSA:
+		*pkey_ctx = NULL;
+		*md_ctx = signature_get_digest_context(key->data.ec_ed.pkey,
+						       pMechanism->mechanism,
+						       op);
+		if (*md_ctx == NULL)
+			return CKR_FUNCTION_FAILED;
+		break;
+
+	default:
+		return CKR_MECHANISM_INVALID;
+	}
+
+	return CKR_OK;
+}
+
+CK_RV signature_sign_init(struct pkcs11_session *sess,
+			  struct pkcs11_object *key,
+			  CK_MECHANISM_PTR pMechanism)
+{
+	CK_RV rc;
+
+	if (sess == NULL || key == NULL || pMechanism == NULL)
+		return CKR_ARGUMENTS_BAD;
+
+	rc = signature_check_mechanism(pMechanism, key, CKF_SIGN);
+	if (rc != CKR_OK)
+		return rc;
+
+	rc = signature_sign_verify_init_ctxs(key, pMechanism, CKF_SIGN,
+					     &sess->sign.pkey_ctx,
+					     &sess->sign.md_ctx);
+	if (rc != CKR_OK)
+		return rc;
+
+	sess->sign.mechanism = pMechanism->mechanism;
+	sess->sign.key = key;
+
+	return CKR_OK;
+}
+
+static CK_RV signature_query_pkcs11_len(CK_BBOOL encoded, size_t prime_len,
+					size_t ossl_siglen, size_t *pkcs11_len)
+{
+	if (encoded)
+		return signature_decode_ec_signature(prime_len, NULL,
+						     ossl_siglen, NULL,
+						     pkcs11_len);
+	*pkcs11_len = ossl_siglen;
+	return CKR_OK;
+}
+
+static CK_RV signature_sign_produce_pkey(EVP_PKEY_CTX *ctx,
+					 const unsigned char *data,
+					 size_t datalen,
+					 size_t ossl_siglen,
+					 unsigned char **sig_out,
+					 size_t *siglen_out)
+{
+	unsigned char *sig;
+
+	sig = calloc(1, ossl_siglen);
+	if (sig == NULL)
+		return CKR_HOST_MEMORY;
+
+	*siglen_out = ossl_siglen;
+	if (EVP_PKEY_sign(ctx, sig, siglen_out, data, datalen) != 1) {
+		fprintf(stderr, "zpcpkcs11: EVP_PKEY_sign failed\n");
+		ERR_print_errors_fp(stderr);
+		free(sig);
+		return CKR_FUNCTION_FAILED;
+	}
+
+	*sig_out = sig;
+	return CKR_OK;
+}
+
+/*
+ * Allocate a buffer of ossl_siglen bytes, produce the signature with
+ * EVP_DigestSign, and hand ownership of the buffer to the caller.
+ * The size query has already been done by the caller; ossl_siglen is its result.
+ */
+static CK_RV signature_sign_produce_digest(EVP_MD_CTX *ctx,
+					   const unsigned char *data,
+					   size_t datalen,
+					   size_t ossl_siglen,
+					   unsigned char **sig_out,
+					   size_t *siglen_out)
+{
+	unsigned char *sig;
+
+	sig = calloc(1, ossl_siglen);
+	if (sig == NULL)
+		return CKR_HOST_MEMORY;
+
+	*siglen_out = ossl_siglen;
+	if (EVP_DigestSign(ctx, sig, siglen_out, data, datalen) != 1) {
+		fprintf(stderr, "zpcpkcs11: EVP_DigestSign failed\n");
+		ERR_print_errors_fp(stderr);
+		free(sig);
+		return CKR_FUNCTION_FAILED;
+	}
+
+	*sig_out = sig;
+	return CKR_OK;
+}
+
+static CK_RV signature_sign_produce_digest_final(EVP_MD_CTX *ctx,
+						 size_t ossl_siglen,
+						 unsigned char **sig_out,
+						 size_t *siglen_out)
+{
+	unsigned char *sig;
+
+	sig = calloc(1, ossl_siglen);
+	if (sig == NULL)
+		return CKR_HOST_MEMORY;
+
+	*siglen_out = ossl_siglen;
+	if (EVP_DigestSignFinal(ctx, sig, siglen_out) != 1) {
+		fprintf(stderr, "zpcpkcs11: EVP_DigestSignFinal failed\n");
+		ERR_print_errors_fp(stderr);
+		free(sig);
+		return CKR_FUNCTION_FAILED;
+	}
+
+	*sig_out = sig;
+	return CKR_OK;
+}
+
+static CK_RV signature_sign_finish(CK_BBOOL encoded, size_t prime_len,
+				   unsigned char *ossl_sig, size_t ossl_siglen,
+				   CK_BYTE_PTR pSignature,
+				   CK_ULONG_PTR pulSignatureLen)
+{
+	unsigned char *sig = ossl_sig;
+	size_t siglen = ossl_siglen;
+	unsigned char *raw_sig = NULL;
+	size_t raw_siglen = 0;
+	CK_RV rc = CKR_OK;
+
+	if (encoded) {
+		rc = signature_decode_ec_signature(prime_len, ossl_sig,
+						   ossl_siglen,
+						   &raw_sig, &raw_siglen);
+		free(ossl_sig);
+		if (rc != CKR_OK)
+			return rc;
+		sig = raw_sig;
+		siglen = raw_siglen;
+	}
+
+	if (pSignature == NULL) {
+		*pulSignatureLen = siglen;
+	} else if (*pulSignatureLen < siglen) {
+		rc = CKR_BUFFER_TOO_SMALL;
+		*pulSignatureLen = siglen;
+	} else {
+		memcpy(pSignature, sig, siglen);
+		*pulSignatureLen = siglen;
+	}
+
+	free(sig);
+	return rc;
+}
+
+CK_RV signature_sign(struct pkcs11_session *sess,
+		     CK_BYTE_PTR pData, CK_ULONG ulDataLen,
+		     CK_BYTE_PTR pSignature, CK_ULONG_PTR pulSignatureLen)
+{
+	CK_BBOOL encoded_signature = CK_TRUE;
+	size_t ossl_siglen = 0, pkcs11_len = 0, prime_len = 0;
+	unsigned char *ossl_sig = NULL;
+	CK_RV rc;
+
+	switch (sess->sign.mechanism) {
+	case CKM_ECDSA:
+		encoded_signature = CK_TRUE;
+		prime_len = sess->sign.key->data.ec_ed.prime_len;
+
+		if (EVP_PKEY_sign(sess->sign.pkey_ctx, NULL, &ossl_siglen,
+				  pData, ulDataLen) != 1) {
+			fprintf(stderr, "zpcpkcs11: EVP_PKEY_sign failed\n");
+			ERR_print_errors_fp(stderr);
+			return CKR_FUNCTION_FAILED;
+		}
+
+		rc = signature_query_pkcs11_len(encoded_signature, prime_len,
+						ossl_siglen, &pkcs11_len);
+		if (rc != CKR_OK)
+			return rc;
+
+		/*
+		 * Stop here for a size query or too-small buffer - calling
+		 * EVP_PKEY_sign to produce the signature would consume the
+		 * context and prevent a retry on the next call.
+		 */
+		if (pSignature == NULL || *pulSignatureLen < pkcs11_len) {
+			*pulSignatureLen = pkcs11_len;
+			return (pSignature == NULL) ?
+					CKR_OK : CKR_BUFFER_TOO_SMALL;
+		}
+
+		rc = signature_sign_produce_pkey(sess->sign.pkey_ctx,
+						 pData, ulDataLen, ossl_siglen,
+						 &ossl_sig, &ossl_siglen);
+		break;
+
+	case CKM_EDDSA:
+		encoded_signature = CK_FALSE;
+		/* Fall through */
+	case CKM_ECDSA_SHA1:
+	case CKM_ECDSA_SHA224:
+	case CKM_ECDSA_SHA256:
+	case CKM_ECDSA_SHA384:
+	case CKM_ECDSA_SHA512:
+	case CKM_ECDSA_SHA3_224:
+	case CKM_ECDSA_SHA3_256:
+	case CKM_ECDSA_SHA3_384:
+	case CKM_ECDSA_SHA3_512:
+		prime_len = sess->sign.key->data.ec_ed.prime_len;
+
+		if (EVP_DigestSign(sess->sign.md_ctx, NULL, &ossl_siglen,
+				   pData, ulDataLen) != 1) {
+			fprintf(stderr, "zpcpkcs11: EVP_DigestSign failed\n");
+			ERR_print_errors_fp(stderr);
+			return CKR_FUNCTION_FAILED;
+		}
+
+		rc = signature_query_pkcs11_len(encoded_signature, prime_len,
+						ossl_siglen, &pkcs11_len);
+		if (rc != CKR_OK)
+			return rc;
+
+		/*
+		 * Stop here for a size query or too-small buffer - calling
+		 * EVP_DigestSign to produce the signature would consume the
+		 * context and prevent a retry on the next call.
+		 */
+		if (pSignature == NULL || *pulSignatureLen < pkcs11_len) {
+			*pulSignatureLen = pkcs11_len;
+			return (pSignature == NULL) ?
+					CKR_OK : CKR_BUFFER_TOO_SMALL;
+		}
+
+		rc = signature_sign_produce_digest(sess->sign.md_ctx,
+						   pData, ulDataLen,
+						   ossl_siglen,
+						   &ossl_sig, &ossl_siglen);
+		break;
+
+	default:
+		return CKR_MECHANISM_INVALID;
+	}
+
+	if (rc != CKR_OK)
+		return rc;
+
+	return signature_sign_finish(encoded_signature, prime_len,
+				     ossl_sig, ossl_siglen,
+				     pSignature, pulSignatureLen);
+}
+
+CK_RV signature_sign_update(struct pkcs11_session *sess,
+			    CK_BYTE_PTR pData, CK_ULONG ulDataLen)
+{
+	switch (sess->sign.mechanism) {
+	case CKM_ECDSA_SHA1:
+	case CKM_ECDSA_SHA224:
+	case CKM_ECDSA_SHA256:
+	case CKM_ECDSA_SHA384:
+	case CKM_ECDSA_SHA512:
+	case CKM_ECDSA_SHA3_224:
+	case CKM_ECDSA_SHA3_256:
+	case CKM_ECDSA_SHA3_384:
+	case CKM_ECDSA_SHA3_512:
+		if (EVP_DigestSignUpdate(sess->sign.md_ctx,
+					 pData, ulDataLen) != 1) {
+			fprintf(stderr,
+				"zpcpkcs11: EVP_DigestSignUpdate failed\n");
+			ERR_print_errors_fp(stderr);
+			return CKR_FUNCTION_FAILED;
+		}
+		break;
+
+	/* CKM_ECDSA and CKM_EDDSA do not support multi-part operations. */
+	default:
+		return CKR_MECHANISM_INVALID;
+	}
+
+	return CKR_OK;
+}
+
+CK_RV signature_sign_final(struct pkcs11_session *sess,
+			   CK_BYTE_PTR pSignature,
+			   CK_ULONG_PTR pulSignatureLen)
+{
+	CK_BBOOL encoded_signature = CK_TRUE;
+	size_t ossl_siglen = 0, pkcs11_len = 0, prime_len = 0;
+	unsigned char *ossl_sig = NULL;
+	CK_RV rc;
+
+	switch (sess->sign.mechanism) {
+	case CKM_ECDSA_SHA1:
+	case CKM_ECDSA_SHA224:
+	case CKM_ECDSA_SHA256:
+	case CKM_ECDSA_SHA384:
+	case CKM_ECDSA_SHA512:
+	case CKM_ECDSA_SHA3_224:
+	case CKM_ECDSA_SHA3_256:
+	case CKM_ECDSA_SHA3_384:
+	case CKM_ECDSA_SHA3_512:
+		encoded_signature = CK_TRUE;
+		prime_len = sess->sign.key->data.ec_ed.prime_len;
+
+		if (EVP_DigestSignFinal(sess->sign.md_ctx, NULL,
+					&ossl_siglen) != 1) {
+			fprintf(stderr,
+				"zpcpkcs11: EVP_DigestSignFinal failed\n");
+			ERR_print_errors_fp(stderr);
+			return CKR_FUNCTION_FAILED;
+		}
+
+		rc = signature_query_pkcs11_len(encoded_signature, prime_len,
+						ossl_siglen, &pkcs11_len);
+		if (rc != CKR_OK)
+			return rc;
+
+		/*
+		 * Stop here for a size query or too-small buffer - calling
+		 * EVP_DigestSignFinal to produce the signature would consume
+		 * the context and prevent a retry on the next call.
+		 */
+		if (pSignature == NULL || *pulSignatureLen < pkcs11_len) {
+			*pulSignatureLen = pkcs11_len;
+			return (pSignature == NULL) ?
+					CKR_OK : CKR_BUFFER_TOO_SMALL;
+		}
+
+		rc = signature_sign_produce_digest_final(sess->sign.md_ctx,
+							 ossl_siglen,
+							 &ossl_sig,
+							 &ossl_siglen);
+		break;
+
+	/* CKM_ECDSA and CKM_EDDSA do not support multi-part operations. */
+	default:
+		return CKR_MECHANISM_INVALID;
+	}
+
+	if (rc != CKR_OK)
+		return rc;
+
+	return signature_sign_finish(encoded_signature, prime_len,
+				     ossl_sig, ossl_siglen,
+				     pSignature, pulSignatureLen);
+}
+
+void signature_sign_cleanup(struct pkcs11_session *sess)
+{
+	if (sess == NULL)
+		return;
+
+	if (sess->sign.pkey_ctx != NULL)
+		EVP_PKEY_CTX_free(sess->sign.pkey_ctx);
+	if (sess->sign.md_ctx != NULL)
+		EVP_MD_CTX_free(sess->sign.md_ctx);
+
+	sess->sign.key = NULL;
+	sess->sign.mechanism = 0;
+	sess->sign.pkey_ctx = NULL;
+	sess->sign.md_ctx = NULL;
+}
+
+CK_RV signature_verify_init(struct pkcs11_session *sess,
+			    struct pkcs11_object *key,
+			    CK_MECHANISM_PTR pMechanism,
+			    CK_BYTE_PTR pSignature,
+			    CK_ULONG ulSignatureLen)
+{
+	CK_RV rc;
+
+	if (sess == NULL || key == NULL || pMechanism == NULL)
+		return CKR_ARGUMENTS_BAD;
+
+	rc = signature_check_mechanism(pMechanism, key, CKF_VERIFY);
+	if (rc != CKR_OK)
+		return rc;
+
+	rc = signature_sign_verify_init_ctxs(key, pMechanism, CKF_VERIFY,
+					     &sess->verify.pkey_ctx,
+					     &sess->verify.md_ctx);
+	if (rc != CKR_OK)
+		return rc;
+
+	sess->verify.signature = memdup(pSignature, ulSignatureLen);
+	if (sess->verify.signature == NULL && ulSignatureLen != 0) {
+		signature_verify_cleanup(sess);
+		return CKR_HOST_MEMORY;
+	}
+	sess->verify.signature_len = ulSignatureLen;
+
+	sess->verify.mechanism = pMechanism->mechanism;
+	sess->verify.key = key;
+
+	return CKR_OK;
+}
+
+static CK_RV signature_verify_prepare_sig(CK_BBOOL encoded, size_t prime_len,
+					  CK_BYTE_PTR pSignature,
+					  CK_ULONG ulSignatureLen,
+					  unsigned char **ossl_sig,
+					  size_t *ossl_siglen)
+{
+	if (!encoded) {
+		*ossl_sig = pSignature;
+		*ossl_siglen = ulSignatureLen;
+		return CKR_OK;
+	}
+
+	*ossl_sig = NULL;
+	*ossl_siglen = 0;
+	return signature_encode_ec_signature(prime_len,
+					     pSignature, ulSignatureLen,
+					     ossl_sig, ossl_siglen);
+}
+
+static CK_RV signature_verify_translate_ret(int ret, const char *fn_name)
+{
+	if (ret == 1)
+		return CKR_OK;
+	if (ret == 0)
+		return CKR_SIGNATURE_INVALID;
+
+	fprintf(stderr, "zpcpkcs11: %s failed\n", fn_name);
+	ERR_print_errors_fp(stderr);
+	return CKR_FUNCTION_FAILED;
+}
+
+CK_RV signature_verify(struct pkcs11_session *sess,
+		       CK_BYTE_PTR pData, CK_ULONG ulDataLen,
+		       CK_BYTE_PTR pSignature, CK_ULONG ulSignatureLen)
+{
+	CK_BBOOL encoded_signature = CK_TRUE;
+	size_t prime_len, ossl_siglen = 0;
+	unsigned char *ossl_sig = NULL;
+	int ret;
+	CK_RV rc;
+
+	switch (sess->verify.mechanism) {
+	case CKM_EDDSA:
+		encoded_signature = CK_FALSE;
+		break;
+	}
+
+	prime_len = sess->verify.key->data.ec_ed.prime_len;
+
+	rc = signature_verify_prepare_sig(encoded_signature, prime_len,
+					  pSignature, ulSignatureLen,
+					  &ossl_sig, &ossl_siglen);
+	if (rc != CKR_OK)
+		return rc;
+
+	switch (sess->verify.mechanism) {
+	case CKM_ECDSA:
+		ret = EVP_PKEY_verify(sess->verify.pkey_ctx, ossl_sig,
+				      ossl_siglen, pData, ulDataLen);
+		rc = signature_verify_translate_ret(ret, "EVP_PKEY_verify");
+		break;
+
+	case CKM_EDDSA:
+	case CKM_ECDSA_SHA1:
+	case CKM_ECDSA_SHA224:
+	case CKM_ECDSA_SHA256:
+	case CKM_ECDSA_SHA384:
+	case CKM_ECDSA_SHA512:
+	case CKM_ECDSA_SHA3_224:
+	case CKM_ECDSA_SHA3_256:
+	case CKM_ECDSA_SHA3_384:
+	case CKM_ECDSA_SHA3_512:
+		ret = EVP_DigestVerify(sess->verify.md_ctx, ossl_sig,
+				       ossl_siglen, pData, ulDataLen);
+		rc = signature_verify_translate_ret(ret, "EVP_DigestVerify");
+		break;
+
+	default:
+		rc = CKR_MECHANISM_INVALID;
+		break;
+	}
+
+	if (encoded_signature && ossl_sig != NULL)
+		OPENSSL_free(ossl_sig);
+
+	return rc;
+}
+
+CK_RV signature_verify_update(struct pkcs11_session *sess,
+			      CK_BYTE_PTR pData, CK_ULONG ulDataLen)
+{
+	switch (sess->verify.mechanism) {
+	case CKM_ECDSA_SHA1:
+	case CKM_ECDSA_SHA224:
+	case CKM_ECDSA_SHA256:
+	case CKM_ECDSA_SHA384:
+	case CKM_ECDSA_SHA512:
+	case CKM_ECDSA_SHA3_224:
+	case CKM_ECDSA_SHA3_256:
+	case CKM_ECDSA_SHA3_384:
+	case CKM_ECDSA_SHA3_512:
+		if (EVP_DigestVerifyUpdate(sess->verify.md_ctx,
+					   pData, ulDataLen) != 1) {
+			fprintf(stderr,
+				"zpcpkcs11: EVP_DigestVerifyUpdate failed\n");
+			ERR_print_errors_fp(stderr);
+			return CKR_FUNCTION_FAILED;
+		}
+		break;
+
+	/* CKM_ECDSA and CKM_EDDSA do not support multi-part operations. */
+	default:
+		return CKR_MECHANISM_INVALID;
+	}
+
+	return CKR_OK;
+}
+
+CK_RV signature_verify_final(struct pkcs11_session *sess,
+			     CK_BYTE_PTR pSignature, CK_ULONG ulSignatureLen)
+{
+	CK_BBOOL encoded_signature = (sess->verify.mechanism != CKM_EDDSA);
+	size_t prime_len = sess->verify.key->data.ec_ed.prime_len;
+	unsigned char *ossl_sig = NULL;
+	size_t ossl_siglen = 0;
+	int ret;
+	CK_RV rc;
+
+	rc = signature_verify_prepare_sig(encoded_signature, prime_len,
+				pSignature, ulSignatureLen,
+				&ossl_sig, &ossl_siglen);
+	if (rc != CKR_OK)
+		return rc;
+
+	switch (sess->verify.mechanism) {
+	case CKM_ECDSA_SHA1:
+	case CKM_ECDSA_SHA224:
+	case CKM_ECDSA_SHA256:
+	case CKM_ECDSA_SHA384:
+	case CKM_ECDSA_SHA512:
+	case CKM_ECDSA_SHA3_224:
+	case CKM_ECDSA_SHA3_256:
+	case CKM_ECDSA_SHA3_384:
+	case CKM_ECDSA_SHA3_512:
+		ret = EVP_DigestVerifyFinal(sess->verify.md_ctx,
+					    ossl_sig, ossl_siglen);
+		rc = signature_verify_translate_ret(ret,
+						    "EVP_DigestVerifyFinal");
+		break;
+
+	/* CKM_ECDSA and CKM_EDDSA do not support multi-part operations. */
+	default:
+		rc = CKR_MECHANISM_INVALID;
+		break;
+	}
+
+	if (encoded_signature && ossl_sig != NULL)
+		OPENSSL_free(ossl_sig);
+
+	return rc;
+}
+
+void signature_verify_cleanup(struct pkcs11_session *sess)
+{
+	if (sess == NULL)
+		return;
+
+	if (sess->verify.pkey_ctx != NULL)
+		EVP_PKEY_CTX_free(sess->verify.pkey_ctx);
+	if (sess->verify.md_ctx != NULL)
+		EVP_MD_CTX_free(sess->verify.md_ctx);
+
+	sess->verify.key = NULL;
+	sess->verify.mechanism = 0;
+	sess->verify.pkey_ctx = NULL;
+	sess->verify.md_ctx = NULL;
+
+	if (sess->verify.signature != NULL)
+		free(sess->verify.signature);
+	sess->verify.signature = NULL;
+	sess->verify.signature_len = 0;
+}
diff --git a/src/pkcs11/signature.h b/src/pkcs11/signature.h
new file mode 100644
index 0000000..da90280
--- /dev/null
+++ b/src/pkcs11/signature.h
@@ -0,0 +1,37 @@
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the libzpc project
+#ifndef SIGNATURE_H
+#define SIGNATURE_H
+
+#include "pkcs11.h"
+#include "object.h"
+#include "session.h"
+
+CK_RV signature_sign_init(struct pkcs11_session *sess,
+			  struct pkcs11_object *key,
+			  CK_MECHANISM_PTR pMechanism);
+CK_RV signature_sign(struct pkcs11_session *sess,
+		     CK_BYTE_PTR pData, CK_ULONG ulDataLen,
+		     CK_BYTE_PTR pSignature, CK_ULONG_PTR pulSignatureLen);
+CK_RV signature_sign_update(struct pkcs11_session *sess,
+			    CK_BYTE_PTR pData, CK_ULONG ulDataLen);
+CK_RV signature_sign_final(struct pkcs11_session *sess,
+			   CK_BYTE_PTR pSignature,
+			   CK_ULONG_PTR pulSignatureLen);
+void signature_sign_cleanup(struct pkcs11_session *sess);
+
+CK_RV signature_verify_init(struct pkcs11_session *sess,
+			    struct pkcs11_object *key,
+			    CK_MECHANISM_PTR pMechanism,
+			    CK_BYTE_PTR pSignature,
+			    CK_ULONG ulSignatureLen);
+CK_RV signature_verify(struct pkcs11_session *sess,
+		       CK_BYTE_PTR pData, CK_ULONG ulDataLen,
+		       CK_BYTE_PTR pSignature, CK_ULONG ulSignatureLen);
+CK_RV signature_verify_update(struct pkcs11_session *sess,
+			      CK_BYTE_PTR pData, CK_ULONG ulDataLen);
+CK_RV signature_verify_final(struct pkcs11_session *sess,
+			     CK_BYTE_PTR pSignature, CK_ULONG ulSignatureLen);
+void signature_verify_cleanup(struct pkcs11_session *sess);
+
+#endif
diff --git a/src/pkcs11/utils.c b/src/pkcs11/utils.c
new file mode 100644
index 0000000..8d76f43
--- /dev/null
+++ b/src/pkcs11/utils.c
@@ -0,0 +1,110 @@
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the libzpc project
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+#include "utils.h"
+
+#define DYN_ARRAY_CHUNK_SIZE	32
+
+int dyn_array_init(struct dyn_array *da)
+{
+	if (da == NULL)
+		return 0;
+
+	da->elements = NULL;
+	da->size = 0;
+	da->allocated = 0;
+
+	return 1;
+}
+
+int dyn_array_free(struct dyn_array *da)
+{
+	if (da == NULL)
+		return 0;
+
+	if (da->elements != NULL)
+		free(da->elements);
+
+	da->elements = NULL;
+	da->size = 0;
+	da->allocated = 0;
+
+	return 1;
+}
+
+size_t dyn_array_size(const struct dyn_array *da)
+{
+	if (da == NULL)
+		return 0;
+
+	return da->size;
+}
+
+int dyn_array_add(struct dyn_array *da, void *element, size_t *index)
+{
+	void **tmp;
+	size_t new_alloc;
+
+	if (da == NULL)
+		return 0;
+
+	if (da->allocated == 0 || da->allocated <= da->size) {
+		new_alloc = da->allocated + DYN_ARRAY_CHUNK_SIZE;
+		if (new_alloc < da->allocated ||
+		    new_alloc > SIZE_MAX / sizeof(void *))
+			return 0;
+
+		tmp = realloc(da->elements, new_alloc * sizeof(void *));
+		if (tmp == NULL)
+			return 0;
+
+		da->elements = tmp;
+		da->allocated = new_alloc;
+	}
+
+	if (index != NULL)
+		*index = da->size;
+
+	da->elements[da->size++] = element;
+	return 1;
+}
+
+int dyn_array_get(const struct dyn_array *da, size_t index, void **element)
+{
+	if (da == NULL || element == NULL)
+		return 0;
+
+	if (index >= da->size)
+		return 0;
+
+	*element = da->elements[index];
+	return 1;
+}
+
+int dyn_array_set(struct dyn_array *da, size_t index, void *element)
+{
+	if (da == NULL)
+		return 0;
+
+	if (index >= da->size)
+		return 0;
+
+	da->elements[index] = element;
+	return 1;
+}
+
+void *memdup(const void *p, size_t len)
+{
+	void *ret;
+
+	if (p == NULL || len == 0)
+		return NULL;
+
+	ret = malloc(len);
+	if (ret != NULL)
+		memcpy(ret, p, len);
+
+	return ret;
+}
diff --git a/src/pkcs11/utils.h b/src/pkcs11/utils.h
new file mode 100644
index 0000000..ac66434
--- /dev/null
+++ b/src/pkcs11/utils.h
@@ -0,0 +1,23 @@
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the libzpc project
+#ifndef UTILS_H
+#define UTILS_H
+
+#include <stddef.h>
+
+struct dyn_array {
+	void **elements;
+	size_t size;
+	size_t allocated;
+};
+
+int dyn_array_init(struct dyn_array *da);
+int dyn_array_free(struct dyn_array *da);
+size_t dyn_array_size(const struct dyn_array *da);
+int dyn_array_add(struct dyn_array *da, void *element, size_t *index);
+int dyn_array_get(const struct dyn_array *da, size_t index, void **element);
+int dyn_array_set(struct dyn_array *da, size_t index, void *element);
+
+void *memdup(const void *p, size_t len);
+
+#endif
diff --git a/test/t_pkcs11_uv_list b/test/t_pkcs11_uv_list
new file mode 100755
index 0000000..5ba8d05
--- /dev/null
+++ b/test/t_pkcs11_uv_list
@@ -0,0 +1,160 @@
+#!/bin/bash
+# SPDX-License-Identifier: MIT
+# Copyright contributors to the libzpc project
+#
+# List keys exposed by zpcpkcs11.so via p11tool (GnuTLS) or pkcs11-tool
+# (OpenSC).  The script tries p11tool first; if it is not found it falls back
+# to pkcs11-tool.  If neither is available all tests are skipped.
+#
+# Env vars:
+#   ZPCPKCS11_SO      path to zpcpkcs11.so  (default: build/zpcpkcs11.so)
+#   ZPCPKCS11_CONF    path to key list file  (default: ./zpcpkcs11.conf)
+#   OPENSSL_CONF      openssl.conf for the hbkzpc provider (default: build/openssl.conf)
+#   OPENSSL           openssl binary (default: openssl)
+#   P11TOOL           override p11tool binary
+#   PKCS11_TOOL       override pkcs11-tool binary
+#   V                 set to 1 for verbose TAP diagnostics
+
+export OPENSSL_CONF=${OPENSSL_CONF:-"build/openssl.conf"}
+OPENSSL=${OPENSSL:-"openssl"}
+ZPCPKCS11_SO=${ZPCPKCS11_SO:-"${PWD}/build/zpcpkcs11.so"}
+ZPCPKCS11_CONF=${ZPCPKCS11_CONF:-"./zpcpkcs11.conf"}
+P11TOOL=${P11TOOL:-"p11tool"}
+PKCS11_TOOL=${PKCS11_TOOL:-"pkcs11-tool"}
+V=${V:-"0"}
+
+ZPCS=( "p-256"  "p-384"  "p-521"  "ed25519" "ed448" )
+ALGS=( "prime256v1" "secp384r1" "secp521r1" "ED25519" "ED448" )
+
+tap13() {
+	local rc="$1"
+	local idx="$2"
+	local text="$3"
+	local log="$4"
+
+	case ${rc} in
+	0)
+		echo "ok ${idx} - ${text}"
+		if [ ${V} -eq 1 ]; then
+			echo " ---"
+			echo "${log}"
+			echo " ---"
+		fi
+		;;
+	77)
+		echo "ok ${idx} # SKIP"
+		;;
+	*)
+		echo "not ok ${idx} - ${text}"
+		echo " ---"
+		echo "${log}"
+		echo " ---"
+		;;
+	esac
+
+	return 0
+}
+
+# Detect which tool is available; set TOOL_CMD and TOOL_NAME.
+detect_tool() {
+	if command -v "${P11TOOL}" > /dev/null 2>&1; then
+		TOOL_NAME="p11tool"
+		return 0
+	fi
+	if command -v "${PKCS11_TOOL}" > /dev/null 2>&1; then
+		TOOL_NAME="pkcs11-tool"
+		return 0
+	fi
+	TOOL_NAME=""
+	return 1
+}
+
+# list_all_p11tool: list all objects reported by p11tool and check that each
+# expected label appears in the output.
+list_all_p11tool() {
+	local label="$1"
+
+	local out
+	out=$(ZPCPKCS11_CONFIG="${ZPCPKCS11_CONF}" \
+		"${P11TOOL}" \
+		  --provider "${ZPCPKCS11_SO}" \
+		  --list-all 2>&1) || return 99
+
+	echo "${out}"
+
+	# Verify the label is present in the listing.
+	echo "${out}" | grep -q "Label:.*${label}" || {
+		echo "label '${label}' not found in p11tool output"
+		return 1
+	}
+
+	return 0
+}
+
+# list_all_pkcs11tool: list all objects reported by pkcs11-tool and check that
+# each expected label appears in the output.
+list_all_pkcs11tool() {
+	local label="$1"
+
+	local out
+	out=$(ZPCPKCS11_CONFIG="${ZPCPKCS11_CONF}" \
+		"${PKCS11_TOOL}" \
+		  --module "${ZPCPKCS11_SO}" \
+		  --list-objects 2>&1) || return 99
+
+	echo "${out}"
+
+	echo "${out}" | grep -q "label:.*${label}" || {
+		echo "label '${label}' not found in pkcs11-tool output"
+		return 1
+	}
+
+	return 0
+}
+
+list_keys() {
+	[ -r "${ZPCPKCS11_SO}" ]   || return 77
+	[ -r "${ZPCPKCS11_CONF}" ] || return 77
+
+	case "${TOOL_NAME}" in
+	p11tool)
+		list_all_p11tool "$1"
+		;;
+	pkcs11-tool)
+		list_all_pkcs11tool "$1"
+		;;
+	*)
+		return 77
+		;;
+	esac
+}
+
+uv_list() {
+	detect_tool || {
+		echo "1..1"
+		echo "ok 1 # SKIP (neither p11tool nor pkcs11-tool found)"
+		return 0
+	}
+
+	fail=0
+	tc=0
+
+	for ((i=0; i<${#ZPCS[@]}; i++)); do
+		local ZPC="${ZPCS[$i]}"
+		local ALG="${ALGS[$i]}"
+
+		tc=$(( tc + 1 ))
+		log=$(list_keys "${ZPC}")
+		rc="$?"
+		[ ${rc} -ne 0 ] && [ ${rc} -ne 77 ] && fail=1
+		tap13 "${rc}" "${tc}" \
+			"List key '${ZPC}' (${ALG}) via ${TOOL_NAME}" "${log}"
+	done
+
+	return ${fail}
+}
+
+if [[ "$0" == "${BASH_SOURCE[0]}" ]]; then
+	uv_list
+	exit $?
+fi
diff --git a/test/t_pkcs11_uv_prepconf b/test/t_pkcs11_uv_prepconf
new file mode 100755
index 0000000..bd8d726
--- /dev/null
+++ b/test/t_pkcs11_uv_prepconf
@@ -0,0 +1,105 @@
+#!/bin/bash
+# SPDX-License-Identifier: MIT
+# Copyright contributors to the libzpc project
+#
+# Prepare the zpcpkcs11.conf key list for the PKCS#11 UV tests.
+#
+# Each entry maps a PKCS#11 label to the hbkzpc PEM file produced by
+# t_ossl_uv_prepkey.  The same keys (p-256, p-384, p-521, ed25519, ed448)
+# that the hbk-provider tests use are reused here.
+#
+# Env vars:
+#   ZPC_KEY_DIR       directory that holds the *-hbkzpc.pem files (default: .)
+#   ZPCPKCS11_CONF    output config file path (default: ./zpcpkcs11.conf)
+#   V                 set to 1 for verbose TAP diagnostics
+
+ZPC_KEY_DIR=${ZPC_KEY_DIR:-"."}
+ZPCPKCS11_CONF=${ZPCPKCS11_CONF:-"./zpcpkcs11.conf"}
+V=${V:-"0"}
+
+ZPCS=( "p-256"  "p-384"  "p-521"  "ed25519" "ed448" )
+ALGS=( "prime256v1" "secp384r1" "secp521r1" "ED25519" "ED448" )
+
+tap13() {
+	local rc="$1"
+	local idx="$2"
+	local text="$3"
+	local log="$4"
+
+	case ${rc} in
+	0)
+		echo "ok ${idx} - ${text}"
+		if [ ${V} -eq 1 ]; then
+			echo " ---"
+			echo "${log}"
+			echo " ---"
+		fi
+		;;
+	77)
+		echo "ok ${idx} # SKIP"
+		;;
+	*)
+		echo "not ok ${idx} - ${text}"
+		echo " ---"
+		echo "${log}"
+		echo " ---"
+		;;
+	esac
+
+	return 0
+}
+
+write_conf() {
+	local conf="$1"
+	local out=""
+
+	out+="# zpcpkcs11 key list generated by t_pkcs11_uv_prepconf"$'\n'
+	out+="# $(date -u)"$'\n'
+
+	for ((i=0; i<${#ZPCS[@]}; i++)); do
+		local ZPC="${ZPCS[$i]}"
+		local ALG="${ALGS[$i]}"
+		local ZPC_PEM="${ZPC_KEY_DIR}/${ZPC}-hbkzpc.pem"
+
+		[ -r "${ZPC_PEM}" ] || {
+			echo "  key file not found, skipping: ${ZPC_PEM}" >&2
+			continue
+		}
+
+		out+="${ZPC}=$(realpath "${ZPC_PEM}")"$'\n'
+	done
+
+	printf '%s' "${out}" > "${conf}" 2>&1
+	echo "${out}"
+}
+
+main() {
+	fail=0
+	tc=0
+
+	tc=$(( tc + 1 ))
+
+	# Require at least one key file to be present.
+	local found=0
+	for ((i=0; i<${#ZPCS[@]}; i++)); do
+		local ZPC="${ZPCS[$i]}"
+		[ -r "${ZPC_KEY_DIR}/${ZPC}-hbkzpc.pem" ] && found=$(( found + 1 ))
+	done
+
+	if [ ${found} -eq 0 ]; then
+		tap13 77 "${tc}" "Write zpcpkcs11.conf (no key files found)" ""
+		return 0
+	fi
+
+	log=$(write_conf "${ZPCPKCS11_CONF}")
+	rc="$?"
+	[ ${rc} -ne 0 ] && fail=1
+	tap13 "${rc}" "${tc}" "Write zpcpkcs11.conf (${found} key(s))" "${log}"
+
+	return ${fail}
+}
+
+if [[ "$0" == "${BASH_SOURCE[0]}" ]]; then
+	main
+	exit $?
+fi
diff --git a/test/t_pkcs11_uv_sign_verify b/test/t_pkcs11_uv_sign_verify
new file mode 100755
index 0000000..81f9cae
--- /dev/null
+++ b/test/t_pkcs11_uv_sign_verify
@@ -0,0 +1,514 @@
+#!/bin/bash
+# SPDX-License-Identifier: MIT
+# Copyright contributors to the libzpc project
+#
+# Sign and verify test for zpcpkcs11.so using pkcs11-tool (OpenSC) or
+# p11tool (GnuTLS).  pkcs11-tool is preferred; p11tool is used as a fallback.
+#
+# The script reuses the same set of hbkzpc PEM key files as the hbk-provider
+# sign/verify tests (t_ossl_uv_sign_verify).  For each algorithm the test:
+#
+#   pkcs11-tool: signs a random message, verifies via the PKCS#11 public key,
+#                then cross-verifies with OpenSSL using the cleartext public key.
+#   p11tool:     runs --test-sign which performs an internal PKCS#11 sign+verify
+#                round-trip; no signature file is produced so no cross-verify.
+#
+# Tool / mechanism mapping
+#   ECDSA (prime256v1 / secp384r1 / secp521r1):
+#     pkcs11-tool: --mechanism ECDSA-SHA256
+#     p11tool:     --test-sign --hash=SHA256
+#   EdDSA (ED25519 / ED448):
+#     pkcs11-tool: --mechanism EDDSA
+#     p11tool:     --test-sign --hash=SHA512   (Ed25519)
+#                  --test-sign --hash=SHAKE-256 (Ed448)
+#
+# Signature format note
+#   PKCS#11 ECDSA produces raw (r||s) signatures.  OpenSSL expects DER-encoded
+#   ECDSA signatures, so the verification step converts the raw signature with
+#   the helper function raw_to_der_sig before calling `openssl dgst -verify`.
+#
+# Env vars:
+#   ZPCPKCS11_SO      path to zpcpkcs11.so  (default: build/zpcpkcs11.so)
+#   ZPCPKCS11_CONF    path to key list file  (default: ./zpcpkcs11.conf)
+#   OPENSSL_CONF      openssl.conf for the hbkzpc provider (default: build/openssl.conf)
+#   ZPC_KEY_DIR       directory holding *-hbkzpc.pem and *-pub.pem files (default: .)
+#   ZPC_SEC_DIR       directory holding cleartext *.key files             (default: .)
+#   OPENSSL           openssl binary (default: openssl)
+#   P11TOOL           override p11tool binary
+#   PKCS11_TOOL       override pkcs11-tool binary
+#   V                 set to 1 for verbose TAP diagnostics
+
+export OPENSSL_CONF=${OPENSSL_CONF:-"build/openssl.conf"}
+OPENSSL=${OPENSSL:-"openssl"}
+ZPCPKCS11_SO=${ZPCPKCS11_SO:-"${PWD}/build/zpcpkcs11.so"}
+ZPCPKCS11_CONF=${ZPCPKCS11_CONF:-"./zpcpkcs11.conf"}
+ZPC_KEY_DIR=${ZPC_KEY_DIR:-"."}
+ZPC_SEC_DIR=${ZPC_SEC_DIR:-"."}
+P11TOOL=${P11TOOL:-"p11tool"}
+PKCS11_TOOL=${PKCS11_TOOL:-"pkcs11-tool"}
+V=${V:-"0"}
+
+# Algorithm tables – same layout as t_ossl_uv_sign_verify.
+ALGS=( "prime256v1" "secp384r1" "secp521r1" "ED25519"  "ED448"  )
+ZPCS=( "p-256"      "p-384"     "p-521"     "ed25519"  "ed448"  )
+CLRS=( "p256"       "p384"      "p521"      "ed25519"  "ed448"  )
+
+TTMPDIR=$(mktemp -d)
+MSG="${TTMPDIR}/msg"
+MSG_LARGE="${TTMPDIR}/msg_large"
+SIG="${TTMPDIR}/msg.p11.sig"
+SIG_DER="${TTMPDIR}/msg.p11.sig.der"
+SIG_LARGE="${TTMPDIR}/msg_large.p11.sig"
+SIG_LARGE_DER="${TTMPDIR}/msg_large.p11.sig.der"
+
+# Small message (< 1024 bytes): pkcs11-tool uses single-shot C_Sign / C_Verify.
+MSG_SIZE=800
+# Large message (> 1024 bytes): pkcs11-tool falls back to C_SignUpdate /
+# C_SignFinal and C_VerifyUpdate / C_VerifyFinal (multi-part).  CKM_EDDSA does
+# not support multi-part, so the large-message test covers EC curves only.
+MSG_SIZE_LARGE=2000
+
+tap13() {
+	local rc="$1"
+	local idx="$2"
+	local text="$3"
+	local log="$4"
+
+	case ${rc} in
+	0)
+		echo "ok ${idx} - ${text}"
+		if [ ${V} -eq 1 ]; then
+			echo " ---"
+			echo "${log}"
+			echo " ---"
+		fi
+		;;
+	77)
+		echo "ok ${idx} # SKIP ${text}"
+		;;
+	*)
+		echo "not ok ${idx} - ${text}"
+		echo " ---"
+		echo "${log}"
+		echo " ---"
+		;;
+	esac
+
+	return 0
+}
+
+# detect_tool: prefer pkcs11-tool; fall back to p11tool.
+# Sets TOOL_NAME and returns 0 if either is found, 1 if neither is.
+detect_tool() {
+	if command -v "${PKCS11_TOOL}" > /dev/null 2>&1; then
+		TOOL_NAME="pkcs11-tool"
+		return 0
+	fi
+	if command -v "${P11TOOL}" > /dev/null 2>&1; then
+		TOOL_NAME="p11tool"
+		return 0
+	fi
+	TOOL_NAME=""
+	return 1
+}
+
+###############################################################################
+# p11tool helpers
+###############################################################################
+
+# p11tool_url_for_label: return the PKCS#11 URL for the private key with the
+# given label, as reported by p11tool --list-all.
+p11tool_url_for_label() {
+	local label="$1"
+
+	ZPCPKCS11_CONFIG="${ZPCPKCS11_CONF}" \
+		"${P11TOOL}" \
+		  --provider "${ZPCPKCS11_SO}" \
+		  --list-all 2>/dev/null \
+	| awk -v lbl="${label}" '
+		/^Object/ { url=""; found_label=0; found_priv=0 }
+		/URL:/    { url=$2 }
+		/Label:/  && $2 == lbl { found_label=1 }
+		/Type:.*[Pp]rivate/    { found_priv=1 }
+		found_label && found_priv && url != "" { print url; exit }
+	'
+}
+
+# p11tool_test_sign: run p11tool --test-sign for the key identified by URL.
+# $1: PKCS#11 URL of the private key
+# $2: optional --hash=<ALG> argument (pass empty string for EdDSA)
+#
+# --test-sign performs a PKCS#11 sign+verify round-trip internally; it does
+# not write a signature file and cannot be used for cross-verification.
+p11tool_test_sign() {
+	local url="$1"
+	local hash_flag="$2"   # e.g. "--hash=SHA256" or "" for EdDSA
+
+	ZPCPKCS11_CONFIG="${ZPCPKCS11_CONF}" \
+		"${P11TOOL}" \
+		  --provider "${ZPCPKCS11_SO}" \
+		  --test-sign \
+		  ${hash_flag} \
+		  "${url}" 2>&1
+}
+
+###############################################################################
+# pkcs11-tool helpers
+###############################################################################
+
+# pkcs11tool_id_for_label: return the CKA_ID hex string for a given label.
+#
+# CKA_ID is set to the raw file line-number of the label's entry in the config
+# (see config.c: lineno is incremented for every line, including comments and
+# blanks).  pkcs11-tool --id expects the value as a hex string of the raw
+# CK_ULONG bytes in the host's native byte order (8 bytes on LP64).
+# s390x is big-endian, so CK_ULONG 6 → 0000000000000006.
+#
+# Example (big-endian): label on line 6 → CK_ULONG 6 → BE bytes
+#                       00 00 00 00 00 00 00 06 → hex string "0000000000000006"
+pkcs11tool_id_for_label() {
+	local label="$1"
+	local lineno
+
+	lineno=$(grep -n "^${label}=" "${ZPCPKCS11_CONF}" | cut -d: -f1)
+	[ -n "${lineno}" ] || return 1
+
+	# Format as 16 hex digits (8 bytes) in native byte order.
+	python3 -c "
+import sys, struct
+n = int(sys.argv[1])
+# sys.byteorder is 'big' on s390x, 'little' on x86.
+order = '>' if sys.byteorder == 'big' else '<'
+print(struct.pack(order + 'Q', n).hex())
+" "${lineno}"
+}
+
+# pkcs11tool_sign: sign a message file using pkcs11-tool.
+# $1: CKA_ID hex string
+# $2: mechanism (e.g. ECDSA-SHA256 or EDDSA)
+# $3: input message file  (default: MSG)
+# $4: output signature file (default: SIG)
+# Uses --id to select the key because --label does not reliably select the
+# correct object when multiple objects share a label prefix.
+pkcs11tool_sign() {
+	local id="$1"
+	local mechanism="$2"
+	local input_file="${3:-${MSG}}"
+	local output_file="${4:-${SIG}}"
+
+	ZPCPKCS11_CONFIG="${ZPCPKCS11_CONF}" \
+		"${PKCS11_TOOL}" \
+		  --module "${ZPCPKCS11_SO}" \
+		  --sign \
+		  --mechanism "${mechanism}" \
+		  --id "${id}" \
+		  --input-file "${input_file}" \
+		  --output-file "${output_file}" 2>&1
+}
+
+# pkcs11tool_verify: verify a signature against a message file using pkcs11-tool.
+# $1: CKA_ID hex string
+# $2: mechanism
+# $3: input message file    (default: MSG)
+# $4: signature file        (default: SIG)
+# Uses --id for the same reason as pkcs11tool_sign.
+pkcs11tool_verify() {
+	local id="$1"
+	local mechanism="$2"
+	local input_file="${3:-${MSG}}"
+	local sig_file="${4:-${SIG}}"
+
+	ZPCPKCS11_CONFIG="${ZPCPKCS11_CONF}" \
+		"${PKCS11_TOOL}" \
+		  --module "${ZPCPKCS11_SO}" \
+		  --verify \
+		  --mechanism "${mechanism}" \
+		  --id "${id}" \
+		  --input-file "${input_file}" \
+		  --signature-file "${sig_file}" 2>&1
+}
+
+###############################################################################
+# Signature conversion helpers
+###############################################################################
+
+# raw_to_der_sig: convert a raw PKCS#11 ECDSA signature (r||s, each
+# prime_bytes wide) into a DER-encoded ECDSA_SIG for OpenSSL.
+# Args: <prime_bytes> <raw_sig_file> <der_sig_file>
+#
+# DER length encoding note: for P-521 the SEQUENCE body is up to 138 bytes,
+# which exceeds the 127-byte threshold for single-byte DER lengths.  The
+# long-form encoding (0x81 <len> for lengths 128-255) must be used; a plain
+# bytes([0x30, len(seq)]) would produce a corrupt blob and cause OpenSSL to
+# report "unsupported algorithm" when it cannot parse the structure.
+raw_to_der_sig() {
+	local prime_bytes="$1"
+	local raw_file="$2"
+	local der_file="$3"
+
+	# Use Python if available (most reliable for arbitrary-length BIGNUMs).
+	if command -v python3 > /dev/null 2>&1; then
+		python3 - "${prime_bytes}" "${raw_file}" "${der_file}" << 'PYEOF'
+import sys
+
+prime_bytes = int(sys.argv[1])
+raw_file    = sys.argv[2]
+der_file    = sys.argv[3]
+
+raw = open(raw_file, "rb").read()
+if len(raw) != 2 * prime_bytes:
+    sys.exit(f"unexpected sig length {len(raw)}, want {2*prime_bytes}")
+
+def der_length(n):
+    """Encode n as a DER length field (short or long form)."""
+    if n < 0x80:
+        return bytes([n])
+    elif n < 0x100:
+        return bytes([0x81, n])
+    else:
+        return bytes([0x82, (n >> 8) & 0xff, n & 0xff])
+
+def encode_integer(n_bytes):
+    # Strip leading zeros but keep at least one byte; prepend 0x00 if high bit set.
+    i = 0
+    while i < len(n_bytes) - 1 and n_bytes[i] == 0:
+        i += 1
+    n_bytes = n_bytes[i:]
+    if n_bytes[0] & 0x80:
+        n_bytes = b'\x00' + n_bytes
+    return bytes([0x02]) + der_length(len(n_bytes)) + n_bytes
+
+r = encode_integer(raw[:prime_bytes])
+s = encode_integer(raw[prime_bytes:])
+seq = r + s
+der = bytes([0x30]) + der_length(len(seq)) + seq
+open(der_file, "wb").write(der)
+PYEOF
+		return $?
+	fi
+
+	# Fallback: openssl asn1parse -genconf is complex; skip cross-verification.
+	return 77
+}
+
+###############################################################################
+# Per-algorithm sign/verify logic
+###############################################################################
+
+# ecdsa_sign_verify: sign with PKCS#11 private key, verify with PKCS#11 public
+# key, then cross-verify with OpenSSL using the cleartext public key.
+# $1: zpc  - PKCS#11 label, e.g. "p-256"
+# $2: clr  - cleartext key prefix, e.g. "p256"
+# $3: prime_bytes - byte-length of prime (32 / 48 / 66)
+# $4: msg_file    - message file to sign  (default: MSG)
+# $5: sig_file    - raw signature file    (default: SIG)
+# $6: sig_der_file - DER signature file   (default: SIG_DER)
+ecdsa_sign_verify() {
+	local zpc="$1"
+	local clr="$2"
+	local prime_bytes="$3"
+	local msg_file="${4:-${MSG}}"
+	local sig_file="${5:-${SIG}}"
+	local sig_der_file="${6:-${SIG_DER}}"
+
+	[ -r "${ZPCPKCS11_SO}" ]   || return 77
+	[ -r "${ZPCPKCS11_CONF}" ] || return 77
+
+	local CLR_PUB_PEM="${ZPC_KEY_DIR}/${clr}-pub.pem"
+	[ -r "${CLR_PUB_PEM}" ] || return 77
+
+	local out=""
+
+	case "${TOOL_NAME}" in
+	pkcs11-tool)
+		local id
+		id=$(pkcs11tool_id_for_label "${zpc}") || return 77
+
+		rm -f "${sig_file}" "${sig_der_file}"
+
+		local sign_out
+		sign_out=$(pkcs11tool_sign "${id}" "ECDSA-SHA256" "${msg_file}" "${sig_file}")
+		[ $? -eq 0 ] || { echo "${sign_out}"; return 99; }
+		out+="${sign_out}"$'\n'"sign ok"
+
+		local verify_out
+		verify_out=$(pkcs11tool_verify "${id}" "ECDSA-SHA256" "${msg_file}" "${sig_file}")
+		[ $? -eq 0 ] || { echo "${out}"; echo "${verify_out}"; return 99; }
+		out+=$'\n'"verify ok (pkcs11-tool)"
+
+		# Cross-verify: convert raw (r||s) to DER and verify with OpenSSL.
+		if raw_to_der_sig "${prime_bytes}" "${sig_file}" "${sig_der_file}" 2>&1; then
+			local xv_out
+			xv_out=$(${OPENSSL} dgst		\
+				  -verify "${CLR_PUB_PEM}"	\
+				  -sha256			\
+				  -signature "${sig_der_file}"	\
+				  "${msg_file}" 2>&1)
+			[ $? -eq 0 ] || { echo "${out}"; echo "${xv_out}"; return 99; }
+			out+=$'\n'"cross-verify ok (openssl)"
+		fi
+		;;
+	p11tool)
+		local url
+		url=$(p11tool_url_for_label "${zpc}") || return 77
+		[ -n "${url}" ] || return 77
+
+		local ts_out
+		ts_out=$(p11tool_test_sign "${url}" "--hash=SHA256")
+		[ $? -eq 0 ] || { echo "${ts_out}"; return 99; }
+		out+="${ts_out}"$'\n'"sign/verify ok (p11tool --test-sign)"
+		;;
+	esac
+
+	echo "${out}"
+	return 0
+}
+
+# eddsa_sign_verify: sign with PKCS#11 private key, verify with PKCS#11 public
+# key, then cross-verify with OpenSSL using the cleartext public key.
+# EdDSA signatures are already raw (not DER-encoded) so no conversion needed.
+eddsa_sign_verify() {
+	local zpc="$1"   # PKCS#11 label, e.g. "ed25519"
+	local clr="$2"   # cleartext key prefix, e.g. "ed25519"
+
+	[ -r "${ZPCPKCS11_SO}" ]   || return 77
+	[ -r "${ZPCPKCS11_CONF}" ] || return 77
+
+	local CLR_PUB_PEM="${ZPC_KEY_DIR}/${clr}-pub.pem"
+
+	local out=""
+
+	case "${TOOL_NAME}" in
+	pkcs11-tool)
+		# Cross-verify requires the cleartext public key.
+		[ -r "${CLR_PUB_PEM}" ] || return 77
+
+		local id
+		id=$(pkcs11tool_id_for_label "${zpc}") || return 77
+
+		rm -f "${SIG}"
+
+		local sign_out
+		sign_out=$(pkcs11tool_sign "${id}" "EDDSA")
+		[ $? -eq 0 ] || { echo "${sign_out}"; return 99; }
+		out+="${sign_out}"$'\n'"sign ok"
+
+		local verify_out
+		verify_out=$(pkcs11tool_verify "${id}" "EDDSA")
+		[ $? -eq 0 ] || { echo "${out}"; echo "${verify_out}"; return 99; }
+		out+=$'\n'"verify ok (pkcs11-tool)"
+
+		# Cross-verify with OpenSSL (EdDSA signature format is already compatible).
+		local xv_out
+		xv_out=$(${OPENSSL} dgst			\
+			  -verify "${CLR_PUB_PEM}"		\
+			  -signature "${SIG}"			\
+			  "${MSG}" 2>&1)
+		[ $? -eq 0 ] || { echo "${out}"; echo "${xv_out}"; return 99; }
+		out+=$'\n'"cross-verify ok (openssl)"
+		;;
+	p11tool)
+		local url
+		url=$(p11tool_url_for_label "${zpc}") || return 77
+		[ -n "${url}" ] || return 77
+
+		# p11tool --test-sign pre-hashes the data before passing it to
+		# C_Sign.  The hash algorithm must match what the EdDSA variant
+		# uses internally: SHA-512 for Ed25519, SHAKE-256 for Ed448.
+		local hash_flag
+		case "${zpc}" in
+		ed25519) hash_flag="--hash=SHA512"   ;;
+		ed448)   hash_flag="--hash=SHAKE-256" ;;
+		*)       return 77 ;;
+		esac
+
+		local ts_out
+		ts_out=$(p11tool_test_sign "${url}" "${hash_flag}")
+		[ $? -eq 0 ] || { echo "${ts_out}"; return 99; }
+		out+="${ts_out}"$'\n'"sign/verify ok (p11tool --test-sign)"
+		;;
+	esac
+
+	echo "${out}"
+	return 0
+}
+
+###############################################################################
+# Main test loop
+###############################################################################
+
+uv_sign_verify() {
+	detect_tool || {
+		echo "1..1"
+		echo "ok 1 # SKIP (neither pkcs11-tool nor p11tool found)"
+		return 0
+	}
+
+	dd if=/dev/random of="${MSG}"       bs=${MSG_SIZE}       count=1 > /dev/null 2>&1 || return 1
+	dd if=/dev/random of="${MSG_LARGE}" bs=${MSG_SIZE_LARGE} count=1 > /dev/null 2>&1 || return 1
+
+	fail=0
+	tc=0
+
+	for ((i=0; i<${#ALGS[@]}; i++)); do
+		local ALG="${ALGS[$i]}"
+		local ZPC="${ZPCS[$i]}"
+		local CLR="${CLRS[$i]}"
+
+		if echo "${ALG}" | grep -iq "^ED"; then
+			# EdDSA single-part.
+			tc=$(( tc + 1 ))
+			log=$(eddsa_sign_verify "${ZPC}" "${CLR}")
+			rc="$?"
+			[ ${rc} -ne 0 ] && [ ${rc} -ne 77 ] && fail=1
+			tap13 "${rc}" "${tc}" \
+				"PKCS#11 sign/verify (EdDSA, ${ALG}) via ${TOOL_NAME}" "${log}"
+
+			# EdDSA multi-part slot – always skipped: CKM_EDDSA has no
+			# C_SignUpdate/C_SignFinal support regardless of tool.
+			tc=$(( tc + 1 ))
+			tap13 77 "${tc}" \
+				"PKCS#11 sign/verify multi-part (EdDSA, ${ALG}) - SKIP (CKM_EDDSA has no multi-part support)" ""
+		else
+			# ECDSA: determine prime byte-length from algorithm name.
+			local prime_bytes
+			case "${ALG}" in
+			prime256v1) prime_bytes=32 ;;
+			secp384r1)  prime_bytes=48 ;;
+			secp521r1)  prime_bytes=66 ;;
+			*)          prime_bytes=32 ;;
+			esac
+
+			# Single-part test (MSG < 1024 bytes → C_Sign / C_Verify).
+			tc=$(( tc + 1 ))
+			log=$(ecdsa_sign_verify "${ZPC}" "${CLR}" "${prime_bytes}")
+			rc="$?"
+			[ ${rc} -ne 0 ] && [ ${rc} -ne 77 ] && fail=1
+			tap13 "${rc}" "${tc}" \
+				"PKCS#11 sign/verify (ECDSA, ${ALG}) via ${TOOL_NAME}" "${log}"
+
+			# Multi-part test (MSG_LARGE > 1024 bytes → C_SignUpdate/Final).
+			# p11tool has no API to drive multi-part operations; skip it.
+			tc=$(( tc + 1 ))
+			if [ "${TOOL_NAME}" = "pkcs11-tool" ]; then
+				log=$(ecdsa_sign_verify "${ZPC}" "${CLR}" "${prime_bytes}" \
+					"${MSG_LARGE}" "${SIG_LARGE}" "${SIG_LARGE_DER}")
+				rc="$?"
+				[ ${rc} -ne 0 ] && [ ${rc} -ne 77 ] && fail=1
+				tap13 "${rc}" "${tc}" \
+					"PKCS#11 sign/verify multi-part (ECDSA, ${ALG}) via ${TOOL_NAME}" "${log}"
+			else
+				tap13 77 "${tc}" \
+					"PKCS#11 sign/verify multi-part (ECDSA, ${ALG}) - SKIP (p11tool cannot drive multi-part)" ""
+			fi
+		fi
+	done
+
+	rm -rf "${TTMPDIR}"
+	return ${fail}
+}
+
+if [[ "$0" == "${BASH_SOURCE[0]}" ]]; then
+	uv_sign_verify
+	exit $?
+fi
diff --git a/zpcpkcs11.map b/zpcpkcs11.map
new file mode 100644
index 0000000..695b7e0
--- /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:
+	*;
+};