Botan 2.1.0 Crypto and TLS for C++11

- Main Page
- Namespaces
- Classes
- Files

- Class List
- Class Index
- Class Hierarchy
- Class Members

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

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

Parameters

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

Definition at line 73 of file p11.cpp.

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

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

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

Parameters

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

Returns
  true on success, false otherwise

Definition at line 758 of file p11.cpp.

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

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

C_CloseAllSessions closes all sessions with a token.

Parameters

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

Returns
  true on success, false otherwise

Definition at line 252 of file p11.cpp.

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

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

C_CloseSession closes a session between an application and a token.

Parameters

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

Returns
  true on success, false otherwise

Definition at line 246 of file p11.cpp.

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

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

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

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

Parameters

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

Returns
  true on success, false otherwise

Definition at line 313 of file p11.cpp.

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

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 }

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

C_CreateObject creates a new object.

Parameters

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

Returns
  true on success, false otherwise

Definition at line 303 of file p11.cpp.

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

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

C_Decrypt decrypts encrypted data in a single part.

Parameters

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

Returns
  true on success, false otherwise

Definition at line 434 of file p11.cpp.

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 }
template<typename TAllocA , typename TAllocB >

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

C_Decrypt decrypts encrypted data in a single part.

Parameters

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

Returns
  true on success, false otherwise

Definition at line 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 }
Botan::PKCS11::Ulong
CK_ULONG Ulong
Definition: p11.h:836
Botan::PKCS11::LowLevel::C_Decrypt
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

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

C_DecryptDigestUpdate continues a multiple-part decryption and digesting operation.

Parameters

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

Returns
  true on success, false otherwise

Definition at line 632 of file p11.cpp.

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 }

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

C_DecryptFinal finishes a multiple-part decryption operation.

Parameters

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

Returns
  true on success, false otherwise

Definition at line 456 of file p11.cpp.

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

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

C_DecryptInit initializes a decryption operation.

Parameters

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

Returns
  true on success, false otherwise

Definition at line 426 of file p11.cpp.

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

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

C_DecryptUpdate continues a multiple-part decryption operation.

Parameters

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

Returns
  true on success, false otherwise

Definition at line 445 of file p11.cpp.

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 }

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

C_DecryptVerifyUpdate continues a multiple-part decryption and verify operation.

Parameters

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

Returns
  true on success, false otherwise

Definition at line 654 of file p11.cpp.

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 }

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

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

Parameters

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

Returns
  true on success, false otherwise

Definition at line 720 of file p11.cpp.

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 }

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

C_DestroyObject destroys an object.

Parameters

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

Returns
  true on success, false otherwise

Definition at line 324 of file p11.cpp.

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

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

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

C_Digest digests data in a single part.

Parameters

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

Returns
  true on success, false otherwise

Definition at line 473 of file p11.cpp.

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 }

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

C_DigestEncryptUpdate continues a multiple-part digesting and encryption operation.

Parameters

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

Returns
  true on success, false otherwise

Definition at line 621 of file p11.cpp.

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 }

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

C_DigestFinal finishes a multiple-part message-digesting operation.

Parameters

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

Returns
  true on success, false otherwise

Definition at line 499 of file p11.cpp.

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

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

C_DigestInit initializes a message-digesting operation.

Parameters

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

Returns
  true on success, false otherwise

Definition at line 466 of file p11.cpp.

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

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

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

Parameters

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

Returns
  true on success, false otherwise

Definition at line 492 of file p11.cpp.

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

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

C_DigestUpdate continues a multiple-part message-digesting operation.

Parameters

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

Returns
  true on success, false otherwise

Definition at line 484 of file p11.cpp.

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

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

C_Encrypt encrypts single-part data.

Parameters

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

Returns
  true on success, false otherwise

Definition at line 393 of file p11.cpp.

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 }
template<typename TAllocA , typename TAllocB >

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

C_Encrypt encrypts single-part data.

Parameters

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

Returns
  true on success, false otherwise

Definition at line 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 }
Botan::PKCS11::Ulong
CK_ULONG Ulong
Definition: p11.h:836
Botan::PKCS11::LowLevel::C_Encrypt
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

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

C_EncryptFinal finishes a multiple-part encryption operation.

Parameters

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

Returns
  true on success, false otherwise

Definition at line 415 of file p11.cpp.

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 }

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

C_EncryptInit initializes an encryption operation.

Parameters

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

Returns
  true on success, false otherwise

Definition at line 385 of file p11.cpp.

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

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

C_EncryptUpdate continues a multiple-part encryption operation.

Parameters

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

Returns
  true on success, false otherwise

Definition at line 404 of file p11.cpp.

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 }

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

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

Parameters

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

Returns
  true on success, false otherwise

Definition at line 90 of file p11.cpp.

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

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

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

Parameters

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

Returns
  true on success, false otherwise

Definition at line 367 of file p11.cpp.

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

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 }

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

C_FindObjectsFinal finishes a search for token and session objects.

Parameters

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

Returns
  true on success, false otherwise

Definition at line 377 of file p11.cpp.

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

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

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

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

Parameters

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

Returns
  true on success, false otherwise

Definition at line 359 of file p11.cpp.

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

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

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

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

Parameters

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

Returns
  true on success, false otherwise

Definition at line 667 of file p11.cpp.

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 }

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

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

Parameters

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

Returns
  true on success, false otherwise

Definition at line 678 of file p11.cpp.

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 }

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

C_GenerateRandom generates random data.

Parameters

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

Returns
  true on success, false otherwise

Definition at line 742 of file p11.cpp.

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

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

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

C_GetAttributeValue obtains the value of one or more object attributes.

Parameters

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

Returns
  true on success, false otherwise

Definition at line 339 of file p11.cpp.

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

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

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

C_GetAttributeValue obtains the value of one or more object attributes.

Parameters

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

Returns
  true on success, false otherwise

Definition at line 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 }
CK_ATTRIBUTE_TYPE
CK_ULONG CK_ATTRIBUTE_TYPE
Definition: pkcs11t.h:416
Botan::PKCS11::LowLevel::C_GetAttributeValue
bool C_GetAttributeValue(SessionHandle session, ObjectHandle object, Attribute *attribute_template_ptr, Ulong count, ReturnValue *return_value=ThrowException) const
Definition: p11.cpp:339
Botan::PKCS11::Attribute
CK_ATTRIBUTE Attribute
Definition: p11.h:845

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

C_GetFunctionList returns the function list.

Parameters

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

Returns
  true on success, false otherwise

Definition at line 102 of file p11.cpp.

References Botan::Dynamically_Loaded_Library::resolve().

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

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 }
Botan::PKCS11::FunctionListPtr
CK_FUNCTION_LIST_PTR FunctionListPtr
Definition: p11.h:825
CK_RV
CK_ULONG CK_RV
Definition: pkcs11t.h:1036

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

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

Parameters

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

Returns
  true on success, false otherwise

Definition at line 752 of file p11.cpp.

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

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

C_GetInfo returns general information about Cryptoki.

Parameters

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

Returns
  true on success, false otherwise

Definition at line 96 of file p11.cpp.

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

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

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

Parameters

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

Returns
  true on success, false otherwise

Definition at line 196 of file p11.cpp.

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 }
type
MechanismType type
Definition: p11_mechanism.cpp:43

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

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

Parameters

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

Returns
  true on success, false otherwise

Definition at line 165 of file p11.cpp.

Referenced by C_GetMechanismList().

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 }

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

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

Parameters

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

Returns
  true on success, false otherwise

Definition at line 174 of file p11.cpp.

References C_GetMechanismList().

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 }
Botan::PKCS11::LowLevel::C_GetMechanismList
bool C_GetMechanismList(SlotId slot_id, MechanismType *mechanism_list_ptr, Ulong *count_ptr, ReturnValue *return_value=ThrowException) const
Definition: p11.cpp:165
Botan::PKCS11::Ulong
CK_ULONG Ulong
Definition: p11.h:836

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

C_GetObjectSize gets the size of an object in bytes.

Parameters

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

Returns
  true on success, false otherwise

Definition at line 331 of file p11.cpp.

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

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

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

Parameters

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

Returns
  true on success, false otherwise

Definition at line 265 of file p11.cpp.

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

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

C_GetSessionInfo obtains information about the session.

Parameters

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

Returns
  true on success, false otherwise

Definition at line 258 of file p11.cpp.

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

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

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

C_GetSlotInfo obtains information about a particular slot in the system.

Parameters

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

Returns
  true on success, false otherwise

Definition at line 143 of file p11.cpp.

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

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

C_GetSlotList obtains a list of slots in the system.

Parameters

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

Returns
  true on success, false otherwise

Definition at line 114 of file p11.cpp.

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

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

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

C_GetSlotList obtains a list of slots in the system.

Parameters

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

Returns
  true on success, false otherwise

Definition at line 122 of file p11.cpp.

References C_GetSlotList().

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 }
Botan::PKCS11::LowLevel::C_GetSlotList
bool C_GetSlotList(Bbool token_present, SlotId *slot_list_ptr, Ulong *count_ptr, ReturnValue *return_value=ThrowException) const
Definition: p11.cpp:114
Botan::PKCS11::Ulong
CK_ULONG Ulong
Definition: p11.h:836

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

C_GetTokenInfo obtains information about a particular token in the system.

Parameters

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

Returns
  true on success, false otherwise

Definition at line 150 of file p11.cpp.

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

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

C_Initialize initializes the Cryptoki library.

Parameters

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

Returns
  true on success, false otherwise

Definition at line 84 of file p11.cpp.

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

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

C_InitPIN initializes the normal user's PIN.

Parameters

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

Returns
  true on success, false otherwise

Definition at line 214 of file p11.cpp.

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

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

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

C_InitPIN initializes the normal user's PIN.

Parameters

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

Returns
  true on success, false otherwise

Definition at line 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 }
Botan::PKCS11::LowLevel::C_InitPIN
bool C_InitPIN(SessionHandle session, Utf8Char *pin_ptr, Ulong pin_len, ReturnValue *return_value=ThrowException) const
Definition: p11.cpp:214

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

C_InitToken initializes a token.

Parameters

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

Returns
  true on success, false otherwise

Definition at line 205 of file p11.cpp.

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 }
template<typename TAlloc >

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

C_InitToken initializes a token.

Parameters

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

Returns
  true on success, false otherwise

Definition at line 1148 of file p11.h.

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 }
Botan::PKCS11::Utf8Char
CK_UTF8CHAR Utf8Char
Definition: p11.h:841
Botan::PKCS11::LowLevel::C_InitToken
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

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

C_Login logs a user into a token.

Parameters

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

Returns
  true on success, false otherwise

Definition at line 285 of file p11.cpp.

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

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 }
template<typename TAlloc >

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

C_Login logs a user into a token.

Parameters

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

Returns
  true on success, false otherwise

Definition at line 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 }
Botan::PKCS11::LowLevel::C_Login
bool C_Login(SessionHandle session, UserType user_type, Utf8Char *pin_ptr, Ulong pin_len, ReturnValue *return_value=ThrowException) const
Definition: p11.cpp:285

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

C_Logout logs a user out from a token.

Parameters

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

Returns
  true on success, false otherwise

Definition at line 295 of file p11.cpp.

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

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

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

C_OpenSession opens a session between an application and a token.

Parameters

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

Returns
  true on success, false otherwise

Definition at line 235 of file p11.cpp.

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

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

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

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

Parameters

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

Returns
  true on success, false otherwise

Definition at line 734 of file p11.cpp.

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

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

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

C_SetAttributeValue modifies the value of one or more object attributes.

Parameters

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

Returns
  true on success, false otherwise

Definition at line 349 of file p11.cpp.

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

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

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

C_SetAttributeValue modifies the value of one or more object attributes.

Parameters

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

Returns
  true on success, false otherwise

Definition at line 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 }
CK_ULONG
unsigned long int CK_ULONG
Definition: pkcs11t.h:48
CK_ATTRIBUTE_TYPE
CK_ULONG CK_ATTRIBUTE_TYPE
Definition: pkcs11t.h:416
Botan::PKCS11::LowLevel::C_SetAttributeValue
bool C_SetAttributeValue(SessionHandle session, ObjectHandle object, Attribute *attribute_template_ptr, Ulong count, ReturnValue *return_value=ThrowException) const
Definition: p11.cpp:349
Botan::PKCS11::Attribute
CK_ATTRIBUTE Attribute
Definition: p11.h:845

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

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

Parameters

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

Returns
  true on success, false otherwise

Definition at line 274 of file p11.cpp.

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 }

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

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

Parameters

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

Returns
  true on success, false otherwise

Definition at line 222 of file p11.cpp.

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

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 }
template<typename TAlloc >

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

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

Parameters

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

Returns
  true on success, false otherwise

Definition at line 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 }
Botan::PKCS11::Utf8Char
CK_UTF8CHAR Utf8Char
Definition: p11.h:841
Botan::PKCS11::LowLevel::C_SetPIN
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

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

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

Parameters

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

Returns
  true on success, false otherwise

Definition at line 517 of file p11.cpp.

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 }
template<typename TAllocA , typename TAllocB >

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

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

Parameters

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

Returns
  true on success, false otherwise

Definition at line 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 }
Botan::PKCS11::LowLevel::C_Sign
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
Botan::PKCS11::Ulong
CK_ULONG Ulong
Definition: p11.h:836

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

C_SignEncryptUpdate continues a multiple-part signing and encryption operation.

Parameters

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

Returns
  true on success, false otherwise

Definition at line 643 of file p11.cpp.

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 }

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

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

Parameters

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

Returns
  true on success, false otherwise

Definition at line 536 of file p11.cpp.

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

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

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

Parameters

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

Returns
  true on success, false otherwise

Definition at line 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 }
Botan::PKCS11::Ulong
CK_ULONG Ulong
Definition: p11.h:836
Botan::PKCS11::LowLevel::C_SignFinal
bool C_SignFinal(SessionHandle session, Byte *signature_ptr, Ulong *signature_len_ptr, ReturnValue *return_value=ThrowException) const
Definition: p11.cpp:536

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

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

Parameters

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

Returns
  true on success, false otherwise

Definition at line 509 of file p11.cpp.

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

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

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

Parameters

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

Returns
  true on success, false otherwise

Definition at line 552 of file p11.cpp.

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

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

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

Parameters

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

Returns
  true on success, false otherwise

Definition at line 544 of file p11.cpp.

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

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

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

Parameters

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

Returns
  true on success, false otherwise

Definition at line 528 of file p11.cpp.

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

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

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

Parameters

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

Returns
  true on success, false otherwise

Definition at line 2196 of file p11.h.

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

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

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

Parameters

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

Returns
  true on success, false otherwise

Definition at line 705 of file p11.cpp.

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 }

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

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

Parameters

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

Returns
  true on success, false otherwise

Definition at line 573 of file p11.cpp.

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 }
template<typename TAllocA , typename TAllocB >

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

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

Parameters

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

Returns
  true on success, false otherwise

Definition at line 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 }
Botan::PKCS11::LowLevel::C_Verify
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

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

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

Parameters

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

Returns
  true on success, false otherwise

Definition at line 592 of file p11.cpp.

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

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

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

Parameters

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

Returns
  true on success, false otherwise

Definition at line 565 of file p11.cpp.

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

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

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

Parameters

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

Returns
  true on success, false otherwise

Definition at line 608 of file p11.cpp.

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 }

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

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

Parameters

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

Returns
  true on success, false otherwise

Definition at line 600 of file p11.cpp.

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

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

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

Parameters

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

Returns
  true on success, false otherwise

Definition at line 584 of file p11.cpp.

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

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

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

Parameters

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

Returns
  true on success, false otherwise

Definition at line 2410 of file p11.h.

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

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

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

Parameters

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

Returns
  true on success, false otherwise

Definition at line 157 of file p11.cpp.

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

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

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

Parameters

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

Returns
  true on success, false otherwise

Definition at line 693 of file p11.cpp.

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:

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