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

bool	C_InitPIN (SessionHandle session, Utf8Char pin_ptr, Ulong pin_len, 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_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_InitToken (SlotId slot_id, const std::vector< uint8_t, TAlloc > &so_pin, const std::string &label, ReturnValue *return_value=ThrowException) const

bool	C_Login (SessionHandle session, UserType user_type, Utf8Char pin_ptr, Ulong pin_len, 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_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, 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

bool	C_SetPIN (SessionHandle session, Utf8Char old_pin_ptr, Ulong old_len, Utf8Char new_pin_ptr, Ulong new_len, 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_Sign (SessionHandle session, 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, 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, Byte data_ptr, Ulong data_len, 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, 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, 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

	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)

Detailed Description

Provides access to all PKCS#11 functions.

Definition at line 901 of file p11.h.

Constructor & Destructor Documentation

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 73 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

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 758 of file p11.cpp.

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

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 252 of file p11.cpp.

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

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 246 of file p11.cpp.

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

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

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 313 of file p11.cpp.

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

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

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 303 of file p11.cpp.

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

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 434 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);
    }

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 1942 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;
          }

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 632 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);
    }

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 456 of file p11.cpp.

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

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 426 of file p11.cpp.

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

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 445 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);
    }

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 654 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);
    }

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 720 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);
    }

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 324 of file p11.cpp.

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

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

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 473 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);
    }

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 621 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);
    }

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 499 of file p11.cpp.

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

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 466 of file p11.cpp.

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

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 492 of file p11.cpp.

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

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 484 of file p11.cpp.

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

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 393 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);
    }

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 1804 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;
          }

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 415 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);
    }

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 385 of file p11.cpp.

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

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 404 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);
    }

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 90 of file p11.cpp.

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

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 367 of file p11.cpp.

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

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

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 377 of file p11.cpp.

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

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

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 359 of file p11.cpp.

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

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

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 667 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);
    }

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 678 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);
    }

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 742 of file p11.cpp.

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

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

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 339 of file p11.cpp.

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

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

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 1584 of file p11.h.

References Botan::PKCS11::ThrowException.

          {
          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);
          }

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 102 of file p11.cpp.

References Botan::Dynamically_Loaded_Library::resolve().

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

    {
    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);
    }

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 752 of file p11.cpp.

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

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 96 of file p11.cpp.

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

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 196 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);
    }

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 165 of file p11.cpp.

Referenced by C_GetMechanismList().

    {
    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);
    }

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 174 of file p11.cpp.

References C_GetMechanismList().

    {
    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);
    }

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 331 of file p11.cpp.

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

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 265 of file p11.cpp.

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

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 258 of file p11.cpp.

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

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

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 143 of file p11.cpp.

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

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 114 of file p11.cpp.

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

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

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 122 of file p11.cpp.

References C_GetSlotList().

    {
    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);
    }

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 150 of file p11.cpp.

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

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 84 of file p11.cpp.

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

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 214 of file p11.cpp.

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

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

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 1203 of file p11.h.

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

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 205 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);
    }

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 1148 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);
          }

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 285 of file p11.cpp.

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

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

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 1429 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);
          }

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 295 of file p11.cpp.

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

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

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 235 of file p11.cpp.

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

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

bool Botan::PKCS11::LowLevel::C_SeedRandom	(	SessionHandle	session,
		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 734 of file p11.cpp.

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

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

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 349 of file p11.cpp.

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

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

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 1664 of file p11.h.

References Botan::PKCS11::ThrowException.

          {
          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);
          }

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 274 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);
    }

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 222 of file p11.cpp.

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

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

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 1255 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);
          }

bool Botan::PKCS11::LowLevel::C_Sign	(	SessionHandle	session,
		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 517 of file p11.cpp.

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

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 2185 of file p11.h.

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

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 643 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);
    }

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 536 of file p11.cpp.

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

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 2297 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;
          }

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 509 of file p11.cpp.

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

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 552 of file p11.cpp.

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

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 544 of file p11.cpp.

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

bool Botan::PKCS11::LowLevel::C_SignUpdate	(	SessionHandle	session,
		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 528 of file p11.cpp.

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

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 2250 of file p11.h.

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

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 705 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);
    }

bool Botan::PKCS11::LowLevel::C_Verify	(	SessionHandle	session,
		Byte *	data_ptr,
		Ulong	data_len,
		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 573 of file p11.cpp.

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

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 2429 of file p11.h.

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

bool Botan::PKCS11::LowLevel::C_VerifyFinal	(	SessionHandle	session,
		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 592 of file p11.cpp.

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

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 565 of file p11.cpp.

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

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 608 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);
    }

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 600 of file p11.cpp.

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

bool Botan::PKCS11::LowLevel::C_VerifyUpdate	(	SessionHandle	session,
		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 584 of file p11.cpp.

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

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 2477 of file p11.h.

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

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 157 of file p11.cpp.

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

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 693 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);
    }

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

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation