Provides access to all PKCS#11 functions. More...

#include <p11.h>

Public Member Functions
bool	C_CancelFunction (SessionHandle session, ReturnValue *return_value=ThrowException) const

bool	C_CloseAllSessions (SlotId slot_id, ReturnValue *return_value=ThrowException) const

bool	C_CloseSession (SessionHandle session, ReturnValue *return_value=ThrowException) const

bool	C_CopyObject (SessionHandle session, ObjectHandle object, Attribute attribute_template_ptr, Ulong count, ObjectHandle new_object_ptr, ReturnValue *return_value=ThrowException) const

bool	C_CreateObject (SessionHandle session, Attribute attribute_template_ptr, Ulong count, ObjectHandle object_ptr, ReturnValue *return_value=ThrowException) const

bool	C_Decrypt (SessionHandle session, Byte encrypted_data_ptr, Ulong encrypted_data_len, Byte data_ptr, Ulong data_len_ptr, ReturnValue return_value=ThrowException) const

template<typename TAllocA , typename TAllocB >
bool	C_Decrypt (SessionHandle session, const std::vector< uint8_t, TAllocA > &encrypted_data, std::vector< uint8_t, TAllocB > &decrypted_data, ReturnValue *return_value=ThrowException) const

bool	C_DecryptDigestUpdate (SessionHandle session, Byte encrypted_part_ptr, Ulong encrypted_part_len, Byte part_ptr, Ulong part_len_ptr, ReturnValue return_value=ThrowException) const

bool	C_DecryptFinal (SessionHandle session, Byte last_part_ptr, Ulong last_part_len_ptr, ReturnValue *return_value=ThrowException) const

bool	C_DecryptInit (SessionHandle session, Mechanism mechanism_ptr, ObjectHandle key, ReturnValue return_value=ThrowException) const

bool	C_DecryptUpdate (SessionHandle session, Byte encrypted_part_ptr, Ulong encrypted_part_len, Byte part_ptr, Ulong part_len_ptr, ReturnValue return_value=ThrowException) const

bool	C_DecryptVerifyUpdate (SessionHandle session, Byte encrypted_part_ptr, Ulong encrypted_part_len, Byte part_ptr, Ulong part_len_ptr, ReturnValue return_value=ThrowException) const

bool	C_DeriveKey (SessionHandle session, Mechanism mechanism_ptr, ObjectHandle base_key, Attribute attribute_template_ptr, Ulong attribute_count, ObjectHandle key_ptr, ReturnValue return_value=ThrowException) const

bool	C_DestroyObject (SessionHandle session, ObjectHandle object, ReturnValue *return_value=ThrowException) const

bool	C_Digest (SessionHandle session, Byte data_ptr, Ulong data_len, Byte digest_ptr, Ulong digest_len_ptr, ReturnValue return_value=ThrowException) const

bool	C_DigestEncryptUpdate (SessionHandle session, Byte part_ptr, Ulong part_len, Byte encrypted_part_ptr, Ulong encrypted_part_len_ptr, ReturnValue return_value=ThrowException) const

bool	C_DigestFinal (SessionHandle session, Byte digest_ptr, Ulong digest_len_ptr, ReturnValue *return_value=ThrowException) const

bool	C_DigestInit (SessionHandle session, Mechanism mechanism_ptr, ReturnValue return_value=ThrowException) const

bool	C_DigestKey (SessionHandle session, ObjectHandle key, ReturnValue *return_value=ThrowException) const

bool	C_DigestUpdate (SessionHandle session, Byte part_ptr, Ulong part_len, ReturnValue return_value=ThrowException) const

bool	C_Encrypt (SessionHandle session, Byte data_ptr, Ulong data_len, Byte encrypted_data, Ulong encrypted_data_len_ptr, ReturnValue return_value=ThrowException) const

template<typename TAllocA , typename TAllocB >
bool	C_Encrypt (SessionHandle session, const std::vector< uint8_t, TAllocA > &plaintext_data, std::vector< uint8_t, TAllocB > &encrypted_data, ReturnValue *return_value=ThrowException) const

bool	C_EncryptFinal (SessionHandle session, Byte last_encrypted_part_ptr, Ulong last_encrypted_part_len_ptr, ReturnValue *return_value=ThrowException) const

bool	C_EncryptInit (SessionHandle session, Mechanism mechanism_ptr, ObjectHandle key, ReturnValue return_value=ThrowException) const

bool	C_EncryptUpdate (SessionHandle session, Byte part_ptr, Ulong part_len, Byte encrypted_part_ptr, Ulong encrypted_part_len_ptr, ReturnValue return_value=ThrowException) const

bool	C_Finalize (VoidPtr reserved, ReturnValue *return_value=ThrowException) const

bool	C_FindObjects (SessionHandle session, ObjectHandle object_ptr, Ulong max_object_count, Ulong object_count_ptr, ReturnValue *return_value=ThrowException) const

bool	C_FindObjectsFinal (SessionHandle session, ReturnValue *return_value=ThrowException) const

bool	C_FindObjectsInit (SessionHandle session, Attribute attribute_template_ptr, Ulong count, ReturnValue return_value=ThrowException) const

bool	C_GenerateKey (SessionHandle session, Mechanism mechanism_ptr, Attribute attribute_template_ptr, Ulong count, ObjectHandle key_ptr, ReturnValue return_value=ThrowException) const

bool	C_GenerateKeyPair (SessionHandle session, Mechanism mechanism_ptr, Attribute public_key_template_ptr, Ulong public_key_attribute_count, Attribute private_key_template_ptr, Ulong private_key_attribute_count, ObjectHandle public_key_ptr, ObjectHandle private_key_ptr, ReturnValue return_value=ThrowException) const

bool	C_GenerateRandom (SessionHandle session, Byte random_data_ptr, Ulong random_len, ReturnValue return_value=ThrowException) const

bool	C_GetAttributeValue (SessionHandle session, ObjectHandle object, Attribute attribute_template_ptr, Ulong count, ReturnValue return_value=ThrowException) const

template<typename TAlloc >
bool	C_GetAttributeValue (SessionHandle session, ObjectHandle object, std::map< AttributeType, std::vector< uint8_t, TAlloc > > &attribute_values, ReturnValue *return_value=ThrowException) const

bool	C_GetFunctionStatus (SessionHandle session, ReturnValue *return_value=ThrowException) const

bool	C_GetInfo (Info info_ptr, ReturnValue return_value=ThrowException) const

bool	C_GetMechanismInfo (SlotId slot_id, MechanismType type, MechanismInfo info_ptr, ReturnValue return_value=ThrowException) const

bool	C_GetMechanismList (SlotId slot_id, MechanismType mechanism_list_ptr, Ulong count_ptr, ReturnValue *return_value=ThrowException) const

bool	C_GetMechanismList (SlotId slot_id, std::vector< MechanismType > &mechanisms, ReturnValue *return_value=ThrowException) const

bool	C_GetObjectSize (SessionHandle session, ObjectHandle object, Ulong size_ptr, ReturnValue return_value=ThrowException) const

bool	C_GetOperationState (SessionHandle session, Byte operation_state_ptr, Ulong operation_state_len_ptr, ReturnValue *return_value=ThrowException) const

bool	C_GetSessionInfo (SessionHandle session, SessionInfo info_ptr, ReturnValue return_value=ThrowException) const

bool	C_GetSlotInfo (SlotId slot_id, SlotInfo info_ptr, ReturnValue return_value=ThrowException) const

bool	C_GetSlotList (Bbool token_present, SlotId slot_list_ptr, Ulong count_ptr, ReturnValue *return_value=ThrowException) const

bool	C_GetSlotList (bool token_present, std::vector< SlotId > &slot_ids, ReturnValue *return_value=ThrowException) const

bool	C_GetTokenInfo (SlotId slot_id, TokenInfo info_ptr, ReturnValue return_value=ThrowException) const

bool	C_Initialize (VoidPtr init_args, ReturnValue *return_value=ThrowException) const

template<typename TAlloc >
bool	C_InitPIN (SessionHandle session, const std::vector< uint8_t, TAlloc > &pin, ReturnValue *return_value=ThrowException) const

bool	C_InitPIN (SessionHandle session, Utf8Char pin_ptr, Ulong pin_len, ReturnValue return_value=ThrowException) const

template<typename TAlloc >
bool	C_InitToken (SlotId slot_id, const std::vector< uint8_t, TAlloc > &so_pin, const std::string &label, ReturnValue *return_value=ThrowException) const

bool	C_InitToken (SlotId slot_id, Utf8Char so_pin_ptr, Ulong so_pin_len, Utf8Char label_ptr, ReturnValue *return_value=ThrowException) const

template<typename TAlloc >
bool	C_Login (SessionHandle session, UserType user_type, const std::vector< uint8_t, TAlloc > &pin, ReturnValue *return_value=ThrowException) const

bool	C_Login (SessionHandle session, UserType user_type, Utf8Char pin_ptr, Ulong pin_len, ReturnValue return_value=ThrowException) const

bool	C_Logout (SessionHandle session, ReturnValue *return_value=ThrowException) const

bool	C_OpenSession (SlotId slot_id, Flags flags, VoidPtr application, Notify notify, SessionHandle session_ptr, ReturnValue return_value=ThrowException) const

bool	C_SeedRandom (SessionHandle session, const Byte seed_ptr, Ulong seed_len, ReturnValue return_value=ThrowException) const

bool	C_SetAttributeValue (SessionHandle session, ObjectHandle object, Attribute attribute_template_ptr, Ulong count, ReturnValue return_value=ThrowException) const

template<typename TAlloc >
bool	C_SetAttributeValue (SessionHandle session, ObjectHandle object, std::map< AttributeType, std::vector< uint8_t, TAlloc > > &attribute_values, ReturnValue *return_value=ThrowException) const

bool	C_SetOperationState (SessionHandle session, Byte operation_state_ptr, Ulong operation_state_len, ObjectHandle encryption_key, ObjectHandle authentication_key, ReturnValue return_value=ThrowException) const

template<typename TAlloc >
bool	C_SetPIN (SessionHandle session, const std::vector< uint8_t, TAlloc > &old_pin, const std::vector< uint8_t, TAlloc > &new_pin, ReturnValue *return_value=ThrowException) const

bool	C_SetPIN (SessionHandle session, Utf8Char old_pin_ptr, Ulong old_len, Utf8Char new_pin_ptr, Ulong new_len, ReturnValue *return_value=ThrowException) const

bool	C_Sign (SessionHandle session, const Byte data_ptr, Ulong data_len, Byte signature_ptr, Ulong signature_len_ptr, ReturnValue return_value=ThrowException) const

template<typename TAllocA , typename TAllocB >
bool	C_Sign (SessionHandle session, const std::vector< uint8_t, TAllocA > &data, std::vector< uint8_t, TAllocB > &signature, ReturnValue *return_value=ThrowException) const

bool	C_SignEncryptUpdate (SessionHandle session, Byte part_ptr, Ulong part_len, Byte encrypted_part_ptr, Ulong encrypted_part_len_ptr, ReturnValue return_value=ThrowException) const

bool	C_SignFinal (SessionHandle session, Byte signature_ptr, Ulong signature_len_ptr, ReturnValue *return_value=ThrowException) const

template<typename TAlloc >
bool	C_SignFinal (SessionHandle session, std::vector< uint8_t, TAlloc > &signature, ReturnValue *return_value=ThrowException) const

bool	C_SignInit (SessionHandle session, Mechanism mechanism_ptr, ObjectHandle key, ReturnValue return_value=ThrowException) const

bool	C_SignRecover (SessionHandle session, Byte data_ptr, Ulong data_len, Byte signature_ptr, Ulong signature_len_ptr, ReturnValue return_value=ThrowException) const

bool	C_SignRecoverInit (SessionHandle session, Mechanism mechanism_ptr, ObjectHandle key, ReturnValue return_value=ThrowException) const

bool	C_SignUpdate (SessionHandle session, const Byte part_ptr, Ulong part_len, ReturnValue return_value=ThrowException) const

template<typename TAlloc >
bool	C_SignUpdate (SessionHandle session, const std::vector< uint8_t, TAlloc > &part, ReturnValue *return_value=ThrowException) const

bool	C_UnwrapKey (SessionHandle session, Mechanism mechanism_ptr, ObjectHandle unwrapping_key, Byte wrapped_key_ptr, Ulong wrapped_key_len, Attribute attribute_template_ptr, Ulong attribute_count, ObjectHandle key_ptr, ReturnValue *return_value=ThrowException) const

bool	C_Verify (SessionHandle session, const Byte data_ptr, Ulong data_len, const Byte signature_ptr, Ulong signature_len, ReturnValue *return_value=ThrowException) const

template<typename TAllocA , typename TAllocB >
bool	C_Verify (SessionHandle session, const std::vector< uint8_t, TAllocA > &data, std::vector< uint8_t, TAllocB > &signature, ReturnValue *return_value=ThrowException) const

bool	C_VerifyFinal (SessionHandle session, const Byte signature_ptr, Ulong signature_len, ReturnValue return_value=ThrowException) const

bool	C_VerifyInit (SessionHandle session, Mechanism mechanism_ptr, ObjectHandle key, ReturnValue return_value=ThrowException) const

bool	C_VerifyRecover (SessionHandle session, Byte signature_ptr, Ulong signature_len, Byte data_ptr, Ulong data_len_ptr, ReturnValue return_value=ThrowException) const

bool	C_VerifyRecoverInit (SessionHandle session, Mechanism mechanism_ptr, ObjectHandle key, ReturnValue return_value=ThrowException) const

bool	C_VerifyUpdate (SessionHandle session, const Byte part_ptr, Ulong part_len, ReturnValue return_value=ThrowException) const

template<typename TAlloc >
bool	C_VerifyUpdate (SessionHandle session, std::vector< uint8_t, TAlloc > part, ReturnValue *return_value=ThrowException) const

bool	C_WaitForSlotEvent (Flags flags, SlotId slot_ptr, VoidPtr reserved, ReturnValue return_value=ThrowException) const

bool	C_WrapKey (SessionHandle session, Mechanism mechanism_ptr, ObjectHandle wrapping_key, ObjectHandle key, Byte wrapped_key_ptr, Ulong wrapped_key_len_ptr, ReturnValue return_value=ThrowException) const

FunctionListPtr	get_functions () const

	LowLevel (FunctionListPtr ptr)

Static Public Member Functions
static bool	C_GetFunctionList (Dynamically_Loaded_Library &pkcs11_module, FunctionListPtr function_list_ptr_ptr, ReturnValue return_value=ThrowException)

Static Protected Member Functions
static bool	handle_return_value (const CK_RV function_result, ReturnValue *return_value)

Detailed Description

Provides access to all PKCS#11 functions.

Definition at line 903 of file p11.h.

Constructor & Destructor Documentation

◆ LowLevel()

Botan::PKCS11::LowLevel::LowLevel ( FunctionListPtr ptr )

explicit

Parameters

ptr	the functon list pointer to use. Can be retrieved via `LowLevel::C_GetFunctionList`

Definition at line 71 of file p11.cpp.

                                      :
   m_func_list_ptr(ptr)
   {
   if(m_func_list_ptr == nullptr)
      {
      throw Invalid_Argument("Invalid PKCS#11 function list ptr");
      }
   }

Member Function Documentation

◆ C_CancelFunction()

bool Botan::PKCS11::LowLevel::C_CancelFunction	(	SessionHandle	session,
		ReturnValue *	return_value = `ThrowException`
	)		const

C_CancelFunction is a legacy function; it cancels a function running in parallel.

Parameters

session	the session's handle
return_value	default value (`ThrowException`): throw exception on error. if a non-NULL pointer is passed: return_value receives the return value of the PKCS#11 function and no exception is thrown. At least the following PKCS#11 return values may be returned: CryptokiNotInitialized FunctionFailed FunctionNotParallel GeneralError HostMemory SessionHandleInvalid SessionClosed

Returns: true on success, false otherwise

Definition at line 767 of file p11.cpp.

   {
   return handle_return_value(m_func_list_ptr->C_CancelFunction(session), return_value);
   }

References handle_return_value().

◆ C_CloseAllSessions()

bool Botan::PKCS11::LowLevel::C_CloseAllSessions	(	SlotId	slot_id,
		ReturnValue *	return_value = `ThrowException`
	)		const

C_CloseAllSessions closes all sessions with a token.

Parameters

slot_id	the token's slot
return_value	default value (`ThrowException`): throw exception on error. if a non-NULL pointer is passed: return_value receives the return value of the PKCS#11 function and no exception is thrown. At least the following PKCS#11 return values may be returned: CryptokiNotInitialized DeviceError DeviceMemory DeviceRemoved FunctionFailed GeneralError HostMemory OK SlotIdInvalid TokenNotPresent

Returns: true on success, false otherwise

Definition at line 250 of file p11.cpp.

   {
   return handle_return_value(m_func_list_ptr->C_CloseAllSessions(slot_id), return_value);
   }

References handle_return_value().

◆ C_CloseSession()

bool Botan::PKCS11::LowLevel::C_CloseSession	(	SessionHandle	session,
		ReturnValue *	return_value = `ThrowException`
	)		const

C_CloseSession closes a session between an application and a token.

Parameters

session	the session's handle
return_value	default value (`ThrowException`): throw exception on error. if a non-NULL pointer is passed: return_value receives the return value of the PKCS#11 function and no exception is thrown. At least the following PKCS#11 return values may be returned: CryptokiNotInitialized DeviceError DeviceMemory DeviceRemoved FunctionFailed GeneralError HostMemory OK SessionClosed SessionHandleInvalid

Returns: true on success, false otherwise

Definition at line 244 of file p11.cpp.

   {
   return handle_return_value(m_func_list_ptr->C_CloseSession(session), return_value);
   }

References handle_return_value().

Referenced by Botan::PKCS11::Session::~Session().

◆ C_CopyObject()

bool Botan::PKCS11::LowLevel::C_CopyObject	(	SessionHandle	session,
		ObjectHandle	object,
		Attribute *	attribute_template_ptr,
		Ulong	count,
		ObjectHandle *	new_object_ptr,
		ReturnValue *	return_value = `ThrowException`
	)		const

C_CopyObject copies an object, creating a new object for the copy.

Parameters

session	the session's handle
object	the object's handle
attribute_template_ptr	template for new object
count	attributes in template
new_object_ptr	receives handle of copy
return_value	default value (`ThrowException`): throw exception on error. if a non-NULL pointer is passed: return_value receives the return value of the PKCS#11 function and no exception is thrown. At least the following PKCS#11 return values may be returned: ActionProhibited ArgumentsBad AttributeReadOnly AttributeTypeInvalid AttributeValueInvalid CryptokiNotInitialized DeviceError DeviceMemory DeviceRemoved FunctionFailed GeneralError HostMemory ObjectHandleInvalid OK PinExpired SessionClosed SessionHandleInvalid SessionReadOnly TemplateInconsistent TokenWriteProtected UserNotLoggedIn

Returns: true on success, false otherwise

Definition at line 311 of file p11.cpp.

   {
   return handle_return_value(m_func_list_ptr->C_CopyObject(session, object, attribute_template_ptr, count,
                              new_object_ptr), return_value);
   }

References handle_return_value().

Referenced by Botan::PKCS11::Object::copy().

◆ C_CreateObject()

bool Botan::PKCS11::LowLevel::C_CreateObject	(	SessionHandle	session,
		Attribute *	attribute_template_ptr,
		Ulong	count,
		ObjectHandle *	object_ptr,
		ReturnValue *	return_value = `ThrowException`
	)		const

C_CreateObject creates a new object.

Parameters

session	the session's handle
attribute_template_ptr	the object's template
count	attributes in template
object_ptr	gets new object's handle.
return_value	default value (`ThrowException`): throw exception on error. if a non-NULL pointer is passed: return_value receives the return value of the PKCS#11 function and no exception is thrown. At least the following PKCS#11 return values may be returned: ArgumentsBad AttributeReadOnly AttributeTypeInvalid AttributeValueInvalid CryptokiNotInitialized CurveNotSupported DeviceError DeviceMemory DeviceRemoved DomainParamsInvalid FunctionFailed GeneralError HostMemory OK PinExpired SessionClosed SessionHandleInvalid SessionReadOnly TemplateIncomplete TemplateInconsistent TokenWriteProtected UserNotLoggedIn

Returns: true on success, false otherwise

Definition at line 301 of file p11.cpp.

   {
   return handle_return_value(m_func_list_ptr->C_CreateObject(session, attribute_template_ptr, count, object_ptr),
                              return_value);
   }

References handle_return_value().

◆ C_Decrypt() [1/2]

bool Botan::PKCS11::LowLevel::C_Decrypt	(	SessionHandle	session,
		Byte *	encrypted_data_ptr,
		Ulong	encrypted_data_len,
		Byte *	data_ptr,
		Ulong *	data_len_ptr,
		ReturnValue *	return_value = `ThrowException`
	)		const

C_Decrypt decrypts encrypted data in a single part.

Parameters

session	session's handle
encrypted_data_ptr	ciphertext
encrypted_data_len	ciphertext length
data_ptr	gets plaintext
data_len_ptr	gets p-text size
return_value	default value (`ThrowException`): throw exception on error. if a non-NULL pointer is passed: return_value receives the return value of the PKCS#11 function and no exception is thrown. At least the following PKCS#11 return values may be returned: ArgumentsBad BufferTooSmall CryptokiNotInitialized DeviceError DeviceMemory DeviceRemoved EncryptedDataInvalid EncryptedDataLenRange FunctionCanceled FunctionFailed GeneralError HostMemory OK OperationNotInitialized SessionClosed SessionHandleInvalid UserNotLoggedIn

Returns: true on success, false otherwise

Definition at line 432 of file p11.cpp.

   {
   return handle_return_value(m_func_list_ptr->C_Decrypt(session, encrypted_data_ptr, encrypted_data_len, data_ptr,
                              data_len_ptr), return_value);
   }

References handle_return_value().

◆ C_Decrypt() [2/2]

template<typename TAllocA , typename TAllocB >

bool Botan::PKCS11::LowLevel::C_Decrypt	(	SessionHandle	session,
		const std::vector< uint8_t, TAllocA > &	encrypted_data,
		std::vector< uint8_t, TAllocB > &	decrypted_data,
		ReturnValue *	return_value = `ThrowException`
	)		const

inline

C_Decrypt decrypts encrypted data in a single part.

Parameters

session	session's handle
encrypted_data	ciphertext
decrypted_data	gets plaintext
return_value	default value (`ThrowException`): throw exception on error. if a non-NULL pointer is passed: return_value receives the return value of the PKCS#11 function and no exception is thrown. At least the following PKCS#11 return values may be returned: ArgumentsBad BufferTooSmall CryptokiNotInitialized DeviceError DeviceMemory DeviceRemoved EncryptedDataInvalid EncryptedDataLenRange FunctionCanceled FunctionFailed GeneralError HostMemory OK OperationNotInitialized SessionClosed SessionHandleInvalid UserNotLoggedIn

Returns: true on success, false otherwise

Definition at line 1945 of file p11.h.

         {
         Ulong decrypted_size = 0;
         if(!C_Decrypt(session,
                       const_cast<Byte*>((encrypted_data.data())),
                       static_cast<Ulong>(encrypted_data.size()),
                       nullptr, &decrypted_size,
                       return_value))
            {
            return false;
            }
 
         decrypted_data.resize(decrypted_size);
         if(!C_Decrypt(session,
                       const_cast<Byte*>(encrypted_data.data()),
                       static_cast<Ulong>(encrypted_data.size()),
                       decrypted_data.data(),
                       &decrypted_size, return_value))
            {
            return false;
            }
         decrypted_data.resize(decrypted_size);
         return true;
         }

◆ C_DecryptDigestUpdate()

bool Botan::PKCS11::LowLevel::C_DecryptDigestUpdate	(	SessionHandle	session,
		Byte *	encrypted_part_ptr,
		Ulong	encrypted_part_len,
		Byte *	part_ptr,
		Ulong *	part_len_ptr,
		ReturnValue *	return_value = `ThrowException`
	)		const

C_DecryptDigestUpdate continues a multiple-part decryption and digesting operation.

Parameters

session	session's handle
encrypted_part_ptr	ciphertext
encrypted_part_len	ciphertext length
part_ptr	gets plaintext
part_len_ptr	gets plaintext len
return_value	default value (`ThrowException`): throw exception on error. if a non-NULL pointer is passed: return_value receives the return value of the PKCS#11 function and no exception is thrown. At least the following PKCS#11 return values may be returned: ArgumentsBad BufferTooSmall CryptokiNotInitialized DeviceError DeviceMemory DeviceRemoved EncryptedDataInvalid EncryptedDataLenRange FunctionCanceled FunctionFailed GeneralError HostMemory OK OperationNotInitialized SessionClosed SessionHandleInvalid

Returns: true on success, false otherwise

Definition at line 639 of file p11.cpp.

   {
   return handle_return_value(m_func_list_ptr->C_DecryptDigestUpdate(session, encrypted_part_ptr, encrypted_part_len,
                              part_ptr, part_len_ptr), return_value);
   }

References handle_return_value().

◆ C_DecryptFinal()

bool Botan::PKCS11::LowLevel::C_DecryptFinal	(	SessionHandle	session,
		Byte *	last_part_ptr,
		Ulong *	last_part_len_ptr,
		ReturnValue *	return_value = `ThrowException`
	)		const

C_DecryptFinal finishes a multiple-part decryption operation.

Parameters

session	the session's handle
last_part_ptr	gets plaintext
last_part_len_ptr	p-text size
return_value	default value (`ThrowException`): throw exception on error. if a non-NULL pointer is passed: return_value receives the return value of the PKCS#11 function and no exception is thrown. At least the following PKCS#11 return values may be returned: ArgumentsBad BufferTooSmall CryptokiNotInitialized DeviceError DeviceMemory DeviceRemoved EncryptedDataInvalid EncryptedDataLenRange FunctionCanceled FunctionFailed GeneralError HostMemory OK OperationNotInitialized SessionClosed SessionHandleInvalid UserNotLoggedIn

Returns: true on success, false otherwise

Definition at line 454 of file p11.cpp.

   {
   return handle_return_value(m_func_list_ptr->C_DecryptFinal(session, last_part_ptr, last_part_len_ptr), return_value);
   }

References handle_return_value().

◆ C_DecryptInit()

bool Botan::PKCS11::LowLevel::C_DecryptInit	(	SessionHandle	session,
		Mechanism *	mechanism_ptr,
		ObjectHandle	key,
		ReturnValue *	return_value = `ThrowException`
	)		const

C_DecryptInit initializes a decryption operation.

Parameters

session	the session's handle
mechanism_ptr	the decryption mechanism
key	handle of decryption key
return_value	default value (`ThrowException`): throw exception on error. if a non-NULL pointer is passed: return_value receives the return value of the PKCS#11 function and no exception is thrown. At least the following PKCS#11 return values may be returned: ArgumentsBad CryptokiNotInitialized DeviceError DeviceMemory DeviceRemoved FunctionCanceled FunctionFailed GeneralError HostMemory KeyFunctionNotPermitted KeyHandleInvalid KeySizeRange KeyTypeInconsistent MechanismInvalid MechanismParamInvalid OK OperationActive PinExpired SessionClosed SessionHandleInvalid UserNotLoggedIn

Returns: true on success, false otherwise

Definition at line 424 of file p11.cpp.

   {
   return handle_return_value(m_func_list_ptr->C_DecryptInit(session, mechanism_ptr, key), return_value);
   }

References handle_return_value().

◆ C_DecryptUpdate()

bool Botan::PKCS11::LowLevel::C_DecryptUpdate	(	SessionHandle	session,
		Byte *	encrypted_part_ptr,
		Ulong	encrypted_part_len,
		Byte *	part_ptr,
		Ulong *	part_len_ptr,
		ReturnValue *	return_value = `ThrowException`
	)		const

C_DecryptUpdate continues a multiple-part decryption operation.

Parameters

session	session's handle
encrypted_part_ptr	encrypted data
encrypted_part_len	input length
part_ptr	gets plaintext
part_len_ptr	p-text size
return_value	default value (`ThrowException`): throw exception on error. if a non-NULL pointer is passed: return_value receives the return value of the PKCS#11 function and no exception is thrown. At least the following PKCS#11 return values may be returned: ArgumentsBad BufferTooSmall CryptokiNotInitialized DeviceError DeviceMemory DeviceRemoved EncryptedDataInvalid EncryptedDataLenRange FunctionCanceled FunctionFailed GeneralError HostMemory OK OperationNotInitialized SessionClosed SessionHandleInvalid UserNotLoggedIn

Returns: true on success, false otherwise

Definition at line 443 of file p11.cpp.

   {
   return handle_return_value(m_func_list_ptr->C_DecryptUpdate(session, encrypted_part_ptr, encrypted_part_len, part_ptr,
                              part_len_ptr), return_value);
   }

References handle_return_value().

◆ C_DecryptVerifyUpdate()

bool Botan::PKCS11::LowLevel::C_DecryptVerifyUpdate	(	SessionHandle	session,
		Byte *	encrypted_part_ptr,
		Ulong	encrypted_part_len,
		Byte *	part_ptr,
		Ulong *	part_len_ptr,
		ReturnValue *	return_value = `ThrowException`
	)		const

C_DecryptVerifyUpdate continues a multiple-part decryption and verify operation.

Parameters

session	session's handle
encrypted_part_ptr	ciphertext
encrypted_part_len	ciphertext length
part_ptr	gets plaintext
part_len_ptr	gets p-text length
return_value	default value (`ThrowException`): throw exception on error. if a non-NULL pointer is passed: return_value receives the return value of the PKCS#11 function and no exception is thrown. At least the following PKCS#11 return values may be returned: ArgumentsBad BufferTooSmall CryptokiNotInitialized DataLenRange DeviceError DeviceMemory DeviceRemoved EncryptedDataInvalid EncryptedDataLenRange FunctionCanceled FunctionFailed GeneralError HostMemory OK OperationNotInitialized SessionClosed SessionHandleInvalid

Returns: true on success, false otherwise

Definition at line 661 of file p11.cpp.

   {
   return handle_return_value(m_func_list_ptr->C_DecryptVerifyUpdate(session, encrypted_part_ptr, encrypted_part_len,
                              part_ptr, part_len_ptr), return_value);
   }

References handle_return_value().

◆ C_DeriveKey()

bool Botan::PKCS11::LowLevel::C_DeriveKey	(	SessionHandle	session,
		Mechanism *	mechanism_ptr,
		ObjectHandle	base_key,
		Attribute *	attribute_template_ptr,
		Ulong	attribute_count,
		ObjectHandle *	key_ptr,
		ReturnValue *	return_value = `ThrowException`
	)		const

C_DeriveKey derives a key from a base key, creating a new key object.

Parameters

session	session's handle
mechanism_ptr	key deriv. mech.
base_key	base key
attribute_template_ptr	new key template
attribute_count	template length
key_ptr	gets new handle
return_value	default value (`ThrowException`): throw exception on error. if a non-NULL pointer is passed: return_value receives the return value of the PKCS#11 function and no exception is thrown. At least the following PKCS#11 return values may be returned: ArgumentsBad AttributeReadOnly AttributeTypeInvalid AttributeValueInvalid CryptokiNotInitialized CurveNotSupported DeviceError DeviceMemory DeviceRemoved DomainParamsInvalid FunctionCanceled FunctionFailed GeneralError HostMemory KeyHandleInvalid KeySizeRange KeyTypeInconsistent MechanismInvalid MechanismParamInvalid OK OperationActive PinExpired SessionClosed SessionHandleInvalid SessionReadOnly TemplateIncomplete TemplateInconsistent TokenWriteProtected UserNotLoggedIn

Returns: true on success, false otherwise

Definition at line 727 of file p11.cpp.

   {
   return handle_return_value(m_func_list_ptr->C_DeriveKey(session, mechanism_ptr, base_key, attribute_template_ptr,
                              attribute_count, key_ptr), return_value);
   }

References handle_return_value().

◆ C_DestroyObject()

bool Botan::PKCS11::LowLevel::C_DestroyObject	(	SessionHandle	session,
		ObjectHandle	object,
		ReturnValue *	return_value = `ThrowException`
	)		const

C_DestroyObject destroys an object.

Parameters

session	the session's handle
object	the object's handle
return_value	default value (`ThrowException`): throw exception on error. if a non-NULL pointer is passed: return_value receives the return value of the PKCS#11 function and no exception is thrown. At least the following PKCS#11 return values may be returned: ActionProhibited CryptokiNotInitialized DeviceError DeviceMemory DeviceRemoved FunctionFailed GeneralError HostMemory ObjectHandleInvalid OK PinExpired SessionClosed SessionHandleInvalid SessionReadOnly TokenWriteProtected

Returns: true on success, false otherwise

Definition at line 322 of file p11.cpp.

   {
   return handle_return_value(m_func_list_ptr->C_DestroyObject(session, object), return_value);
   }

References handle_return_value().

Referenced by Botan::PKCS11::Object::destroy().

◆ C_Digest()

bool Botan::PKCS11::LowLevel::C_Digest	(	SessionHandle	session,
		Byte *	data_ptr,
		Ulong	data_len,
		Byte *	digest_ptr,
		Ulong *	digest_len_ptr,
		ReturnValue *	return_value = `ThrowException`
	)		const

C_Digest digests data in a single part.

Parameters

session	the session's handle
data_ptr	data to be digested
data_len	bytes of data to digest
digest_ptr	gets the message digest
digest_len_ptr	gets digest length
return_value	default value (`ThrowException`): throw exception on error. if a non-NULL pointer is passed: return_value receives the return value of the PKCS#11 function and no exception is thrown. At least the following PKCS#11 return values may be returned: ArgumentsBad BufferTooSmall CryptokiNotInitialized DeviceError DeviceMemory DeviceRemoved FunctionCanceled FunctionFailed GeneralError HostMemory OK OperationNotInitialized SessionClosed SessionHandleInvalid

Returns: true on success, false otherwise

Definition at line 471 of file p11.cpp.

   {
   return handle_return_value(m_func_list_ptr->C_Digest(session, data_ptr, data_len, digest_ptr, digest_len_ptr),
                              return_value);
   }

References handle_return_value().

◆ C_DigestEncryptUpdate()

bool Botan::PKCS11::LowLevel::C_DigestEncryptUpdate	(	SessionHandle	session,
		Byte *	part_ptr,
		Ulong	part_len,
		Byte *	encrypted_part_ptr,
		Ulong *	encrypted_part_len_ptr,
		ReturnValue *	return_value = `ThrowException`
	)		const

C_DigestEncryptUpdate continues a multiple-part digesting and encryption operation.

Parameters

session	session's handle
part_ptr	the plaintext data
part_len	plaintext length
encrypted_part_ptr	gets ciphertext
encrypted_part_len_ptr	gets c-text length
return_value	default value (`ThrowException`): throw exception on error. if a non-NULL pointer is passed: return_value receives the return value of the PKCS#11 function and no exception is thrown. At least the following PKCS#11 return values may be returned: ArgumentsBad BufferTooSmall CryptokiNotInitialized DataLenRange DeviceError DeviceMemory DeviceRemoved FunctionCanceled FunctionFailed GeneralError HostMemory OK OperationNotInitialized SessionClosed SessionHandleInvalid

Returns: true on success, false otherwise

Definition at line 628 of file p11.cpp.

   {
   return handle_return_value(m_func_list_ptr->C_DigestEncryptUpdate(session, part_ptr, part_len, encrypted_part_ptr,
                              encrypted_part_len_ptr), return_value);
   }

References handle_return_value().

◆ C_DigestFinal()

bool Botan::PKCS11::LowLevel::C_DigestFinal	(	SessionHandle	session,
		Byte *	digest_ptr,
		Ulong *	digest_len_ptr,
		ReturnValue *	return_value = `ThrowException`
	)		const

C_DigestFinal finishes a multiple-part message-digesting operation.

Parameters

session	the session's handle
digest_ptr	gets the message digest
digest_len_ptr	gets uint8_t count of digest
return_value	default value (`ThrowException`): throw exception on error. if a non-NULL pointer is passed: return_value receives the return value of the PKCS#11 function and no exception is thrown. At least the following PKCS#11 return values may be returned: ArgumentsBad BufferTooSmall CryptokiNotInitialized DeviceError DeviceMemory DeviceRemoved FunctionCanceled FunctionFailed GeneralError HostMemory OK OperationNotInitialized SessionClosed SessionHandleInvalid

Returns: true on success, false otherwise

Definition at line 497 of file p11.cpp.

   {
   return handle_return_value(m_func_list_ptr->C_DigestFinal(session, digest_ptr, digest_len_ptr), return_value);
   }

References handle_return_value().

◆ C_DigestInit()

bool Botan::PKCS11::LowLevel::C_DigestInit	(	SessionHandle	session,
		Mechanism *	mechanism_ptr,
		ReturnValue *	return_value = `ThrowException`
	)		const

C_DigestInit initializes a message-digesting operation.

Parameters

session	the session's handle
mechanism_ptr	the digesting mechanism
return_value	default value (`ThrowException`): throw exception on error. if a non-NULL pointer is passed: return_value receives the return value of the PKCS#11 function and no exception is thrown. At least the following PKCS#11 return values may be returned: ArgumentsBad CryptokiNotInitialized DeviceError DeviceMemory DeviceRemoved FunctionCanceled FunctionFailed GeneralError HostMemory MechanismInvalid MechanismParamInvalid OK OperationActive PinExpired SessionClosed SessionHandleInvalid UserNotLoggedIn

Returns: true on success, false otherwise

Definition at line 464 of file p11.cpp.

   {
   return handle_return_value(m_func_list_ptr->C_DigestInit(session, mechanism), return_value);
   }

References handle_return_value().

◆ C_DigestKey()

bool Botan::PKCS11::LowLevel::C_DigestKey	(	SessionHandle	session,
		ObjectHandle	key,
		ReturnValue *	return_value = `ThrowException`
	)		const

C_DigestKey continues a multi-part message-digesting operation, by digesting the value of a secret key as part of the data already digested.

Parameters

session	the session's handle
key	secret key to digest
return_value	default value (`ThrowException`): throw exception on error. if a non-NULL pointer is passed: return_value receives the return value of the PKCS#11 function and no exception is thrown. At least the following PKCS#11 return values may be returned: CryptokiNotInitialized DeviceError DeviceMemory DeviceRemoved FunctionCanceled FunctionFailed GeneralError HostMemory KeyHandleInvalid KeyIndigestible KeySizeRange OK OperationNotInitialized SessionClosed SessionHandleInvalid

Returns: true on success, false otherwise

Definition at line 490 of file p11.cpp.

   {
   return handle_return_value(m_func_list_ptr->C_DigestKey(session, key), return_value);
   }

References handle_return_value().

◆ C_DigestUpdate()

bool Botan::PKCS11::LowLevel::C_DigestUpdate	(	SessionHandle	session,
		Byte *	part_ptr,
		Ulong	part_len,
		ReturnValue *	return_value = `ThrowException`
	)		const

C_DigestUpdate continues a multiple-part message-digesting operation.

Parameters

session	the session's handle
part_ptr	data to be digested
part_len	bytes of data to be digested
return_value	default value (`ThrowException`): throw exception on error. if a non-NULL pointer is passed: return_value receives the return value of the PKCS#11 function and no exception is thrown. At least the following PKCS#11 return values may be returned: ArgumentsBad CryptokiNotInitialized DeviceError DeviceMemory DeviceRemoved FunctionCanceled FunctionFailed GeneralError HostMemory OK OperationNotInitialized SessionClosed SessionHandleInvalid

Returns: true on success, false otherwise

Definition at line 482 of file p11.cpp.

   {
   return handle_return_value(m_func_list_ptr->C_DigestUpdate(session, part_ptr, part_len), return_value);
   }

References handle_return_value().

◆ C_Encrypt() [1/2]

bool Botan::PKCS11::LowLevel::C_Encrypt	(	SessionHandle	session,
		Byte *	data_ptr,
		Ulong	data_len,
		Byte *	encrypted_data,
		Ulong *	encrypted_data_len_ptr,
		ReturnValue *	return_value = `ThrowException`
	)		const

C_Encrypt encrypts single-part data.

Parameters

session	session's handle
data_ptr	the plaintext data
data_len	size of plaintext data in bytes
encrypted_data	gets ciphertext
encrypted_data_len_ptr	gets c-text size
return_value	default value (`ThrowException`): throw exception on error. if a non-NULL pointer is passed: return_value receives the return value of the PKCS#11 function and no exception is thrown. At least the following PKCS#11 return values may be returned: ArgumentsBad BufferTooSmall CryptokiNotInitialized DataInvalid DataLenRange DeviceError DeviceMemory DeviceRemoved FunctionCanceled FunctionFailed GeneralError HostMemory OK OperationNotInitialized SessionClosed SessionHandleInvalid

Returns: true on success, false otherwise

Definition at line 391 of file p11.cpp.

   {
   return handle_return_value(m_func_list_ptr->C_Encrypt(session, data_ptr, data_len, encrypted_data_ptr,
                              encrypted_data_len_ptr), return_value);
   }

References handle_return_value().

◆ C_Encrypt() [2/2]

template<typename TAllocA , typename TAllocB >

bool Botan::PKCS11::LowLevel::C_Encrypt	(	SessionHandle	session,
		const std::vector< uint8_t, TAllocA > &	plaintext_data,
		std::vector< uint8_t, TAllocB > &	encrypted_data,
		ReturnValue *	return_value = `ThrowException`
	)		const

inline

C_Encrypt encrypts single-part data.

Parameters

session	session's handle
plaintext_data	the plaintext data
encrypted_data	gets ciphertext
return_value	default value (`ThrowException`): throw exception on error. if a non-NULL pointer is passed: return_value receives the return value of the PKCS#11 function and no exception is thrown. At least the following PKCS#11 return values may be returned: ArgumentsBad BufferTooSmall CryptokiNotInitialized DataInvalid DataLenRange DeviceError DeviceMemory DeviceRemoved FunctionCanceled FunctionFailed GeneralError HostMemory OK OperationNotInitialized SessionClosed SessionHandleInvalid

Returns: true on success, false otherwise

Definition at line 1807 of file p11.h.

         {
         Ulong encrypted_size = 0;
         if(!C_Encrypt(session,
                       const_cast<Byte*>((plaintext_data.data())),
                       static_cast<Ulong>(plaintext_data.size()),
                       nullptr, &encrypted_size,
                       return_value))
            {
            return false;
            }
 
         encrypted_data.resize(encrypted_size);
         if (!C_Encrypt(session,
                          const_cast<Byte*>(plaintext_data.data()),
                          static_cast<Ulong>(plaintext_data.size()),
                          encrypted_data.data(),
                          &encrypted_size, return_value))
            {
            return false;
            }
         encrypted_data.resize(encrypted_size);
         return true;
         }

◆ C_EncryptFinal()

bool Botan::PKCS11::LowLevel::C_EncryptFinal	(	SessionHandle	session,
		Byte *	last_encrypted_part_ptr,
		Ulong *	last_encrypted_part_len_ptr,
		ReturnValue *	return_value = `ThrowException`
	)		const

C_EncryptFinal finishes a multiple-part encryption operation.

Parameters

session	session handle
last_encrypted_part_ptr	last c-text
last_encrypted_part_len_ptr	gets last size
return_value	default value (`ThrowException`): throw exception on error. if a non-NULL pointer is passed: return_value receives the return value of the PKCS#11 function and no exception is thrown. At least the following PKCS#11 return values may be returned: ArgumentsBad BufferTooSmall CryptokiNotInitialized DataLenRange DeviceError DeviceMemory DeviceRemoved FunctionCanceled FunctionFailed GeneralError HostMemory OK OperationNotInitialized SessionClosed SessionHandleInvalid

Returns: true on success, false otherwise

Definition at line 413 of file p11.cpp.

   {
   return handle_return_value(m_func_list_ptr->C_EncryptFinal(session, last_encrypted_part_ptr,
                              last_encrypted_part_len_ptr), return_value);
   }

References handle_return_value().

◆ C_EncryptInit()

bool Botan::PKCS11::LowLevel::C_EncryptInit	(	SessionHandle	session,
		Mechanism *	mechanism_ptr,
		ObjectHandle	key,
		ReturnValue *	return_value = `ThrowException`
	)		const

C_EncryptInit initializes an encryption operation.

Parameters

session	the session's handle
mechanism_ptr	the encryption mechanism
key	handle of encryption key
return_value	default value (`ThrowException`): throw exception on error. if a non-NULL pointer is passed: return_value receives the return value of the PKCS#11 function and no exception is thrown. At least the following PKCS#11 return values may be returned: CryptokiNotInitialized DeviceError DeviceMemory DeviceRemoved FunctionCanceled FunctionFailed GeneralError HostMemory KeyFunctionNotPermitted KeyHandleInvalid KeySizeRange KeyTypeInconsistent MechanismInvalid MechanismParamInvalid OK OperationActive PinExpired SessionClosed SessionHandleInvalid UserNotLoggedIn

Returns: true on success, false otherwise

Definition at line 383 of file p11.cpp.

   {
   return handle_return_value(m_func_list_ptr->C_EncryptInit(session, mechanism_ptr, key), return_value);
   }

References handle_return_value().

◆ C_EncryptUpdate()

bool Botan::PKCS11::LowLevel::C_EncryptUpdate	(	SessionHandle	session,
		Byte *	part_ptr,
		Ulong	part_len,
		Byte *	encrypted_part_ptr,
		Ulong *	encrypted_part_len_ptr,
		ReturnValue *	return_value = `ThrowException`
	)		const

C_EncryptUpdate continues a multiple-part encryption operation.

Parameters

session	session's handle
part_ptr	the plaintext data
part_len	plaintext data len
encrypted_part_ptr	gets ciphertext
encrypted_part_len_ptr	gets c-text size
return_value	default value (`ThrowException`): throw exception on error. if a non-NULL pointer is passed: return_value receives the return value of the PKCS#11 function and no exception is thrown. At least the following PKCS#11 return values may be returned: ArgumentsBad BufferTooSmall CryptokiNotInitialized DataLenRange DeviceError DeviceMemory DeviceRemoved FunctionCanceled FunctionFailed GeneralError HostMemory OK OperationNotInitialized SessionClosed SessionHandleInvalid

Returns: true on success, false otherwise

Definition at line 402 of file p11.cpp.

   {
   return handle_return_value(m_func_list_ptr->C_EncryptUpdate(session, part_ptr, part_len, encrypted_part_ptr,
                              encrypted_part_len_ptr), return_value);
   }

References handle_return_value().

◆ C_Finalize()

bool Botan::PKCS11::LowLevel::C_Finalize	(	VoidPtr	reserved,
		ReturnValue *	return_value = `ThrowException`
	)		const

C_Finalize indicates that an application is done with the Cryptoki library.

Parameters

reserved	reserved. Should be nullptr
return_value	default value (`ThrowException`): throw exception on error. if a non-NULL pointer is passed: return_value receives the return value of the PKCS#11 function and no exception is thrown. At least the following PKCS#11 return values may be returned: ArgumentsBad CryptokiNotInitialized FunctionFailed GeneralError HostMemory OK

Returns: true on success, false otherwise

Definition at line 88 of file p11.cpp.

   {
   return handle_return_value(m_func_list_ptr->C_Finalize(reserved), return_value);
   }

References handle_return_value().

◆ C_FindObjects()

bool Botan::PKCS11::LowLevel::C_FindObjects	(	SessionHandle	session,
		ObjectHandle *	object_ptr,
		Ulong	max_object_count,
		Ulong *	object_count_ptr,
		ReturnValue *	return_value = `ThrowException`
	)		const

C_FindObjects continues a search for token and session objects that match a template, obtaining additional object handles.

Parameters

session	session's handle
object_ptr	gets obj. handles
max_object_count	max handles to get
object_count_ptr	actual # returned
return_value	default value (`ThrowException`): throw exception on error. if a non-NULL pointer is passed: return_value receives the return value of the PKCS#11 function and no exception is thrown. At least the following PKCS#11 return values may be returned: ArgumentsBad CryptokiNotInitialized DeviceError DeviceMemory DeviceRemoved FunctionFailed GeneralError HostMemory OK OperationNotInitialized SessionClosed SessionHandleInvalid

Returns: true on success, false otherwise

Definition at line 365 of file p11.cpp.

   {
   return handle_return_value(m_func_list_ptr->C_FindObjects(session, object_ptr, max_object_count, object_count_ptr),
                              return_value);
   }

References handle_return_value().

Referenced by Botan::PKCS11::ObjectFinder::find().

◆ C_FindObjectsFinal()

bool Botan::PKCS11::LowLevel::C_FindObjectsFinal	(	SessionHandle	session,
		ReturnValue *	return_value = `ThrowException`
	)		const

C_FindObjectsFinal finishes a search for token and session objects.

Parameters

session the session's handle

return_value

default value (ThrowException): throw exception on error. if a non-NULL pointer is passed: return_value receives the return value of the PKCS#11 function and no exception is thrown. At least the following PKCS#11 return values may be returned:

CryptokiNotInitialized
DeviceError
DeviceMemory
DeviceRemoved
FunctionFailed
GeneralError
HostMemory
OK
OperationNotInitialized
SessionClosed
SessionHandleInvalid

Returns: true on success, false otherwise

Definition at line 375 of file p11.cpp.

   {
   return handle_return_value(m_func_list_ptr->C_FindObjectsFinal(session), return_value);
   }

References handle_return_value().

Referenced by Botan::PKCS11::ObjectFinder::finish(), and Botan::PKCS11::ObjectFinder::~ObjectFinder().

◆ C_FindObjectsInit()

bool Botan::PKCS11::LowLevel::C_FindObjectsInit	(	SessionHandle	session,
		Attribute *	attribute_template_ptr,
		Ulong	count,
		ReturnValue *	return_value = `ThrowException`
	)		const

C_FindObjectsInit initializes a search for token and session objects that match a template.

Parameters

session	the session's handle
attribute_template_ptr	attribute values to match
count	attrs in search template
return_value	default value (`ThrowException`): throw exception on error. if a non-NULL pointer is passed: return_value receives the return value of the PKCS#11 function and no exception is thrown. At least the following PKCS#11 return values may be returned: ArgumentsBad AttributeTypeInvalid AttributeValueInvalid CryptokiNotInitialized DeviceError DeviceMemory DeviceRemoved FunctionFailed GeneralError HostMemory OK OperationActive PinExpired SessionClosed SessionHandleInvalid

Returns: true on success, false otherwise

Definition at line 357 of file p11.cpp.

   {
   return handle_return_value(m_func_list_ptr->C_FindObjectsInit(session, attribute_template_ptr, count), return_value);
   }

References handle_return_value().

Referenced by Botan::PKCS11::ObjectFinder::ObjectFinder().

◆ C_GenerateKey()

bool Botan::PKCS11::LowLevel::C_GenerateKey	(	SessionHandle	session,
		Mechanism *	mechanism_ptr,
		Attribute *	attribute_template_ptr,
		Ulong	count,
		ObjectHandle *	key_ptr,
		ReturnValue *	return_value = `ThrowException`
	)		const

C_GenerateKey generates a secret key, creating a new key object.

Parameters

session	the session's handle
mechanism_ptr	key generation mech.
attribute_template_ptr	template for new key
count	# of attrs in template
key_ptr	gets handle of new key
return_value	default value (`ThrowException`): throw exception on error. if a non-NULL pointer is passed: return_value receives the return value of the PKCS#11 function and no exception is thrown. At least the following PKCS#11 return values may be returned: ArgumentsBad AttributeReadOnly AttributeTypeInvalid AttributeValueInvalid CryptokiNotInitialized CurveNotSupported DeviceError DeviceMemory DeviceRemoved FunctionCanceled FunctionFailed GeneralError HostMemory MechanismInvalid MechanismParamInvalid OK OperationActive PinExpired SessionClosed SessionHandleInvalid SessionReadOnly TemplateIncomplete TemplateInconsistent TokenWriteProtected UserNotLoggedIn

Returns: true on success, false otherwise

Definition at line 674 of file p11.cpp.

   {
   return handle_return_value(m_func_list_ptr->C_GenerateKey(session, mechanism_ptr, attribute_template_ptr, count,
                              key_ptr), return_value);
   }

References handle_return_value().

◆ C_GenerateKeyPair()

bool Botan::PKCS11::LowLevel::C_GenerateKeyPair	(	SessionHandle	session,
		Mechanism *	mechanism_ptr,
		Attribute *	public_key_template_ptr,
		Ulong	public_key_attribute_count,
		Attribute *	private_key_template_ptr,
		Ulong	private_key_attribute_count,
		ObjectHandle *	public_key_ptr,
		ObjectHandle *	private_key_ptr,
		ReturnValue *	return_value = `ThrowException`
	)		const

C_GenerateKeyPair generates a public-key/private-key pair, creating new key objects.

Parameters

session	session handle
mechanism_ptr	key-gen mech.
public_key_template_ptr	template for pub. key
public_key_attribute_count	# pub. attrs.
private_key_template_ptr	template for priv. key
private_key_attribute_count	# priv. attrs.
public_key_ptr	gets pub. key handle
private_key_ptr	gets priv. key handle
return_value	default value (`ThrowException`): throw exception on error. if a non-NULL pointer is passed: return_value receives the return value of the PKCS#11 function and no exception is thrown. At least the following PKCS#11 return values may be returned: ArgumentsBad AttributeReadOnly AttributeTypeInvalid AttributeValueInvalid CryptokiNotInitialized CurveNotSupported DeviceError DeviceMemory DeviceRemoved DomainParamsInvalid FunctionCanceled FunctionFailed GeneralError HostMemory MechanismInvalid MechanismParamInvalid OK OperationActive PinExpired SessionClosed SessionHandleInvalid SessionReadOnly TemplateIncomplete TemplateInconsistent TokenWriteProtected UserNotLoggedIn

Returns: true on success, false otherwise

Definition at line 685 of file p11.cpp.

   {
   return handle_return_value(m_func_list_ptr->C_GenerateKeyPair(session, mechanism_ptr, public_key_template_ptr,
                              public_key_attribute_count, private_key_template_ptr,
                              private_key_attribute_count, public_key_ptr, private_key_ptr), return_value);
   }

References handle_return_value().

◆ C_GenerateRandom()

bool Botan::PKCS11::LowLevel::C_GenerateRandom	(	SessionHandle	session,
		Byte *	random_data_ptr,
		Ulong	random_len,
		ReturnValue *	return_value = `ThrowException`
	)		const

C_GenerateRandom generates random data.

Parameters

session	the session's handle
random_data_ptr	receives the random data
random_len	# of bytes to generate
return_value	default value (`ThrowException`): throw exception on error. if a non-NULL pointer is passed: return_value receives the return value of the PKCS#11 function and no exception is thrown. At least the following PKCS#11 return values may be returned: ArgumentsBad CryptokiNotInitialized DeviceError DeviceMemory DeviceRemoved FunctionCanceled FunctionFailed GeneralError HostMemory OK OperationActive RandomNoRng SessionClosed SessionHandleInvalid UserNotLoggedIn

Returns: true on success, false otherwise

Definition at line 751 of file p11.cpp.

   {
   return handle_return_value(m_func_list_ptr->C_GenerateRandom(session, random_data_ptr, random_len), return_value);
   }

References handle_return_value().

Referenced by Botan::PKCS11::PKCS11_RNG::randomize().

◆ C_GetAttributeValue() [1/2]

bool Botan::PKCS11::LowLevel::C_GetAttributeValue	(	SessionHandle	session,
		ObjectHandle	object,
		Attribute *	attribute_template_ptr,
		Ulong	count,
		ReturnValue *	return_value = `ThrowException`
	)		const

C_GetAttributeValue obtains the value of one or more object attributes.

Parameters

session	the session's handle
object	the object's handle
attribute_template_ptr	specifies attrs; gets vals
count	attributes in template
return_value	default value (`ThrowException`): throw exception on error. if a non-NULL pointer is passed: return_value receives the return value of the PKCS#11 function and no exception is thrown. At least the following PKCS#11 return values may be returned: ArgumentsBad AttributeSensitive AttributeTypeInvalid BufferTooSmall CryptokiNotInitialized DeviceError DeviceMemory DeviceRemoved FunctionFailed GeneralError HostMemory ObjectHandleInvalid OK SessionClosed SessionHandleInvalid

Returns: true on success, false otherwise

Definition at line 337 of file p11.cpp.

   {
   return handle_return_value(m_func_list_ptr->C_GetAttributeValue(session, object, attribute_template_ptr, count),
                              return_value);
   }

References handle_return_value().

Referenced by Botan::PKCS11::Object::get_attribute_value().

◆ C_GetAttributeValue() [2/2]

template<typename TAlloc >

bool Botan::PKCS11::LowLevel::C_GetAttributeValue	(	SessionHandle	session,
		ObjectHandle	object,
		std::map< AttributeType, std::vector< uint8_t, TAlloc > > &	attribute_values,
		ReturnValue *	return_value = `ThrowException`
	)		const

inline

C_GetAttributeValue obtains the value of one or more object attributes.

Parameters

session	the session's handle
object	the object's handle
attribute_values	specifies attrs; gets vals
return_value	default value (`ThrowException`): throw exception on error. if a non-NULL pointer is passed: return_value receives the return value of the PKCS#11 function and no exception is thrown. At least the following PKCS#11 return values may be returned: ArgumentsBad AttributeSensitive AttributeTypeInvalid BufferTooSmall CryptokiNotInitialized DeviceError DeviceMemory DeviceRemoved FunctionFailed GeneralError HostMemory ObjectHandleInvalid OK SessionClosed SessionHandleInvalid

Returns: true on success, false otherwise

Definition at line 1587 of file p11.h.

         {
         std::vector<Attribute> getter_template;
 
         for(const auto& entry : attribute_values)
            {
            getter_template.emplace_back(Attribute{ static_cast< CK_ATTRIBUTE_TYPE >(entry.first), nullptr, 0 });
            }
 
         bool success = C_GetAttributeValue(session,
                                            object,
                                            const_cast< Attribute* >(getter_template.data()),
                                            static_cast<Ulong>(getter_template.size()),
                                            return_value);
 
         if(!success)
            {
            return success;
            }
 
         size_t i = 0;
         for(auto& entry : attribute_values)
            {
            entry.second.clear();
            entry.second.resize(getter_template.at(i).ulValueLen);
            getter_template.at(i).pValue = const_cast< uint8_t* >(entry.second.data());
            i++;
            }
 
         return C_GetAttributeValue(session, object,
                                    const_cast< Attribute* >(getter_template.data()),
                                    static_cast<Ulong>(getter_template.size()),
                                    return_value);
         }

◆ C_GetFunctionList()

bool Botan::PKCS11::LowLevel::C_GetFunctionList	(	Dynamically_Loaded_Library &	pkcs11_module,
		FunctionListPtr *	function_list_ptr_ptr,
		ReturnValue *	return_value = `ThrowException`
	)

static

C_GetFunctionList returns the function list.

Parameters

pkcs11_module	The PKCS#11 module
function_list_ptr_ptr	receives pointer to function list
return_value	default value (`ThrowException`): throw exception on error. if a non-NULL pointer is passed: return_value receives the return value of the PKCS#11 function and no exception is thrown. At least the following PKCS#11 return values may be returned: ArgumentsBad FunctionFailed GeneralError HostMemory OK

Returns: true on success, false otherwise

Definition at line 100 of file p11.cpp.

   {
   using get_function_list = CK_RV(*)(FunctionListPtr*);
 
   get_function_list get_function_list_ptr = pkcs11_module.resolve<get_function_list>("C_GetFunctionList");
 
   return handle_return_value(get_function_list_ptr(function_list_ptr_ptr), return_value);
   }

References handle_return_value(), and Botan::Dynamically_Loaded_Library::resolve().

Referenced by Botan::PKCS11::Module::reload().

◆ C_GetFunctionStatus()

bool Botan::PKCS11::LowLevel::C_GetFunctionStatus	(	SessionHandle	session,
		ReturnValue *	return_value = `ThrowException`
	)		const

C_GetFunctionStatus is a legacy function; it obtains an updated status of a function running in parallel with an application.

Parameters

session	the session's handle
return_value	default value (`ThrowException`): throw exception on error. if a non-NULL pointer is passed: return_value receives the return value of the PKCS#11 function and no exception is thrown. At least the following PKCS#11 return values may be returned: CryptokiNotInitialized FunctionFailed FunctionNotParallel GeneralError HostMemory SessionHandleInvalid SessionClosed

Returns: true on success, false otherwise

Definition at line 761 of file p11.cpp.

   {
   return handle_return_value(m_func_list_ptr->C_GetFunctionStatus(session), return_value);
   }

References handle_return_value().

◆ C_GetInfo()

bool Botan::PKCS11::LowLevel::C_GetInfo	(	Info *	info_ptr,
		ReturnValue *	return_value = `ThrowException`
	)		const

C_GetInfo returns general information about Cryptoki.

Parameters

info_ptr	location that receives information
return_value	default value (`ThrowException`): throw exception on error. if a non-NULL pointer is passed: return_value receives the return value of the PKCS#11 function and no exception is thrown. At least the following PKCS#11 return values may be returned: ArgumentsBad CryptokiNotInitialized FunctionFailed GeneralError HostMemory OK

Returns: true on success, false otherwise

Definition at line 94 of file p11.cpp.

   {
   return handle_return_value(m_func_list_ptr->C_GetInfo(info_ptr), return_value);
   }

References handle_return_value().

◆ C_GetMechanismInfo()

bool Botan::PKCS11::LowLevel::C_GetMechanismInfo	(	SlotId	slot_id,
		MechanismType	type,
		MechanismInfo *	info_ptr,
		ReturnValue *	return_value = `ThrowException`
	)		const

C_GetMechanismInfo obtains information about a particular mechanism possibly supported by a token.

Parameters

slot_id	ID of the token's slot
type	type of mechanism
info_ptr	receives mechanism info
return_value	default value (`ThrowException`): throw exception on error. if a non-NULL pointer is passed: return_value receives the return value of the PKCS#11 function and no exception is thrown. At least the following PKCS#11 return values may be returned: CryptokiNotInitialized DeviceError DeviceMemory DeviceRemoved FunctionFailed GeneralError HostMemory MechanismInvalid OK SlotIdInvalid TokenNotPresent TokenNotRecognized ArgumentsBad

Returns: true on success, false otherwise

Definition at line 194 of file p11.cpp.

   {
   return handle_return_value(m_func_list_ptr->C_GetMechanismInfo(slot_id, static_cast< CK_MECHANISM_TYPE >(type),
                              info_ptr), return_value);
   }

References handle_return_value(), and type.

◆ C_GetMechanismList() [1/2]

bool Botan::PKCS11::LowLevel::C_GetMechanismList	(	SlotId	slot_id,
		MechanismType *	mechanism_list_ptr,
		Ulong *	count_ptr,
		ReturnValue *	return_value = `ThrowException`
	)		const

C_GetMechanismList obtains a list of mechanism types supported by a token.

Parameters

slot_id	ID of token's slot
mechanism_list_ptr	gets mech. array
count_ptr	gets # of mechs.
return_value	default value (`ThrowException`): throw exception on error. if a non-NULL pointer is passed: return_value receives the return value of the PKCS#11 function and no exception is thrown. At least the following PKCS#11 return values may be returned: BufferTooSmall CryptokiNotInitialized DeviceError DeviceMemory DeviceRemoved FunctionFailed GeneralError HostMemory OK SlotIdInvalid TokenNotPresent TokenNotRecognized ArgumentsBad

Returns: true on success, false otherwise

Definition at line 163 of file p11.cpp.

   {
   return handle_return_value(m_func_list_ptr->C_GetMechanismList(slot_id,
                              reinterpret_cast< CK_MECHANISM_TYPE_PTR >(mechanism_list_ptr), count_ptr), return_value);
   }

References handle_return_value().

Referenced by C_GetMechanismList().

◆ C_GetMechanismList() [2/2]

bool Botan::PKCS11::LowLevel::C_GetMechanismList	(	SlotId	slot_id,
		std::vector< MechanismType > &	mechanisms,
		ReturnValue *	return_value = `ThrowException`
	)		const

C_GetMechanismList obtains a list of mechanism types supported by a token.

Parameters

slot_id	ID of token's slot
mechanisms	receives vector of supported mechanisms
return_value	default value (`ThrowException`): throw exception on error. if a non-NULL pointer is passed: return_value receives the return value of the PKCS#11 function and no exception is thrown. At least the following PKCS#11 return values may be returned: BufferTooSmall CryptokiNotInitialized DeviceError DeviceMemory DeviceRemoved FunctionFailed GeneralError HostMemory OK SlotIdInvalid TokenNotPresent TokenNotRecognized ArgumentsBad

Returns: true on success, false otherwise

Definition at line 172 of file p11.cpp.

   {
   mechanisms.clear();
 
   // first get number of mechanisms
   Ulong number_mechanisms = 0;
 
   bool success = C_GetMechanismList(slot_id, nullptr, &number_mechanisms, return_value);
 
   if(!success || !number_mechanisms)
      {
      return success;
      }
 
   // get actual mechanisms
   mechanisms.resize(number_mechanisms);
   return C_GetMechanismList(slot_id, reinterpret_cast< MechanismType* >(mechanisms.data()), &number_mechanisms,
                             return_value);
   }

References C_GetMechanismList().

◆ C_GetObjectSize()

bool Botan::PKCS11::LowLevel::C_GetObjectSize	(	SessionHandle	session,
		ObjectHandle	object,
		Ulong *	size_ptr,
		ReturnValue *	return_value = `ThrowException`
	)		const

C_GetObjectSize gets the size of an object in bytes.

Parameters

session	the session's handle
object	the object's handle
size_ptr	receives size of object
return_value	default value (`ThrowException`): throw exception on error. if a non-NULL pointer is passed: return_value receives the return value of the PKCS#11 function and no exception is thrown. At least the following PKCS#11 return values may be returned: ArgumentsBad CryptokiNotInitialized DeviceError DeviceMemory DeviceRemoved FunctionFailed GeneralError HostMemory InformationSensitive ObjectHandleInvalid OK SessionClosed SessionHandleInvalid

Returns: true on success, false otherwise

Definition at line 329 of file p11.cpp.

   {
   return handle_return_value(m_func_list_ptr->C_GetObjectSize(session, object, size_ptr), return_value);
   }

References handle_return_value().

◆ C_GetOperationState()

bool Botan::PKCS11::LowLevel::C_GetOperationState	(	SessionHandle	session,
		Byte *	operation_state_ptr,
		Ulong *	operation_state_len_ptr,
		ReturnValue *	return_value = `ThrowException`
	)		const

C_GetOperationState obtains the state of the cryptographic operation in a session.

Parameters

session	session's handle
operation_state_ptr	gets state
operation_state_len_ptr	gets state length
return_value	default value (`ThrowException`): throw exception on error. if a non-NULL pointer is passed: return_value receives the return value of the PKCS#11 function and no exception is thrown. At least the following PKCS#11 return values may be returned: BufferTooSmall CryptokiNotInitialized DeviceError DeviceMemory DeviceRemoved FunctionFailed GeneralError HostMemory OK OperationNotInitialized SessionClosed SessionHandleInvalid StateUnsaveable ArgumentsBad

Returns: true on success, false otherwise

Definition at line 263 of file p11.cpp.

   {
   return handle_return_value(m_func_list_ptr->C_GetOperationState(session, operation_state_ptr, operation_state_len_ptr),
                              return_value);
   }

References handle_return_value().

◆ C_GetSessionInfo()

bool Botan::PKCS11::LowLevel::C_GetSessionInfo	(	SessionHandle	session,
		SessionInfo *	info_ptr,
		ReturnValue *	return_value = `ThrowException`
	)		const

C_GetSessionInfo obtains information about the session.

Parameters

session	the session's handle
info_ptr	receives session info
return_value	default value (`ThrowException`): throw exception on error. if a non-NULL pointer is passed: return_value receives the return value of the PKCS#11 function and no exception is thrown. At least the following PKCS#11 return values may be returned: CryptokiNotInitialized DeviceError DeviceMemory DeviceRemoved FunctionFailed GeneralError HostMemory OK SessionClosed SessionHandleInvalid ArgumentsBad

Returns: true on success, false otherwise

Definition at line 256 of file p11.cpp.

   {
   return handle_return_value(m_func_list_ptr->C_GetSessionInfo(session, info_ptr), return_value);
   }

References handle_return_value().

Referenced by Botan::PKCS11::Session::get_info().

◆ C_GetSlotInfo()

bool Botan::PKCS11::LowLevel::C_GetSlotInfo	(	SlotId	slot_id,
		SlotInfo *	info_ptr,
		ReturnValue *	return_value = `ThrowException`
	)		const

C_GetSlotInfo obtains information about a particular slot in the system.

Parameters

slot_id	the ID of the slot
info_ptr	receives the slot information
return_value	default value (`ThrowException`): throw exception on error. if a non-NULL pointer is passed: return_value receives the return value of the PKCS#11 function and no exception is thrown. At least the following PKCS#11 return values may be returned: ArgumentsBad CryptokiNotInitialized DeviceError FunctionFailed GeneralError HostMemory OK SlotIdInvalid

Returns: true on success, false otherwise

Definition at line 141 of file p11.cpp.

   {
   return handle_return_value(m_func_list_ptr->C_GetSlotInfo(slot_id, info_ptr), return_value);
   }

References handle_return_value().

◆ C_GetSlotList() [1/2]

bool Botan::PKCS11::LowLevel::C_GetSlotList	(	Bbool	token_present,
		SlotId *	slot_list_ptr,
		Ulong *	count_ptr,
		ReturnValue *	return_value = `ThrowException`
	)		const

C_GetSlotList obtains a list of slots in the system.

Parameters

token_present	only slots with tokens
slot_list_ptr	receives array of slot IDs
count_ptr	receives number of slots
return_value	default value (`ThrowException`): throw exception on error. if a non-NULL pointer is passed: return_value receives the return value of the PKCS#11 function and no exception is thrown. At least the following PKCS#11 return values may be returned: ArgumentsBad BufferTooSmall CryptokiNotInitialized FunctionFailed GeneralError HostMemory OK

Returns: true on success, false otherwise

Definition at line 112 of file p11.cpp.

   {
   return handle_return_value(m_func_list_ptr->C_GetSlotList(token_present, slot_list_ptr, count_ptr), return_value);
   }

References handle_return_value().

Referenced by C_GetSlotList(), and Botan::PKCS11::Slot::get_available_slots().

◆ C_GetSlotList() [2/2]

bool Botan::PKCS11::LowLevel::C_GetSlotList	(	bool	token_present,
		std::vector< SlotId > &	slot_ids,
		ReturnValue *	return_value = `ThrowException`
	)		const

C_GetSlotList obtains a list of slots in the system.

Parameters

token_present	only slots with tokens
slot_ids	receives vector of slot IDs
return_value	default value (`ThrowException`): throw exception on error. if a non-NULL pointer is passed: return_value receives the return value of the PKCS#11 function and no exception is thrown. At least the following PKCS#11 return values may be returned: ArgumentsBad BufferTooSmall CryptokiNotInitialized FunctionFailed GeneralError HostMemory OK

Returns: true on success, false otherwise

Definition at line 120 of file p11.cpp.

   {
   slot_ids.clear();
 
   // first get available slots
   Ulong number_slots = 0;
 
   bool success = C_GetSlotList(token_present, nullptr, &number_slots, return_value);
 
   if(!success || !number_slots)
      {
      return success;
      }
 
   // get actual slot ids
   slot_ids.resize(number_slots);
   return C_GetSlotList(token_present, slot_ids.data(), &number_slots, return_value);
   }

References C_GetSlotList().

◆ C_GetTokenInfo()

bool Botan::PKCS11::LowLevel::C_GetTokenInfo	(	SlotId	slot_id,
		TokenInfo *	info_ptr,
		ReturnValue *	return_value = `ThrowException`
	)		const

C_GetTokenInfo obtains information about a particular token in the system.

Parameters

slot_id	ID of the token's slot
info_ptr	receives the token information
return_value	default value (`ThrowException`): throw exception on error. if a non-NULL pointer is passed: return_value receives the return value of the PKCS#11 function and no exception is thrown. At least the following PKCS#11 return values may be returned: CryptokiNotInitialized DeviceError DeviceMemory DeviceRemoved FunctionFailed GeneralError HostMemory OK SlotIdInvalid TokenNotPresent TokenNotRecognized ArgumentsBad

Returns: true on success, false otherwise

Definition at line 148 of file p11.cpp.

   {
   return handle_return_value(m_func_list_ptr->C_GetTokenInfo(slot_id, info_ptr), return_value);
   }

References handle_return_value().

◆ C_Initialize()

bool Botan::PKCS11::LowLevel::C_Initialize	(	VoidPtr	init_args,
		ReturnValue *	return_value = `ThrowException`
	)		const

C_Initialize initializes the Cryptoki library.

Parameters

init_args	if this is not nullptr, it gets cast to (`C_InitializeArgs`) and dereferenced
return_value	default value (`ThrowException`): throw exception on error. if a non-NULL pointer is passed: return_value receives the return value of the PKCS#11 function and no exception is thrown. At least the following PKCS#11 return values may be returned: ArgumentsBad CantLock CryptokiAlreadyInitialized FunctionFailed GeneralError HostMemory NeedToCreateThreads OK

Returns: true on success, false otherwise

Definition at line 82 of file p11.cpp.

   {
   return handle_return_value(m_func_list_ptr->C_Initialize(init_args), return_value);
   }

References handle_return_value().

◆ C_InitPIN() [1/2]

template<typename TAlloc >

bool Botan::PKCS11::LowLevel::C_InitPIN	(	SessionHandle	session,
		const std::vector< uint8_t, TAlloc > &	pin,
		ReturnValue *	return_value = `ThrowException`
	)		const

inline

C_InitPIN initializes the normal user's PIN.

Parameters

session	the session's handle
pin	the normal user's PIN
return_value	default value (`ThrowException`): throw exception on error. if a non-NULL pointer is passed: return_value receives the return value of the PKCS#11 function and no exception is thrown. At least the following PKCS#11 return values may be returned: CryptokiNotInitialized DeviceError DeviceMemory DeviceRemoved FunctionCanceled FunctionFailed GeneralError HostMemory OK PinInvalid PinLenRange SessionClosed SessionReadOnly SessionHandleInvalid TokenWriteProtected UserNotLoggedIn ArgumentsBad

Returns: true on success, false otherwise

Definition at line 1206 of file p11.h.

         {
         return C_InitPIN(session,
                          reinterpret_cast< Utf8Char* >(const_cast< uint8_t* >(pin.data())),
                          static_cast<Ulong>(pin.size()),
                          return_value);
         }

◆ C_InitPIN() [2/2]

bool Botan::PKCS11::LowLevel::C_InitPIN	(	SessionHandle	session,
		Utf8Char *	pin_ptr,
		Ulong	pin_len,
		ReturnValue *	return_value = `ThrowException`
	)		const

C_InitPIN initializes the normal user's PIN.

Parameters

session	the session's handle
pin_ptr	the normal user's PIN
pin_len	length in bytes of the PIN
return_value	default value (`ThrowException`): throw exception on error. if a non-NULL pointer is passed: return_value receives the return value of the PKCS#11 function and no exception is thrown. At least the following PKCS#11 return values may be returned: CryptokiNotInitialized DeviceError DeviceMemory DeviceRemoved FunctionCanceled FunctionFailed GeneralError HostMemory OK PinInvalid PinLenRange SessionClosed SessionReadOnly SessionHandleInvalid TokenWriteProtected UserNotLoggedIn ArgumentsBad

Returns: true on success, false otherwise

Definition at line 212 of file p11.cpp.

   {
   return handle_return_value(m_func_list_ptr->C_InitPIN(session, pin_ptr, pin_len), return_value);
   }

References handle_return_value().

Referenced by Botan::PKCS11::Session::init_pin().

◆ C_InitToken() [1/2]

template<typename TAlloc >

bool Botan::PKCS11::LowLevel::C_InitToken	(	SlotId	slot_id,
		const std::vector< uint8_t, TAlloc > &	so_pin,
		const std::string &	label,
		ReturnValue *	return_value = `ThrowException`
	)		const

inline

C_InitToken initializes a token.

Parameters

slot_id	ID of the token's slot
so_pin	the SO's initial PIN
label	token label (at max 32 bytes long)
return_value	default value (`ThrowException`): throw exception on error. if a non-NULL pointer is passed: return_value receives the return value of the PKCS#11 function and no exception is thrown. At least the following PKCS#11 return values may be returned: CryptokiNotInitialized DeviceError DeviceMemory DeviceRemoved FunctionCanceled FunctionFailed GeneralError HostMemory OK PinIncorrect PinLocked SessionExists SlotIdInvalid TokenNotPresent TokenNotRecognized TokenWriteProtected ArgumentsBad

Returns: true on success, false otherwise

Definition at line 1151 of file p11.h.

         {
         std::string padded_label = label;
         if(label.size() < 32)
            {
            padded_label.insert(padded_label.end(), 32 - label.size(), ' ');
            }
 
         return C_InitToken(slot_id,
                            reinterpret_cast< Utf8Char* >(const_cast< uint8_t* >(so_pin.data())),
                            static_cast<Ulong>(so_pin.size()),
                            reinterpret_cast< Utf8Char* >(const_cast< char* >(padded_label.c_str())),
                            return_value);
         }

◆ C_InitToken() [2/2]

bool Botan::PKCS11::LowLevel::C_InitToken	(	SlotId	slot_id,
		Utf8Char *	so_pin_ptr,
		Ulong	so_pin_len,
		Utf8Char *	label_ptr,
		ReturnValue *	return_value = `ThrowException`
	)		const

C_InitToken initializes a token.

Parameters

slot_id	ID of the token's slot
so_pin_ptr	the SO's initial PIN
so_pin_len	length in bytes of the SO_PIN
label_ptr	32-byte token label (blank padded)
return_value	default value (`ThrowException`): throw exception on error. if a non-NULL pointer is passed: return_value receives the return value of the PKCS#11 function and no exception is thrown. At least the following PKCS#11 return values may be returned: CryptokiNotInitialized DeviceError DeviceMemory DeviceRemoved FunctionCanceled FunctionFailed GeneralError HostMemory OK PinIncorrect PinLocked SessionExists SlotIdInvalid TokenNotPresent TokenNotRecognized TokenWriteProtected ArgumentsBad

Returns: true on success, false otherwise

Definition at line 203 of file p11.cpp.

   {
   return handle_return_value(m_func_list_ptr->C_InitToken(slot_id, so_pin_ptr, so_pin_len, label_ptr), return_value);
   }

References handle_return_value().

◆ C_Login() [1/2]

template<typename TAlloc >

bool Botan::PKCS11::LowLevel::C_Login	(	SessionHandle	session,
		UserType	user_type,
		const std::vector< uint8_t, TAlloc > &	pin,
		ReturnValue *	return_value = `ThrowException`
	)		const

inline

C_Login logs a user into a token.

Parameters

session	the session's handle
user_type	the user type
pin	the user or security officer's PIN
return_value	default value (`ThrowException`): throw exception on error. if a non-NULL pointer is passed: return_value receives the return value of the PKCS#11 function and no exception is thrown. At least the following PKCS#11 return values may be returned: ArgumentsBad CryptokiNotInitialized DeviceError DeviceMemory DeviceRemoved FunctionCanceled FunctionFailed GeneralError HostMemory OK OperationNotInitialized PinIncorrect PinLocked SessionClosed SessionHandleInvalid SessionReadOnlyExists UserAlreadyLoggedIn UserAnotherAlreadyLoggedIn UserPinNotInitialized UserTooManyTypes UserTypeInvalid

Returns: true on success, false otherwise

Definition at line 1432 of file p11.h.

         {
         return C_Login(session, user_type,
                        reinterpret_cast< Utf8Char* >(const_cast< uint8_t* >(pin.data())),
                        static_cast<Ulong>(pin.size()),
                        return_value);
         }

◆ C_Login() [2/2]

bool Botan::PKCS11::LowLevel::C_Login	(	SessionHandle	session,
		UserType	user_type,
		Utf8Char *	pin_ptr,
		Ulong	pin_len,
		ReturnValue *	return_value = `ThrowException`
	)		const

C_Login logs a user into a token.

Parameters

session	the session's handle
user_type	the user type
pin_ptr	the user's PIN
pin_len	the length of the PIN
return_value	default value (`ThrowException`): throw exception on error. if a non-NULL pointer is passed: return_value receives the return value of the PKCS#11 function and no exception is thrown. At least the following PKCS#11 return values may be returned: ArgumentsBad CryptokiNotInitialized DeviceError DeviceMemory DeviceRemoved FunctionCanceled FunctionFailed GeneralError HostMemory OK OperationNotInitialized PinIncorrect PinLocked SessionClosed SessionHandleInvalid SessionReadOnlyExists UserAlreadyLoggedIn UserAnotherAlreadyLoggedIn UserPinNotInitialized UserTooManyTypes UserTypeInvalid

Returns: true on success, false otherwise

Definition at line 283 of file p11.cpp.

   {
   return handle_return_value(m_func_list_ptr->C_Login(session, static_cast< CK_USER_TYPE >(user_type), pin_ptr, pin_len),
                              return_value);
   }

References handle_return_value().

Referenced by Botan::PKCS11::Session::login().

◆ C_Logout()

bool Botan::PKCS11::LowLevel::C_Logout	(	SessionHandle	session,
		ReturnValue *	return_value = `ThrowException`
	)		const

C_Logout logs a user out from a token.

Parameters

session the session's handle

return_value

default value (ThrowException): throw exception on error. if a non-NULL pointer is passed: return_value receives the return value of the PKCS#11 function and no exception is thrown. At least the following PKCS#11 return values may be returned:

CryptokiNotInitialized
DeviceError
DeviceMemory
DeviceRemoved
FunctionFailed
GeneralError
HostMemory
OK
SessionClosed
SessionHandleInvalid
UserNotLoggedIn

Returns: true on success, false otherwise

Definition at line 293 of file p11.cpp.

   {
   return handle_return_value(m_func_list_ptr->C_Logout(session), return_value);
   }

References handle_return_value().

Referenced by Botan::PKCS11::Session::logoff(), and Botan::PKCS11::Session::~Session().

◆ C_OpenSession()

bool Botan::PKCS11::LowLevel::C_OpenSession	(	SlotId	slot_id,
		Flags	flags,
		VoidPtr	application,
		Notify	notify,
		SessionHandle *	session_ptr,
		ReturnValue *	return_value = `ThrowException`
	)		const

C_OpenSession opens a session between an application and a token.

Parameters

slot_id	the slot's ID
flags	from CK_SESSION_INFO
application	passed to callback
notify	callback function
session_ptr	gets session handle
return_value	default value (`ThrowException`): throw exception on error. if a non-NULL pointer is passed: return_value receives the return value of the PKCS#11 function and no exception is thrown. At least the following PKCS#11 return values may be returned: CryptokiNotInitialized DeviceError DeviceMemory DeviceRemoved FunctionFailed GeneralError HostMemory OK SessionCount SessionParallelNotSupported SessionReadWriteSoExists SlotIdInvalid TokenNotPresent TokenNotRecognized TokenWriteProtected ArgumentsBad

Returns: true on success, false otherwise

Definition at line 233 of file p11.cpp.

   {
   return handle_return_value(m_func_list_ptr->C_OpenSession(slot_id, flags, application, notify, session_ptr),
                              return_value);
   }

References Botan::PKCS11::flags(), and handle_return_value().

Referenced by Botan::PKCS11::Session::Session().

◆ C_SeedRandom()

bool Botan::PKCS11::LowLevel::C_SeedRandom	(	SessionHandle	session,
		const Byte *	seed_ptr,
		Ulong	seed_len,
		ReturnValue *	return_value = `ThrowException`
	)		const

C_SeedRandom mixes additional seed material into the token's random number generator.

Parameters

session	the session's handle
seed_ptr	the seed material
seed_len	length of seed material
return_value	default value (`ThrowException`): throw exception on error. if a non-NULL pointer is passed: return_value receives the return value of the PKCS#11 function and no exception is thrown. At least the following PKCS#11 return values may be returned: ArgumentsBad CryptokiNotInitialized DeviceError DeviceMemory DeviceRemoved FunctionCanceled FunctionFailed GeneralError HostMemory OK OperationActive RandomSeedNotSupported RandomNoRng SessionClosed SessionHandleInvalid UserNotLoggedIn

Returns: true on success, false otherwise

Definition at line 741 of file p11.cpp.

   {
   return handle_return_value(
      m_func_list_ptr->C_SeedRandom(session, const_cast<Byte*>(seed_ptr), seed_len),
      return_value);
   }

References handle_return_value().

Referenced by Botan::PKCS11::PKCS11_RNG::add_entropy().

◆ C_SetAttributeValue() [1/2]

bool Botan::PKCS11::LowLevel::C_SetAttributeValue	(	SessionHandle	session,
		ObjectHandle	object,
		Attribute *	attribute_template_ptr,
		Ulong	count,
		ReturnValue *	return_value = `ThrowException`
	)		const

C_SetAttributeValue modifies the value of one or more object attributes.

Parameters

session	the session's handle
object	the object's handle
attribute_template_ptr	specifies attrs and values
count	attributes in template
return_value	default value (`ThrowException`): throw exception on error. if a non-NULL pointer is passed: return_value receives the return value of the PKCS#11 function and no exception is thrown. At least the following PKCS#11 return values may be returned: ActionProhibited ArgumentsBad AttributeReadOnly AttributeTypeInvalid AttributeValueInvalid CryptokiNotInitialized DeviceError DeviceMemory DeviceRemoved FunctionFailed GeneralError HostMemory ObjectHandleInvalid OK SessionClosed SessionHandleInvalid SessionReadOnly TemplateInconsistent TokenWriteProtected UserNotLoggedIn

Returns: true on success, false otherwise

Definition at line 347 of file p11.cpp.

   {
   return handle_return_value(m_func_list_ptr->C_SetAttributeValue(session, object, attribute_template_ptr, count),
                              return_value);
   }

References handle_return_value().

Referenced by Botan::PKCS11::Object::set_attribute_value().

◆ C_SetAttributeValue() [2/2]

template<typename TAlloc >

bool Botan::PKCS11::LowLevel::C_SetAttributeValue	(	SessionHandle	session,
		ObjectHandle	object,
		std::map< AttributeType, std::vector< uint8_t, TAlloc > > &	attribute_values,
		ReturnValue *	return_value = `ThrowException`
	)		const

inline

C_SetAttributeValue modifies the value of one or more object attributes.

Parameters

session	the session's handle
object	the object's handle
attribute_values	specifies attrs and values
return_value	default value (`ThrowException`): throw exception on error. if a non-NULL pointer is passed: return_value receives the return value of the PKCS#11 function and no exception is thrown. At least the following PKCS#11 return values may be returned: ActionProhibited ArgumentsBad AttributeReadOnly AttributeTypeInvalid AttributeValueInvalid CryptokiNotInitialized DeviceError DeviceMemory DeviceRemoved FunctionFailed GeneralError HostMemory ObjectHandleInvalid OK SessionClosed SessionHandleInvalid SessionReadOnly TemplateInconsistent TokenWriteProtected UserNotLoggedIn

Returns: true on success, false otherwise

Definition at line 1667 of file p11.h.

         {
         std::vector<Attribute> setter_template;
 
         for(auto& entry : attribute_values)
            {
            setter_template.emplace_back(Attribute{ static_cast< CK_ATTRIBUTE_TYPE >(entry.first), entry.second.data(), static_cast<CK_ULONG>(entry.second.size()) });
            }
 
         return C_SetAttributeValue(session, object,
                                    const_cast< Attribute* >(setter_template.data()),
                                    static_cast<Ulong>(setter_template.size()),
                                    return_value);
         }

◆ C_SetOperationState()

bool Botan::PKCS11::LowLevel::C_SetOperationState	(	SessionHandle	session,
		Byte *	operation_state_ptr,
		Ulong	operation_state_len,
		ObjectHandle	encryption_key,
		ObjectHandle	authentication_key,
		ReturnValue *	return_value = `ThrowException`
	)		const

C_SetOperationState restores the state of the cryptographic operation in a session.

Parameters

session	session's handle
operation_state_ptr	holds state
operation_state_len	holds state length
encryption_key	en/decryption key
authentication_key	sign/verify key
return_value	default value (`ThrowException`): throw exception on error. if a non-NULL pointer is passed: return_value receives the return value of the PKCS#11 function and no exception is thrown. At least the following PKCS#11 return values may be returned: CryptokiNotInitialized DeviceError DeviceMemory DeviceRemoved FunctionFailed GeneralError HostMemory KeyChanged KeyNeeded KeyNotNeeded OK SavedStateInvalid SessionClosed SessionHandleInvalid ArgumentsBad

Returns: true on success, false otherwise

Definition at line 272 of file p11.cpp.

   {
   return handle_return_value(m_func_list_ptr->C_SetOperationState(session, operation_state_ptr, operation_state_len,
                              encryption_key, authentication_key), return_value);
   }

References handle_return_value().

◆ C_SetPIN() [1/2]

template<typename TAlloc >

bool Botan::PKCS11::LowLevel::C_SetPIN	(	SessionHandle	session,
		const std::vector< uint8_t, TAlloc > &	old_pin,
		const std::vector< uint8_t, TAlloc > &	new_pin,
		ReturnValue *	return_value = `ThrowException`
	)		const

inline

C_SetPIN modifies the PIN of the user who is logged in.

Parameters

session	the session's handle
old_pin	the old PIN
new_pin	the new PIN
return_value	default value (`ThrowException`): throw exception on error. if a non-NULL pointer is passed: return_value receives the return value of the PKCS#11 function and no exception is thrown. At least the following PKCS#11 return values may be returned: CryptokiNotInitialized DeviceError DeviceMemory DeviceRemoved FunctionCanceled FunctionFailed GeneralError HostMemory OK PinIncorrect PinInvalid PinLenRange PinLocked SessionClosed SessionHandleInvalid SessionReadOnly TokenWriteProtected ArgumentsBad

Returns: true on success, false otherwise

Definition at line 1258 of file p11.h.

         {
         return C_SetPIN(session,
                         reinterpret_cast< Utf8Char* >(const_cast< uint8_t* >(old_pin.data())),
                         static_cast<Ulong>(old_pin.size()),
                         reinterpret_cast< Utf8Char* >(const_cast< uint8_t* >(new_pin.data())),
                         static_cast<Ulong>(new_pin.size()),
                         return_value);
         }

◆ C_SetPIN() [2/2]

bool Botan::PKCS11::LowLevel::C_SetPIN	(	SessionHandle	session,
		Utf8Char *	old_pin_ptr,
		Ulong	old_len,
		Utf8Char *	new_pin_ptr,
		Ulong	new_len,
		ReturnValue *	return_value = `ThrowException`
	)		const

C_SetPIN modifies the PIN of the user who is logged in.

Parameters

session	the session's handle
old_pin_ptr	the old PIN
old_len	length of the old PIN
new_pin_ptr	the new PIN
new_len	length of the new PIN
return_value	default value (`ThrowException`): throw exception on error. if a non-NULL pointer is passed: return_value receives the return value of the PKCS#11 function and no exception is thrown. At least the following PKCS#11 return values may be returned: CryptokiNotInitialized DeviceError DeviceMemory DeviceRemoved FunctionCanceled FunctionFailed GeneralError HostMemory OK PinIncorrect PinInvalid PinLenRange PinLocked SessionClosed SessionHandleInvalid SessionReadOnly TokenWriteProtected ArgumentsBad

Returns: true on success, false otherwise

Definition at line 220 of file p11.cpp.

   {
   return handle_return_value(m_func_list_ptr->C_SetPIN(session, old_pin_ptr, old_len, new_pin_ptr, new_len),
                              return_value);
   }

References handle_return_value().

Referenced by Botan::PKCS11::Session::set_pin().

◆ C_Sign() [1/2]

bool Botan::PKCS11::LowLevel::C_Sign	(	SessionHandle	session,
		const Byte *	data_ptr,
		Ulong	data_len,
		Byte *	signature_ptr,
		Ulong *	signature_len_ptr,
		ReturnValue *	return_value = `ThrowException`
	)		const

C_Sign signs (encrypts with private key) data in a single part, where the signature is (will be) an appendix to the data, and plaintext cannot be recovered from the signature.

Parameters

session	the session's handle
data_ptr	the data to sign
data_len	count of bytes to sign
signature_ptr	gets the signature
signature_len_ptr	gets signature length
return_value	default value (`ThrowException`): throw exception on error. if a non-NULL pointer is passed: return_value receives the return value of the PKCS#11 function and no exception is thrown. At least the following PKCS#11 return values may be returned: ArgumentsBad BufferTooSmall CryptokiNotInitialized DataInvalid DataLenRange DeviceError DeviceMemory DeviceRemoved FunctionCanceled FunctionFailed GeneralError HostMemory OK OperationNotInitialized SessionClosed SessionHandleInvalid UserNotLoggedIn FunctionRejected

Returns: true on success, false otherwise

Definition at line 515 of file p11.cpp.

   {
   return handle_return_value(
      m_func_list_ptr->C_Sign(session, const_cast<Byte*>(data_ptr), data_len, signature_ptr, signature_len_ptr),
      return_value);
   }

References handle_return_value().

◆ C_Sign() [2/2]

template<typename TAllocA , typename TAllocB >

bool Botan::PKCS11::LowLevel::C_Sign	(	SessionHandle	session,
		const std::vector< uint8_t, TAllocA > &	data,
		std::vector< uint8_t, TAllocB > &	signature,
		ReturnValue *	return_value = `ThrowException`
	)		const

inline

C_Sign signs (encrypts with private key) data in a single part, where the signature is (will be) an appendix to the data, and plaintext cannot be recovered from the signature.

Parameters

session	the session's handle
data	the data to sign
signature	gets the signature
return_value	default value (`ThrowException`): throw exception on error. if a non-NULL pointer is passed: return_value receives the return value of the PKCS#11 function and no exception is thrown. At least the following PKCS#11 return values may be returned: ArgumentsBad BufferTooSmall CryptokiNotInitialized DataInvalid DataLenRange DeviceError DeviceMemory DeviceRemoved FunctionCanceled FunctionFailed GeneralError HostMemory OK OperationNotInitialized SessionClosed SessionHandleInvalid UserNotLoggedIn FunctionRejected

Returns: true on success, false otherwise

Definition at line 2188 of file p11.h.

         {
         Ulong signature_size = 0;
         if(!C_Sign(session,
                    data.data(),
                    static_cast<Ulong>(data.size()),
                    nullptr,
                    &signature_size,
                    return_value))
            {
            return false;
            }
 
         signature.resize(signature_size);
         if (!C_Sign(session,
                     data.data(),
                     static_cast<Ulong>(data.size()),
                     signature.data(),
                     &signature_size,
                     return_value))
            {
            return false;
            }
         signature.resize(signature_size);
         return true;
         }

◆ C_SignEncryptUpdate()

bool Botan::PKCS11::LowLevel::C_SignEncryptUpdate	(	SessionHandle	session,
		Byte *	part_ptr,
		Ulong	part_len,
		Byte *	encrypted_part_ptr,
		Ulong *	encrypted_part_len_ptr,
		ReturnValue *	return_value = `ThrowException`
	)		const

C_SignEncryptUpdate continues a multiple-part signing and encryption operation.

Parameters

session	session's handle
part_ptr	the plaintext data
part_len	plaintext length
encrypted_part_ptr	gets ciphertext
encrypted_part_len_ptr	gets c-text length
return_value	default value (`ThrowException`): throw exception on error. if a non-NULL pointer is passed: return_value receives the return value of the PKCS#11 function and no exception is thrown. At least the following PKCS#11 return values may be returned: ArgumentsBad BufferTooSmall CryptokiNotInitialized DataLenRange DeviceError DeviceMemory DeviceRemoved FunctionCanceled FunctionFailed GeneralError HostMemory OK OperationNotInitialized SessionClosed SessionHandleInvalid UserNotLoggedIn

Returns: true on success, false otherwise

Definition at line 650 of file p11.cpp.

   {
   return handle_return_value(m_func_list_ptr->C_SignEncryptUpdate(session, part_ptr, part_len, encrypted_part_ptr,
                              encrypted_part_len_ptr), return_value);
   }

References handle_return_value().

◆ C_SignFinal() [1/2]

bool Botan::PKCS11::LowLevel::C_SignFinal	(	SessionHandle	session,
		Byte *	signature_ptr,
		Ulong *	signature_len_ptr,
		ReturnValue *	return_value = `ThrowException`
	)		const

C_SignFinal finishes a multiple-part signature operation, returning the signature.

Parameters

session	the session's handle
signature_ptr	gets the signature
signature_len_ptr	gets signature length
return_value	default value (`ThrowException`): throw exception on error. if a non-NULL pointer is passed: return_value receives the return value of the PKCS#11 function and no exception is thrown. At least the following PKCS#11 return values may be returned: ArgumentsBad BufferTooSmall CryptokiNotInitialized DataLenRange DeviceError DeviceMemory DeviceRemoved FunctionCanceled FunctionFailed GeneralError HostMemory OK OperationNotInitialized SessionClosed SessionHandleInvalid UserNotLoggedIn FunctionRejected

Returns: true on success, false otherwise

Definition at line 537 of file p11.cpp.

   {
   return handle_return_value(m_func_list_ptr->C_SignFinal(session, signature_ptr, signature_len_ptr), return_value);
   }

References handle_return_value().

◆ C_SignFinal() [2/2]

template<typename TAlloc >

bool Botan::PKCS11::LowLevel::C_SignFinal	(	SessionHandle	session,
		std::vector< uint8_t, TAlloc > &	signature,
		ReturnValue *	return_value = `ThrowException`
	)		const

inline

C_SignFinal finishes a multiple-part signature operation, returning the signature.

Parameters

session	the session's handle
signature	gets the signature
return_value	default value (`ThrowException`): throw exception on error. if a non-NULL pointer is passed: return_value receives the return value of the PKCS#11 function and no exception is thrown. At least the following PKCS#11 return values may be returned: ArgumentsBad BufferTooSmall CryptokiNotInitialized DataLenRange DeviceError DeviceMemory DeviceRemoved FunctionCanceled FunctionFailed GeneralError HostMemory OK OperationNotInitialized SessionClosed SessionHandleInvalid UserNotLoggedIn FunctionRejected

Returns: true on success, false otherwise

Definition at line 2300 of file p11.h.

         {
         Ulong signature_size = 0;
         if(!C_SignFinal(session, nullptr, &signature_size, return_value))
            {
            return false;
            }
 
         signature.resize(signature_size);
         if (!C_SignFinal(session, signature.data(), &signature_size, return_value))
            {
            return false;
            }
         signature.resize(signature_size);
         return true;
         }

◆ C_SignInit()

bool Botan::PKCS11::LowLevel::C_SignInit	(	SessionHandle	session,
		Mechanism *	mechanism_ptr,
		ObjectHandle	key,
		ReturnValue *	return_value = `ThrowException`
	)		const

C_SignInit initializes a signature (private key encryption) operation, where the signature is (will be) an appendix to the data, and plaintext cannot be recovered from the signature.

Parameters

session	the session's handle
mechanism_ptr	the signature mechanism
key	handle of signature key
return_value	default value (`ThrowException`): throw exception on error. if a non-NULL pointer is passed: return_value receives the return value of the PKCS#11 function and no exception is thrown. At least the following PKCS#11 return values may be returned: ArgumentsBad CryptokiNotInitialized DeviceError DeviceMemory DeviceRemoved FunctionCanceled FunctionFailed GeneralError HostMemory KeyFunctionNotPermitted KeyHandleInvalid KeySizeRange KeyTypeInconsistent MechanismInvalid MechanismParamInvalid OK OperationActive PinExpired SessionClosed SessionHandleInvalid UserNotLoggedIn

Returns: true on success, false otherwise

Definition at line 507 of file p11.cpp.

   {
   return handle_return_value(m_func_list_ptr->C_SignInit(session, mechanism_ptr, key), return_value);
   }

References handle_return_value().

◆ C_SignRecover()

bool Botan::PKCS11::LowLevel::C_SignRecover	(	SessionHandle	session,
		Byte *	data_ptr,
		Ulong	data_len,
		Byte *	signature_ptr,
		Ulong *	signature_len_ptr,
		ReturnValue *	return_value = `ThrowException`
	)		const

C_SignRecover signs data in a single operation, where the data can be recovered from the signature.

Parameters

session	the session's handle
data_ptr	the data to sign
data_len	count of bytes to sign
signature_ptr	gets the signature
signature_len_ptr	gets signature length
return_value	default value (`ThrowException`): throw exception on error. if a non-NULL pointer is passed: return_value receives the return value of the PKCS#11 function and no exception is thrown. At least the following PKCS#11 return values may be returned: ArgumentsBad BufferTooSmall CryptokiNotInitialized DataInvalid DataLenRange DeviceError DeviceMemory DeviceRemoved FunctionCanceled FunctionFailed GeneralError HostMemory OK OperationNotInitialized SessionClosed SessionHandleInvalid UserNotLoggedIn

Returns: true on success, false otherwise

Definition at line 553 of file p11.cpp.

   {
   return handle_return_value(m_func_list_ptr->C_SignRecover(session, data, data_len, signature, signature_len),
                              return_value);
   }

References handle_return_value().

◆ C_SignRecoverInit()

bool Botan::PKCS11::LowLevel::C_SignRecoverInit	(	SessionHandle	session,
		Mechanism *	mechanism_ptr,
		ObjectHandle	key,
		ReturnValue *	return_value = `ThrowException`
	)		const

C_SignRecoverInit initializes a signature operation, where the data can be recovered from the signature.

Parameters

session	the session's handle
mechanism_ptr	the signature mechanism
key	handle of the signature key
return_value	default value (`ThrowException`): throw exception on error. if a non-NULL pointer is passed: return_value receives the return value of the PKCS#11 function and no exception is thrown. At least the following PKCS#11 return values may be returned: ArgumentsBad CryptokiNotInitialized DeviceError DeviceMemory DeviceRemoved FunctionCanceled FunctionFailed GeneralError HostMemory KeyFunctionNotPermitted KeyHandleInvalid KeySizeRange KeyTypeInconsistent MechanismInvalid MechanismParamInvalid OK OperationActive PinExpired SessionClosed SessionHandleInvalid UserNotLoggedIn

Returns: true on success, false otherwise

Definition at line 545 of file p11.cpp.

   {
   return handle_return_value(m_func_list_ptr->C_SignRecoverInit(session, mechanism_ptr, key), return_value);
   }

References handle_return_value().

◆ C_SignUpdate() [1/2]

bool Botan::PKCS11::LowLevel::C_SignUpdate	(	SessionHandle	session,
		const Byte *	part_ptr,
		Ulong	part_len,
		ReturnValue *	return_value = `ThrowException`
	)		const

C_SignUpdate continues a multiple-part signature operation, where the signature is (will be) an appendix to the data, and plaintext cannot be recovered from the signature.

Parameters

session	the session's handle
part_ptr	the data to sign
part_len	count of bytes to sign
return_value	default value (`ThrowException`): throw exception on error. if a non-NULL pointer is passed: return_value receives the return value of the PKCS#11 function and no exception is thrown. At least the following PKCS#11 return values may be returned: ArgumentsBad CryptokiNotInitialized DataLenRange DeviceError DeviceMemory DeviceRemoved FunctionCanceled FunctionFailed GeneralError HostMemory OK OperationNotInitialized SessionClosed SessionHandleInvalid UserNotLoggedIn

Returns: true on success, false otherwise

Definition at line 527 of file p11.cpp.

   {
   return handle_return_value(
      m_func_list_ptr->C_SignUpdate(session, const_cast<Byte*>(part_ptr), part_len),
      return_value);
   }

References handle_return_value().

◆ C_SignUpdate() [2/2]

template<typename TAlloc >

bool Botan::PKCS11::LowLevel::C_SignUpdate	(	SessionHandle	session,
		const std::vector< uint8_t, TAlloc > &	part,
		ReturnValue *	return_value = `ThrowException`
	)		const

inline

C_SignUpdate continues a multiple-part signature operation, where the signature is (will be) an appendix to the data, and plaintext cannot be recovered from the signature.

Parameters

session	the session's handle
part	the data to sign
return_value	default value (`ThrowException`): throw exception on error. if a non-NULL pointer is passed: return_value receives the return value of the PKCS#11 function and no exception is thrown. At least the following PKCS#11 return values may be returned: ArgumentsBad CryptokiNotInitialized DataLenRange DeviceError DeviceMemory DeviceRemoved FunctionCanceled FunctionFailed GeneralError HostMemory OK OperationNotInitialized SessionClosed SessionHandleInvalid UserNotLoggedIn

Returns: true on success, false otherwise

Definition at line 2253 of file p11.h.

         {
         return C_SignUpdate(session,
                             part.data(),
                             static_cast<Ulong>(part.size()),
                             return_value);
         }

◆ C_UnwrapKey()

bool Botan::PKCS11::LowLevel::C_UnwrapKey	(	SessionHandle	session,
		Mechanism *	mechanism_ptr,
		ObjectHandle	unwrapping_key,
		Byte *	wrapped_key_ptr,
		Ulong	wrapped_key_len,
		Attribute *	attribute_template_ptr,
		Ulong	attribute_count,
		ObjectHandle *	key_ptr,
		ReturnValue *	return_value = `ThrowException`
	)		const

C_UnwrapKey unwraps (decrypts) a wrapped key, creating a new key object.

Parameters

session	session's handle
mechanism_ptr	unwrapping mech.
unwrapping_key	unwrapping key
wrapped_key_ptr	the wrapped key
wrapped_key_len	wrapped key len
attribute_template_ptr	new key template
attribute_count	template length
key_ptr	gets new handle
return_value	default value (`ThrowException`): throw exception on error. if a non-NULL pointer is passed: return_value receives the return value of the PKCS#11 function and no exception is thrown. At least the following PKCS#11 return values may be returned: ArgumentsBad AttributeReadOnly AttributeTypeInvalid AttributeValueInvalid BufferTooSmall CryptokiNotInitialized CurveNotSupported DeviceError DeviceMemory DeviceRemoved DomainParamsInvalid FunctionCanceled FunctionFailed GeneralError HostMemory MechanismInvalid MechanismParamInvalid OK OperationActive PinExpired SessionClosed SessionHandleInvalid SessionReadOnly TemplateIncomplete TemplateInconsistent TokenWriteProtected UnwrappingKeyHandleInvalid UnwrappingKeySizeRange UnwrappingKeyTypeInconsistent UserNotLoggedIn WrappedKeyInvalid WrappedKeyLenRange

Returns: true on success, false otherwise

Definition at line 712 of file p11.cpp.

   {
   return handle_return_value(m_func_list_ptr->C_UnwrapKey(session, mechanism_ptr, unwrapping_key, wrapped_key_ptr,
                              wrapped_key_len, attribute_template_ptr,
                              attribute_count, key_ptr), return_value);
   }

References handle_return_value().

◆ C_Verify() [1/2]

bool Botan::PKCS11::LowLevel::C_Verify	(	SessionHandle	session,
		const Byte *	data_ptr,
		Ulong	data_len,
		const Byte *	signature_ptr,
		Ulong	signature_len,
		ReturnValue *	return_value = `ThrowException`
	)		const

C_Verify verifies a signature in a single-part operation, where the signature is an appendix to the data, and plaintext cannot be recovered from the signature.

Parameters

session	the session's handle
data_ptr	signed data
data_len	length of signed data
signature_ptr	signature
signature_len	signature length
return_value	default value (`ThrowException`): throw exception on error. if a non-NULL pointer is passed: return_value receives the return value of the PKCS#11 function and no exception is thrown. At least the following PKCS#11 return values may be returned: ArgumentsBad CryptokiNotInitialized DataInvalid DataLenRange DeviceError DeviceMemory DeviceRemoved FunctionCanceled FunctionFailed GeneralError HostMemory OK OperationNotInitialized SessionClosed SessionHandleInvalid SignatureInvalid SignatureLenRange

Returns: true on success, false otherwise

Definition at line 574 of file p11.cpp.

   {
   return handle_return_value(
      m_func_list_ptr->C_Verify(session, const_cast<Byte*>(data_ptr), data_len,
                                const_cast<Byte*>(signature_ptr), signature_len),
      return_value);
   }

References handle_return_value().

◆ C_Verify() [2/2]

template<typename TAllocA , typename TAllocB >

bool Botan::PKCS11::LowLevel::C_Verify	(	SessionHandle	session,
		const std::vector< uint8_t, TAllocA > &	data,
		std::vector< uint8_t, TAllocB > &	signature,
		ReturnValue *	return_value = `ThrowException`
	)		const

inline

C_Verify verifies a signature in a single-part operation, where the signature is an appendix to the data, and plaintext cannot be recovered from the signature.

Parameters

session	the session's handle
data	signed data
signature	signature
return_value	default value (`ThrowException`): throw exception on error. if a non-NULL pointer is passed: return_value receives the return value of the PKCS#11 function and no exception is thrown. At least the following PKCS#11 return values may be returned: ArgumentsBad CryptokiNotInitialized DataInvalid DataLenRange DeviceError DeviceMemory DeviceRemoved FunctionCanceled FunctionFailed GeneralError HostMemory OK OperationNotInitialized SessionClosed SessionHandleInvalid SignatureInvalid SignatureLenRange

Returns: true on success, false otherwise

Definition at line 2432 of file p11.h.

         {
         return C_Verify(session,
                         data.data(),
                         static_cast<Ulong>(data.size()),
                         signature.data(),
                         static_cast<Ulong>(signature.size()),
                         return_value);
         }

◆ C_VerifyFinal()

bool Botan::PKCS11::LowLevel::C_VerifyFinal	(	SessionHandle	session,
		const Byte *	signature_ptr,
		Ulong	signature_len,
		ReturnValue *	return_value = `ThrowException`
	)		const

C_VerifyFinal finishes a multiple-part verification operation, checking the signature.

Parameters

session	the session's handle
signature_ptr	signature to verify
signature_len	signature length
return_value	default value (`ThrowException`): throw exception on error. if a non-NULL pointer is passed: return_value receives the return value of the PKCS#11 function and no exception is thrown. At least the following PKCS#11 return values may be returned: ArgumentsBad CryptokiNotInitialized DataLenRange DeviceError DeviceMemory DeviceRemoved FunctionCanceled FunctionFailed GeneralError HostMemory OK OperationNotInitialized SessionClosed SessionHandleInvalid SignatureInvalid SignatureLenRange

Returns: true on success, false otherwise

Definition at line 597 of file p11.cpp.

   {
   return handle_return_value(
      m_func_list_ptr->C_VerifyFinal(session, const_cast<Byte*>(signature_ptr), signature_len),
      return_value);
   }

References handle_return_value().

◆ C_VerifyInit()

bool Botan::PKCS11::LowLevel::C_VerifyInit	(	SessionHandle	session,
		Mechanism *	mechanism_ptr,
		ObjectHandle	key,
		ReturnValue *	return_value = `ThrowException`
	)		const

C_VerifyInit initializes a verification operation, where the signature is an appendix to the data, and plaintext cannot be recovered from the signature (e.g. DSA).

Parameters

session	the session's handle
mechanism_ptr	the verification mechanism
key	verification key
return_value	default value (`ThrowException`): throw exception on error. if a non-NULL pointer is passed: return_value receives the return value of the PKCS#11 function and no exception is thrown. At least the following PKCS#11 return values may be returned: ArgumentsBad CryptokiNotInitialized DeviceError DeviceMemory DeviceRemoved FunctionCanceled FunctionFailed GeneralError HostMemory KeyFunctionNotPermitted KeyHandleInvalid KeySizeRange KeyTypeInconsistent MechanismInvalid MechanismParamInvalid OK OperationActive PinExpired SessionClosed SessionHandleInvalid UserNotLoggedIn

Returns: true on success, false otherwise

Definition at line 566 of file p11.cpp.

   {
   return handle_return_value(m_func_list_ptr->C_VerifyInit(session, mechanism_ptr, key), return_value);
   }

References handle_return_value().

◆ C_VerifyRecover()

bool Botan::PKCS11::LowLevel::C_VerifyRecover	(	SessionHandle	session,
		Byte *	signature_ptr,
		Ulong	signature_len,
		Byte *	data_ptr,
		Ulong *	data_len_ptr,
		ReturnValue *	return_value = `ThrowException`
	)		const

C_VerifyRecover verifies a signature in a single-part operation, where the data is recovered from the signature.

Parameters

session	the session's handle
signature_ptr	signature to verify
signature_len	signature length
data_ptr	gets signed data
data_len_ptr	gets signed data len
return_value	default value (`ThrowException`): throw exception on error. if a non-NULL pointer is passed: return_value receives the return value of the PKCS#11 function and no exception is thrown. At least the following PKCS#11 return values may be returned: ArgumentsBad BufferTooSmall CryptokiNotInitialized DataInvalid DataLenRange DeviceError DeviceMemory DeviceRemoved FunctionCanceled FunctionFailed GeneralError HostMemory OK OperationNotInitialized SessionClosed SessionHandleInvalid SignatureLenRange SignatureInvalid

Returns: true on success, false otherwise

Definition at line 615 of file p11.cpp.

   {
   return handle_return_value(m_func_list_ptr->C_VerifyRecover(session, signature_ptr, signature_len, data_ptr,
                              data_len_ptr), return_value);
   }

References handle_return_value().

◆ C_VerifyRecoverInit()

bool Botan::PKCS11::LowLevel::C_VerifyRecoverInit	(	SessionHandle	session,
		Mechanism *	mechanism_ptr,
		ObjectHandle	key,
		ReturnValue *	return_value = `ThrowException`
	)		const

C_VerifyRecoverInit initializes a signature verification operation, where the data is recovered from the signature.

Parameters

session	the session's handle
mechanism_ptr	the verification mechanism
key	verification key
return_value	default value (`ThrowException`): throw exception on error. if a non-NULL pointer is passed: return_value receives the return value of the PKCS#11 function and no exception is thrown. At least the following PKCS#11 return values may be returned: ArgumentsBad CryptokiNotInitialized DeviceError DeviceMemory DeviceRemoved FunctionCanceled FunctionFailed GeneralError HostMemory KeyFunctionNotPermitted KeyHandleInvalid KeySizeRange KeyTypeInconsistent MechanismInvalid MechanismParamInvalid OK OperationActive PinExpired SessionClosed SessionHandleInvalid UserNotLoggedIn

Returns: true on success, false otherwise

Definition at line 607 of file p11.cpp.

   {
   return handle_return_value(m_func_list_ptr->C_VerifyRecoverInit(session, mechanism_ptr, key), return_value);
   }

References handle_return_value().

◆ C_VerifyUpdate() [1/2]

bool Botan::PKCS11::LowLevel::C_VerifyUpdate	(	SessionHandle	session,
		const Byte *	part_ptr,
		Ulong	part_len,
		ReturnValue *	return_value = `ThrowException`
	)		const

C_VerifyUpdate continues a multiple-part verification operation, where the signature is an appendix to the data, and plaintext cannot be recovered from the signature.

Parameters

session	the session's handle
part_ptr	signed data
part_len	length of signed data
return_value	default value (`ThrowException`): throw exception on error. if a non-NULL pointer is passed: return_value receives the return value of the PKCS#11 function and no exception is thrown. At least the following PKCS#11 return values may be returned: ArgumentsBad CryptokiNotInitialized DataLenRange DeviceError DeviceMemory DeviceRemoved FunctionCanceled FunctionFailed GeneralError HostMemory OK OperationNotInitialized SessionClosed SessionHandleInvalid

Returns: true on success, false otherwise

Definition at line 587 of file p11.cpp.

   {
   return handle_return_value(
      m_func_list_ptr->C_VerifyUpdate(session, const_cast<Byte*>(part_ptr), part_len),
      return_value);
   }

References handle_return_value().

◆ C_VerifyUpdate() [2/2]

template<typename TAlloc >

bool Botan::PKCS11::LowLevel::C_VerifyUpdate	(	SessionHandle	session,
		std::vector< uint8_t, TAlloc >	part,
		ReturnValue *	return_value = `ThrowException`
	)		const

inline

C_VerifyUpdate continues a multiple-part verification operation, where the signature is an appendix to the data, and plaintext cannot be recovered from the signature.

Parameters

session	the session's handle
part	signed data
return_value	default value (`ThrowException`): throw exception on error. if a non-NULL pointer is passed: return_value receives the return value of the PKCS#11 function and no exception is thrown. At least the following PKCS#11 return values may be returned: ArgumentsBad CryptokiNotInitialized DataLenRange DeviceError DeviceMemory DeviceRemoved FunctionCanceled FunctionFailed GeneralError HostMemory OK OperationNotInitialized SessionClosed SessionHandleInvalid

Returns: true on success, false otherwise

Definition at line 2480 of file p11.h.

         {
         return C_VerifyUpdate(session, part.data(), static_cast<Ulong>(part.size()), return_value);
         }

◆ C_WaitForSlotEvent()

bool Botan::PKCS11::LowLevel::C_WaitForSlotEvent	(	Flags	flags,
		SlotId *	slot_ptr,
		VoidPtr	reserved,
		ReturnValue *	return_value = `ThrowException`
	)		const

C_WaitForSlotEvent waits for a slot event (token insertion, removal, etc.) to occur.

Parameters

flags	blocking/nonblocking flag
slot_ptr	location that receives the slot ID
reserved	reserved. Should be NULL_PTR
return_value	default value (`ThrowException`): throw exception on error. if a non-NULL pointer is passed: return_value receives the return value of the PKCS#11 function and no exception is thrown. At least the following PKCS#11 return values may be returned: ArgumentsBad CryptokiNotInitialized FunctionFailed GeneralError HostMemory NoEvent OK

Returns: true on success, false otherwise

Definition at line 155 of file p11.cpp.

   {
   return handle_return_value(m_func_list_ptr->C_WaitForSlotEvent(flags, slot_ptr, reserved), return_value);
   }

References Botan::PKCS11::flags(), and handle_return_value().

◆ C_WrapKey()

bool Botan::PKCS11::LowLevel::C_WrapKey	(	SessionHandle	session,
		Mechanism *	mechanism_ptr,
		ObjectHandle	wrapping_key,
		ObjectHandle	key,
		Byte *	wrapped_key_ptr,
		Ulong *	wrapped_key_len_ptr,
		ReturnValue *	return_value = `ThrowException`
	)		const

C_WrapKey wraps (i.e., encrypts) a key.

Parameters

session	the session's handle
mechanism_ptr	the wrapping mechanism
wrapping_key	wrapping key
key	key to be wrapped
wrapped_key_ptr	gets wrapped key
wrapped_key_len_ptr	gets wrapped key size
return_value	default value (`ThrowException`): throw exception on error. if a non-NULL pointer is passed: return_value receives the return value of the PKCS#11 function and no exception is thrown. At least the following PKCS#11 return values may be returned: ArgumentsBad BufferTooSmall CryptokiNotInitialized DeviceError DeviceMemory DeviceRemoved FunctionCanceled FunctionFailed GeneralError HostMemory KeyHandleInvalid KeyNotWrappable KeySizeRange KeyUnextractable MechanismInvalid MechanismParamInvalid OK OperationActive PinExpired SessionClosed SessionHandleInvalid UserNotLoggedIn WrappingKeyHandleInvalid WrappingKeySizeRange WrappingKeyTypeInconsistent

Returns: true on success, false otherwise

Definition at line 700 of file p11.cpp.

   {
   return handle_return_value(m_func_list_ptr->C_WrapKey(session, mechanism_ptr, wrapping_key, key, wrapped_key_ptr,
                              wrapped_key_len_ptr), return_value);
   }

References handle_return_value().

◆ get_functions()

FunctionListPtr Botan::PKCS11::LowLevel::get_functions ( ) const

inline

Return the PKCS11 function list that this LowLevel class contains.

This is primarily useful when invoking vendor specific extension functions which are not supported directly by LowLevel or the higher level PKCS11 API.

Definition at line 2897 of file p11.h.

2897{ return m_func_list_ptr; }

◆ handle_return_value()

bool Botan::PKCS11::LowLevel::handle_return_value	(	const CK_RV	function_result,
		ReturnValue *	return_value
	)

staticprotected

A helper for error handling. This is exposed as a protected member so that it is possible for an application to inherit from LowLevel in order to implement wrappers for vendor specific extensions using the same error handling mechanisms as the rest of the library.

Parameters

function_result	Return value of the PKCS11 module function
return_value	if (`ThrowException`) is passed the function throws an exception, otherwise if a non-NULL pointer is passed: return_value receives the return value of the PKCS#11 function and no exception is thrown.

Returns: true if function call was successful, false otherwise

Definition at line 25 of file p11.cpp.

   {
   if(return_value == ThrowException)
      {
      if(static_cast< ReturnValue >(function_result) != ReturnValue::OK)
         {
         // caller wants exception
         throw PKCS11_ReturnError(static_cast< ReturnValue >(function_result));
         }
      }
   else if(return_value != nullptr)
      {
      // caller wants return value
      *return_value = static_cast< ReturnValue >(function_result);
      }
 
   return static_cast< ReturnValue >(function_result) == ReturnValue::OK;
   }

References Botan::PKCS11::OK, and Botan::PKCS11::ThrowException.

Referenced by 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_Initialize(), C_InitPIN(), C_InitToken(), 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_UnwrapKey(), C_Verify(), C_VerifyFinal(), C_VerifyInit(), C_VerifyRecover(), C_VerifyRecoverInit(), C_VerifyUpdate(), C_WaitForSlotEvent(), and C_WrapKey().

The documentation for this class was generated from the following files:

src/lib/prov/pkcs11/p11.h
src/lib/prov/pkcs11/p11.cpp

Public Member Functions

Static Public Member Functions

Static Protected Member Functions

Detailed Description

Constructor & Destructor Documentation

◆ LowLevel()

Member Function Documentation

◆ C_CancelFunction()

◆ C_CloseAllSessions()

◆ C_CloseSession()

◆ C_CopyObject()

◆ C_CreateObject()

◆ C_Decrypt() [1/2]

◆ C_Decrypt() [2/2]

◆ 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() [1/2]

◆ C_Encrypt() [2/2]

◆ C_EncryptFinal()

◆ C_EncryptInit()

◆ C_EncryptUpdate()

◆ C_Finalize()

◆ C_FindObjects()

◆ C_FindObjectsFinal()

◆ C_FindObjectsInit()

◆ C_GenerateKey()

◆ C_GenerateKeyPair()

◆ C_GenerateRandom()

◆ C_GetAttributeValue() [1/2]

◆ C_GetAttributeValue() [2/2]

◆ C_GetFunctionList()

◆ C_GetFunctionStatus()

◆ C_GetInfo()

◆ C_GetMechanismInfo()

◆ C_GetMechanismList() [1/2]

◆ C_GetMechanismList() [2/2]

◆ C_GetObjectSize()

◆ C_GetOperationState()

◆ C_GetSessionInfo()

◆ C_GetSlotInfo()

◆ C_GetSlotList() [1/2]

◆ C_GetSlotList() [2/2]

◆ C_GetTokenInfo()

◆ C_Initialize()

◆ C_InitPIN() [1/2]

◆ C_InitPIN() [2/2]

◆ C_InitToken() [1/2]

◆ C_InitToken() [2/2]

◆ C_Login() [1/2]

◆ C_Login() [2/2]

◆ C_Logout()

◆ C_OpenSession()

◆ C_SeedRandom()

◆ C_SetAttributeValue() [1/2]

◆ C_SetAttributeValue() [2/2]

◆ C_SetOperationState()

◆ C_SetPIN() [1/2]

◆ C_SetPIN() [2/2]

◆ C_Sign() [1/2]

◆ C_Sign() [2/2]

◆ C_SignEncryptUpdate()

◆ C_SignFinal() [1/2]

◆ C_SignFinal() [2/2]

◆ C_SignInit()

◆ C_SignRecover()

◆ C_SignRecoverInit()

◆ C_SignUpdate() [1/2]

◆ C_SignUpdate() [2/2]

◆ C_UnwrapKey()