Botan  2.7.0
Crypto and TLS for C++11
Public Member Functions | Static Public Member Functions | List of all members
Botan::PKCS11::LowLevel Class Reference

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

◆ LowLevel()

Botan::PKCS11::LowLevel::LowLevel ( FunctionListPtr  ptr)
explicit
Parameters
ptrthe functon list pointer to use. Can be retrieved via LowLevel::C_GetFunctionList

Definition at line 73 of file p11.cpp.

73  :
74  m_func_list_ptr(ptr)
75  {
76  if(m_func_list_ptr == nullptr)
77  {
78  throw Invalid_Argument("Invalid PKCS#11 function list ptr");
79  }
80  }

Member Function Documentation

◆ C_CancelFunction()

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

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

Parameters
sessionthe session's handle
return_valuedefault 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.

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

◆ C_CloseAllSessions()

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

C_CloseAllSessions closes all sessions with a token.

Parameters
slot_idthe token's slot
return_valuedefault 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.

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

◆ C_CloseSession()

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

C_CloseSession closes a session between an application and a token.

Parameters
sessionthe session's handle
return_valuedefault 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().

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

◆ C_CopyObject()

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

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

Parameters
sessionthe session's handle
objectthe object's handle
attribute_template_ptrtemplate for new object
countattributes in template
new_object_ptrreceives handle of copy
return_valuedefault 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().

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

◆ C_CreateObject()

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

C_CreateObject creates a new object.

Parameters
sessionthe session's handle
attribute_template_ptrthe object's template
countattributes in template
object_ptrgets new object's handle.
return_valuedefault 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.

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

◆ C_Decrypt() [1/2]

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

C_Decrypt decrypts encrypted data in a single part.

Parameters
sessionsession's handle
encrypted_data_ptrciphertext
encrypted_data_lenciphertext length
data_ptrgets plaintext
data_len_ptrgets p-text size
return_valuedefault 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.

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

◆ C_Decrypt() [2/2]

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

C_Decrypt decrypts encrypted data in a single part.

Parameters
sessionsession's handle
encrypted_dataciphertext
decrypted_datagets plaintext
return_valuedefault 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 1914 of file p11.h.

1918  {
1919  Ulong decrypted_size = 0;
1920  if(!C_Decrypt(session, const_cast<Byte*>((encrypted_data.data())), encrypted_data.size(), nullptr, &decrypted_size,
1921  return_value))
1922  {
1923  return false;
1924  }
1925 
1926  decrypted_data.resize(decrypted_size);
1927  return C_Decrypt(session, const_cast<Byte*>(encrypted_data.data()), encrypted_data.size(), decrypted_data.data(),
1928  &decrypted_size, return_value);
1929  }
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
Definition: p11.cpp:434
CK_ULONG Ulong
Definition: p11.h:836

◆ C_DecryptDigestUpdate()

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

C_DecryptDigestUpdate continues a multiple-part decryption and digesting operation.

Parameters
sessionsession's handle
encrypted_part_ptrciphertext
encrypted_part_lenciphertext length
part_ptrgets plaintext
part_len_ptrgets plaintext len
return_valuedefault 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.

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

◆ C_DecryptFinal()

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

C_DecryptFinal finishes a multiple-part decryption operation.

Parameters
sessionthe session's handle
last_part_ptrgets plaintext
last_part_len_ptrp-text size
return_valuedefault 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.

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

◆ C_DecryptInit()

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

C_DecryptInit initializes a decryption operation.

Parameters
sessionthe session's handle
mechanism_ptrthe decryption mechanism
keyhandle of decryption key
return_valuedefault 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.

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

◆ C_DecryptUpdate()

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

C_DecryptUpdate continues a multiple-part decryption operation.

Parameters
sessionsession's handle
encrypted_part_ptrencrypted data
encrypted_part_leninput length
part_ptrgets plaintext
part_len_ptrp-text size
return_valuedefault 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.

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

◆ C_DecryptVerifyUpdate()

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

C_DecryptVerifyUpdate continues a multiple-part decryption and verify operation.

Parameters
sessionsession's handle
encrypted_part_ptrciphertext
encrypted_part_lenciphertext length
part_ptrgets plaintext
part_len_ptrgets p-text length
return_valuedefault 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.

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

◆ C_DeriveKey()

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

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

Parameters
sessionsession's handle
mechanism_ptrkey deriv. mech.
base_keybase key
attribute_template_ptrnew key template
attribute_counttemplate length
key_ptrgets new handle
return_valuedefault 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.

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

◆ C_DestroyObject()

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

C_DestroyObject destroys an object.

Parameters
sessionthe session's handle
objectthe object's handle
return_valuedefault 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().

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

◆ C_Digest()

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

C_Digest digests data in a single part.

Parameters
sessionthe session's handle
data_ptrdata to be digested
data_lenbytes of data to digest
digest_ptrgets the message digest
digest_len_ptrgets digest length
return_valuedefault 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.

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

◆ C_DigestEncryptUpdate()

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

C_DigestEncryptUpdate continues a multiple-part digesting and encryption operation.

Parameters
sessionsession's handle
part_ptrthe plaintext data
part_lenplaintext length
encrypted_part_ptrgets ciphertext
encrypted_part_len_ptrgets c-text length
return_valuedefault 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.

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

◆ C_DigestFinal()

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

C_DigestFinal finishes a multiple-part message-digesting operation.

Parameters
sessionthe session's handle
digest_ptrgets the message digest
digest_len_ptrgets uint8_t count of digest
return_valuedefault 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.

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

◆ C_DigestInit()

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

C_DigestInit initializes a message-digesting operation.

Parameters
sessionthe session's handle
mechanism_ptrthe digesting mechanism
return_valuedefault 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.

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

◆ C_DigestKey()

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

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

Parameters
sessionthe session's handle
keysecret key to digest
return_valuedefault 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.

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

◆ C_DigestUpdate()

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

C_DigestUpdate continues a multiple-part message-digesting operation.

Parameters
sessionthe session's handle
part_ptrdata to be digested
part_lenbytes of data to be digested
return_valuedefault 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.

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

◆ C_Encrypt() [1/2]

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

C_Encrypt encrypts single-part data.

Parameters
sessionsession's handle
data_ptrthe plaintext data
data_lensize of plaintext data in bytes
encrypted_datagets ciphertext
encrypted_data_len_ptrgets c-text size
return_valuedefault 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.

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

◆ C_Encrypt() [2/2]

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

C_Encrypt encrypts single-part data.

Parameters
sessionsession's handle
plaintext_datathe plaintext data
encrypted_datagets ciphertext
return_valuedefault 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 1787 of file p11.h.

1791  {
1792  Ulong encrypted_size = 0;
1793  if(!C_Encrypt(session, const_cast<Byte*>((plaintext_data.data())), plaintext_data.size(), nullptr, &encrypted_size,
1794  return_value))
1795  {
1796  return false;
1797  }
1798 
1799  encrypted_data.resize(encrypted_size);
1800  return C_Encrypt(session, const_cast<Byte*>(plaintext_data.data()), plaintext_data.size(), encrypted_data.data(),
1801  &encrypted_size, return_value);
1802  }
CK_ULONG Ulong
Definition: p11.h:836
bool C_Encrypt(SessionHandle session, Byte *data_ptr, Ulong data_len, Byte *encrypted_data, Ulong *encrypted_data_len_ptr, ReturnValue *return_value=ThrowException) const
Definition: p11.cpp:393

◆ C_EncryptFinal()

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

C_EncryptFinal finishes a multiple-part encryption operation.

Parameters
sessionsession handle
last_encrypted_part_ptrlast c-text
last_encrypted_part_len_ptrgets last size
return_valuedefault 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.

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

◆ C_EncryptInit()

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

C_EncryptInit initializes an encryption operation.

Parameters
sessionthe session's handle
mechanism_ptrthe encryption mechanism
keyhandle of encryption key
return_valuedefault 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.

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

◆ C_EncryptUpdate()

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

C_EncryptUpdate continues a multiple-part encryption operation.

Parameters
sessionsession's handle
part_ptrthe plaintext data
part_lenplaintext data len
encrypted_part_ptrgets ciphertext
encrypted_part_len_ptrgets c-text size
return_valuedefault 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.

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

◆ C_Finalize()

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

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

Parameters
reservedreserved. Should be nullptr
return_valuedefault 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.

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

◆ C_FindObjects()

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

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

Parameters
sessionsession's handle
object_ptrgets obj. handles
max_object_countmax handles to get
object_count_ptractual # returned
return_valuedefault 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().

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

◆ C_FindObjectsFinal()

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

C_FindObjectsFinal finishes a search for token and session objects.

Parameters
sessionthe session's handle
return_valuedefault 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().

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

◆ C_FindObjectsInit()

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

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

Parameters
sessionthe session's handle
attribute_template_ptrattribute values to match
countattrs in search template
return_valuedefault 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().

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

◆ C_GenerateKey()

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

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

Parameters
sessionthe session's handle
mechanism_ptrkey generation mech.
attribute_template_ptrtemplate for new key
count# of attrs in template
key_ptrgets handle of new key
return_valuedefault 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.

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

◆ C_GenerateKeyPair()

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

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

Parameters
sessionsession handle
mechanism_ptrkey-gen mech.
public_key_template_ptrtemplate for pub. key
public_key_attribute_count# pub. attrs.
private_key_template_ptrtemplate for priv. key
private_key_attribute_count# priv. attrs.
public_key_ptrgets pub. key handle
private_key_ptrgets priv. key handle
return_valuedefault 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.

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

◆ C_GenerateRandom()

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

C_GenerateRandom generates random data.

Parameters
sessionthe session's handle
random_data_ptrreceives the random data
random_len# of bytes to generate
return_valuedefault 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().

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

◆ C_GetAttributeValue() [1/2]

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

C_GetAttributeValue obtains the value of one or more object attributes.

Parameters
sessionthe session's handle
objectthe object's handle
attribute_template_ptrspecifies attrs; gets vals
countattributes in template
return_valuedefault 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().

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

◆ C_GetAttributeValue() [2/2]

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

C_GetAttributeValue obtains the value of one or more object attributes.

Parameters
sessionthe session's handle
objectthe object's handle
attribute_valuesspecifies attrs; gets vals
return_valuedefault 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 1574 of file p11.h.

1578  {
1579  std::vector<Attribute> getter_template;
1580 
1581  for(const auto& entry : attribute_values)
1582  {
1583  getter_template.emplace_back(Attribute{ static_cast< CK_ATTRIBUTE_TYPE >(entry.first), nullptr, 0 });
1584  }
1585 
1586  bool success = C_GetAttributeValue(session, object, const_cast< Attribute* >(getter_template.data()),
1587  getter_template.size(), return_value);
1588 
1589  if(!success)
1590  {
1591  return success;
1592  }
1593 
1594  size_t i = 0;
1595  for(auto& entry : attribute_values)
1596  {
1597  entry.second.clear();
1598  entry.second.resize(getter_template.at(i).ulValueLen);
1599  getter_template.at(i).pValue = const_cast< uint8_t* >(entry.second.data());
1600  i++;
1601  }
1602 
1603  return C_GetAttributeValue(session, object, const_cast< Attribute* >(getter_template.data()), getter_template.size(),
1604  return_value);
1605  }
bool C_GetAttributeValue(SessionHandle session, ObjectHandle object, Attribute *attribute_template_ptr, Ulong count, ReturnValue *return_value=ThrowException) const
Definition: p11.cpp:339
CK_ULONG CK_ATTRIBUTE_TYPE
Definition: pkcs11t.h:416
CK_ATTRIBUTE Attribute
Definition: p11.h:845

◆ C_GetFunctionList()

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

C_GetFunctionList returns the function list.

Parameters
pkcs11_moduleThe PKCS#11 module
function_list_ptr_ptrreceives pointer to function list
return_valuedefault 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().

104  {
105  using get_function_list = CK_RV(*)(FunctionListPtr*);
106 
107  get_function_list get_function_list_ptr = pkcs11_module.resolve<get_function_list>("C_GetFunctionList");
108 
109  return handle_return_value(get_function_list_ptr(function_list_ptr_ptr), return_value);
110  }
CK_FUNCTION_LIST_PTR FunctionListPtr
Definition: p11.h:825
CK_ULONG CK_RV
Definition: pkcs11t.h:1036

◆ C_GetFunctionStatus()

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

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

Parameters
sessionthe session's handle
return_valuedefault 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.

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

◆ C_GetInfo()

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

C_GetInfo returns general information about Cryptoki.

Parameters
info_ptrlocation that receives information
return_valuedefault 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.

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

◆ C_GetMechanismInfo()

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

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

Parameters
slot_idID of the token's slot
typetype of mechanism
info_ptrreceives mechanism info
return_valuedefault 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.

References type.

200  {
201  return handle_return_value(m_func_list_ptr->C_GetMechanismInfo(slot_id, static_cast< CK_MECHANISM_TYPE >(type),
202  info_ptr), return_value);
203  }
MechanismType type

◆ C_GetMechanismList() [1/2]

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

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

Parameters
slot_idID of token's slot
mechanism_list_ptrgets mech. array
count_ptrgets # of mechs.
return_valuedefault 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().

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

◆ C_GetMechanismList() [2/2]

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

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

Parameters
slot_idID of token's slot
mechanismsreceives vector of supported mechanisms
return_valuedefault 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().

177  {
178  mechanisms.clear();
179 
180  // first get number of mechanisms
181  Ulong number_mechanisms = 0;
182 
183  bool success = C_GetMechanismList(slot_id, nullptr, &number_mechanisms, return_value);
184 
185  if(!success || !number_mechanisms)
186  {
187  return success;
188  }
189 
190  // get actual mechanisms
191  mechanisms.resize(number_mechanisms);
192  return C_GetMechanismList(slot_id, reinterpret_cast< MechanismType* >(mechanisms.data()), &number_mechanisms,
193  return_value);
194  }
CK_ULONG Ulong
Definition: p11.h:836
bool C_GetMechanismList(SlotId slot_id, MechanismType *mechanism_list_ptr, Ulong *count_ptr, ReturnValue *return_value=ThrowException) const
Definition: p11.cpp:165

◆ C_GetObjectSize()

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

C_GetObjectSize gets the size of an object in bytes.

Parameters
sessionthe session's handle
objectthe object's handle
size_ptrreceives size of object
return_valuedefault 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.

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

◆ C_GetOperationState()

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

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

Parameters
sessionsession's handle
operation_state_ptrgets state
operation_state_len_ptrgets state length
return_valuedefault 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.

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

◆ C_GetSessionInfo()

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

C_GetSessionInfo obtains information about the session.

Parameters
sessionthe session's handle
info_ptrreceives session info
return_valuedefault 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().

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

◆ C_GetSlotInfo()

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

C_GetSlotInfo obtains information about a particular slot in the system.

Parameters
slot_idthe ID of the slot
info_ptrreceives the slot information
return_valuedefault 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.

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

◆ C_GetSlotList() [1/2]

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

C_GetSlotList obtains a list of slots in the system.

Parameters
token_presentonly slots with tokens
slot_list_ptrreceives array of slot IDs
count_ptrreceives number of slots
return_valuedefault 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().

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

◆ C_GetSlotList() [2/2]

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

C_GetSlotList obtains a list of slots in the system.

Parameters
token_presentonly slots with tokens
slot_idsreceives vector of slot IDs
return_valuedefault 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().

125  {
126  slot_ids.clear();
127 
128  // first get available slots
129  Ulong number_slots = 0;
130 
131  bool success = C_GetSlotList(token_present, nullptr, &number_slots, return_value);
132 
133  if(!success || !number_slots)
134  {
135  return success;
136  }
137 
138  // get actual slot ids
139  slot_ids.resize(number_slots);
140  return C_GetSlotList(token_present, slot_ids.data(), &number_slots, return_value);
141  }
CK_ULONG Ulong
Definition: p11.h:836
bool C_GetSlotList(Bbool token_present, SlotId *slot_list_ptr, Ulong *count_ptr, ReturnValue *return_value=ThrowException) const
Definition: p11.cpp:114

◆ C_GetTokenInfo()

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

C_GetTokenInfo obtains information about a particular token in the system.

Parameters
slot_idID of the token's slot
info_ptrreceives the token information
return_valuedefault 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.

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

◆ C_Initialize()

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

C_Initialize initializes the Cryptoki library.

Parameters
init_argsif this is not nullptr, it gets cast to (C_InitializeArgs) and dereferenced
return_valuedefault 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.

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

◆ C_InitPIN() [1/2]

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

C_InitPIN initializes the normal user's PIN.

Parameters
sessionthe session's handle
pin_ptrthe normal user's PIN
pin_lenlength in bytes of the PIN
return_valuedefault 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().

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

◆ C_InitPIN() [2/2]

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

C_InitPIN initializes the normal user's PIN.

Parameters
sessionthe session's handle
pinthe normal user's PIN
return_valuedefault 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 1200 of file p11.h.

1203  {
1204  return C_InitPIN(session, reinterpret_cast< Utf8Char* >(const_cast< uint8_t* >(pin.data())), pin.size(), return_value);
1205  }
bool C_InitPIN(SessionHandle session, Utf8Char *pin_ptr, Ulong pin_len, ReturnValue *return_value=ThrowException) const
Definition: p11.cpp:214

◆ C_InitToken() [1/2]

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

C_InitToken initializes a token.

Parameters
slot_idID of the token's slot
so_pin_ptrthe SO's initial PIN
so_pin_lenlength in bytes of the SO_PIN
label_ptr32-byte token label (blank padded)
return_valuedefault 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.

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

◆ C_InitToken() [2/2]

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

C_InitToken initializes a token.

Parameters
slot_idID of the token's slot
so_pinthe SO's initial PIN
labeltoken label (at max 32 bytes long)
return_valuedefault 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.

1152  {
1153  std::string padded_label = label;
1154  if(label.size() < 32)
1155  {
1156  padded_label.insert(padded_label.end(), 32 - label.size(), ' ');
1157  }
1158 
1159  return C_InitToken(slot_id, reinterpret_cast< Utf8Char* >(const_cast< uint8_t* >(so_pin.data())),
1160  so_pin.size(), reinterpret_cast< Utf8Char* >(const_cast< char* >(padded_label.c_str())), return_value);
1161  }
CK_UTF8CHAR Utf8Char
Definition: p11.h:841
bool C_InitToken(SlotId slot_id, Utf8Char *so_pin_ptr, Ulong so_pin_len, Utf8Char *label_ptr, ReturnValue *return_value=ThrowException) const
Definition: p11.cpp:205

◆ C_Login() [1/2]

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

C_Login logs a user into a token.

Parameters
sessionthe session's handle
user_typethe user type
pin_ptrthe user's PIN
pin_lenthe length of the PIN
return_valuedefault 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().

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

◆ C_Login() [2/2]

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

C_Login logs a user into a token.

Parameters
sessionthe session's handle
user_typethe user type
pinthe user or security officer's PIN
return_valuedefault 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 1421 of file p11.h.

1425  {
1426  return C_Login(session, user_type, reinterpret_cast< Utf8Char* >(const_cast< uint8_t* >(pin.data())), pin.size(),
1427  return_value);
1428  }
bool C_Login(SessionHandle session, UserType user_type, Utf8Char *pin_ptr, Ulong pin_len, ReturnValue *return_value=ThrowException) const
Definition: p11.cpp:285

◆ C_Logout()

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

C_Logout logs a user out from a token.

Parameters
sessionthe session's handle
return_valuedefault 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().

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

◆ C_OpenSession()

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

C_OpenSession opens a session between an application and a token.

Parameters
slot_idthe slot's ID
flagsfrom CK_SESSION_INFO
applicationpassed to callback
notifycallback function
session_ptrgets session handle
return_valuedefault 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.

References Botan::PKCS11::flags().

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

241  {
242  return handle_return_value(m_func_list_ptr->C_OpenSession(slot_id, flags, application, notify, session_ptr),
243  return_value);
244  }
Flags flags(Flag flags)
Definition: p11.h:858

◆ C_SeedRandom()

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
sessionthe session's handle
seed_ptrthe seed material
seed_lenlength of seed material
return_valuedefault 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().

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

◆ C_SetAttributeValue() [1/2]

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

C_SetAttributeValue modifies the value of one or more object attributes.

Parameters
sessionthe session's handle
objectthe object's handle
attribute_template_ptrspecifies attrs and values
countattributes in template
return_valuedefault 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().

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

◆ C_SetAttributeValue() [2/2]

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

C_SetAttributeValue modifies the value of one or more object attributes.

Parameters
sessionthe session's handle
objectthe object's handle
attribute_valuesspecifies attrs and values
return_valuedefault 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 1649 of file p11.h.

1653  {
1654  std::vector<Attribute> setter_template;
1655 
1656  for(auto& entry : attribute_values)
1657  {
1658  setter_template.emplace_back(Attribute{ static_cast< CK_ATTRIBUTE_TYPE >(entry.first), entry.second.data(), static_cast<CK_ULONG>(entry.second.size()) });
1659  }
1660 
1661  return C_SetAttributeValue(session, object, const_cast< Attribute* >(setter_template.data()), setter_template.size(),
1662  return_value);
1663  }
unsigned long int CK_ULONG
Definition: pkcs11t.h:48
CK_ULONG CK_ATTRIBUTE_TYPE
Definition: pkcs11t.h:416
CK_ATTRIBUTE Attribute
Definition: p11.h:845
bool C_SetAttributeValue(SessionHandle session, ObjectHandle object, Attribute *attribute_template_ptr, Ulong count, ReturnValue *return_value=ThrowException) const
Definition: p11.cpp:349

◆ C_SetOperationState()

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

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

Parameters
sessionsession's handle
operation_state_ptrholds state
operation_state_lenholds state length
encryption_keyen/decryption key
authentication_keysign/verify key
return_valuedefault 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.

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

◆ C_SetPIN() [1/2]

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

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

Parameters
sessionthe session's handle
old_pin_ptrthe old PIN
old_lenlength of the old PIN
new_pin_ptrthe new PIN
new_lenlength of the new PIN
return_valuedefault 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().

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

◆ C_SetPIN() [2/2]

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

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

Parameters
sessionthe session's handle
old_pinthe old PIN
new_pinthe new PIN
return_valuedefault 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 1249 of file p11.h.

1253  {
1254  return C_SetPIN(session,
1255  reinterpret_cast< Utf8Char* >(const_cast< uint8_t* >(old_pin.data())), old_pin.size(),
1256  reinterpret_cast< Utf8Char* >(const_cast< uint8_t* >(new_pin.data())), new_pin.size(),
1257  return_value);
1258  }
CK_UTF8CHAR Utf8Char
Definition: p11.h:841
bool C_SetPIN(SessionHandle session, Utf8Char *old_pin_ptr, Ulong old_len, Utf8Char *new_pin_ptr, Ulong new_len, ReturnValue *return_value=ThrowException) const
Definition: p11.cpp:222

◆ C_Sign() [1/2]

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
sessionthe session's handle
data_ptrthe data to sign
data_lencount of bytes to sign
signature_ptrgets the signature
signature_len_ptrgets signature length
return_valuedefault 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.

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

◆ C_Sign() [2/2]

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

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

Parameters
sessionthe session's handle
datathe data to sign
signaturegets the signature
return_valuedefault 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 2146 of file p11.h.

2150  {
2151  Ulong signature_size = 0;
2152  if(!C_Sign(session, const_cast<Byte*>((data.data())), data.size(), nullptr, &signature_size, return_value))
2153  {
2154  return false;
2155  }
2156 
2157  signature.resize(signature_size);
2158  return C_Sign(session, const_cast<Byte*>(data.data()), data.size(), signature.data(), &signature_size, return_value);
2159  }
CK_ULONG Ulong
Definition: p11.h:836
bool C_Sign(SessionHandle session, Byte *data_ptr, Ulong data_len, Byte *signature_ptr, Ulong *signature_len_ptr, ReturnValue *return_value=ThrowException) const
Definition: p11.cpp:517

◆ C_SignEncryptUpdate()

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

C_SignEncryptUpdate continues a multiple-part signing and encryption operation.

Parameters
sessionsession's handle
part_ptrthe plaintext data
part_lenplaintext length
encrypted_part_ptrgets ciphertext
encrypted_part_len_ptrgets c-text length
return_valuedefault 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.

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

◆ C_SignFinal() [1/2]

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

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

Parameters
sessionthe session's handle
signature_ptrgets the signature
signature_len_ptrgets signature length
return_valuedefault 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.

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

◆ C_SignFinal() [2/2]

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

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

Parameters
sessionthe session's handle
signaturegets the signature
return_valuedefault 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 2240 of file p11.h.

2243  {
2244  Ulong signature_size = 0;
2245  if(!C_SignFinal(session, nullptr, &signature_size, return_value))
2246  {
2247  return false;
2248  }
2249 
2250  signature.resize(signature_size);
2251  return C_SignFinal(session, signature.data(), &signature_size, return_value);
2252  }
CK_ULONG Ulong
Definition: p11.h:836
bool C_SignFinal(SessionHandle session, Byte *signature_ptr, Ulong *signature_len_ptr, ReturnValue *return_value=ThrowException) const
Definition: p11.cpp:536

◆ C_SignInit()

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

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

Parameters
sessionthe session's handle
mechanism_ptrthe signature mechanism
keyhandle of signature key
return_valuedefault 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.

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

◆ C_SignRecover()

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

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

Parameters
sessionthe session's handle
data_ptrthe data to sign
data_lencount of bytes to sign
signature_ptrgets the signature
signature_len_ptrgets signature length
return_valuedefault 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.

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

◆ C_SignRecoverInit()

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

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

Parameters
sessionthe session's handle
mechanism_ptrthe signature mechanism
keyhandle of the signature key
return_valuedefault 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.

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

◆ C_SignUpdate() [1/2]

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
sessionthe session's handle
part_ptrthe data to sign
part_lencount of bytes to sign
return_valuedefault 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.

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

◆ C_SignUpdate() [2/2]

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

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

Parameters
sessionthe session's handle
partthe data to sign
return_valuedefault 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 2196 of file p11.h.

2199  {
2200  return C_SignUpdate(session, const_cast<Byte*>(part.data()), part.size(), return_value);
2201  }
bool C_SignUpdate(SessionHandle session, Byte *part_ptr, Ulong part_len, ReturnValue *return_value=ThrowException) const
Definition: p11.cpp:528

◆ C_UnwrapKey()

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

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

Parameters
sessionsession's handle
mechanism_ptrunwrapping mech.
unwrapping_keyunwrapping key
wrapped_key_ptrthe wrapped key
wrapped_key_lenwrapped key len
attribute_template_ptrnew key template
attribute_counttemplate length
key_ptrgets new handle
return_valuedefault 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.

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

◆ C_Verify() [1/2]

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
sessionthe session's handle
data_ptrsigned data
data_lenlength of signed data
signature_ptrsignature
signature_lensignature length
return_valuedefault 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.

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

◆ C_Verify() [2/2]

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

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

Parameters
sessionthe session's handle
datasigned data
signaturesignature
return_valuedefault 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 2367 of file p11.h.

2371  {
2372  return C_Verify(session, const_cast<Byte*>(data.data()), data.size(), signature.data(), signature.size(), return_value);
2373  }
bool C_Verify(SessionHandle session, Byte *data_ptr, Ulong data_len, Byte *signature_ptr, Ulong signature_len, ReturnValue *return_value=ThrowException) const
Definition: p11.cpp:573

◆ C_VerifyFinal()

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
sessionthe session's handle
signature_ptrsignature to verify
signature_lensignature length
return_valuedefault 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.

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

◆ C_VerifyInit()

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

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

Parameters
sessionthe session's handle
mechanism_ptrthe verification mechanism
keyverification key
return_valuedefault 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.

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

◆ C_VerifyRecover()

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

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

Parameters
sessionthe session's handle
signature_ptrsignature to verify
signature_lensignature length
data_ptrgets signed data
data_len_ptrgets signed data len
return_valuedefault 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.

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

◆ C_VerifyRecoverInit()

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

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

Parameters
sessionthe session's handle
mechanism_ptrthe verification mechanism
keyverification key
return_valuedefault 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.

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

◆ C_VerifyUpdate() [1/2]

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
sessionthe session's handle
part_ptrsigned data
part_lenlength of signed data
return_valuedefault 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.

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

◆ C_VerifyUpdate() [2/2]

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

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

Parameters
sessionthe session's handle
partsigned data
return_valuedefault 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 2410 of file p11.h.

2413  {
2414  return C_VerifyUpdate(session, part.data(), part.size(), return_value);
2415  }
bool C_VerifyUpdate(SessionHandle session, Byte *part_ptr, Ulong part_len, ReturnValue *return_value=ThrowException) const
Definition: p11.cpp:584

◆ C_WaitForSlotEvent()

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

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

Parameters
flagsblocking/nonblocking flag
slot_ptrlocation that receives the slot ID
reservedreserved. Should be NULL_PTR
return_valuedefault 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.

References Botan::PKCS11::flags().

161  {
162  return handle_return_value(m_func_list_ptr->C_WaitForSlotEvent(flags, slot_ptr, reserved), return_value);
163  }
Flags flags(Flag flags)
Definition: p11.h:858

◆ C_WrapKey()

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

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

Parameters
sessionthe session's handle
mechanism_ptrthe wrapping mechanism
wrapping_keywrapping key
keykey to be wrapped
wrapped_key_ptrgets wrapped key
wrapped_key_len_ptrgets wrapped key size
return_valuedefault 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.

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

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