yubihsm_pkcs11.c File Reference

#include <sys/types.h>
#include <sys/stat.h>
#include <stdbool.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <cmdline.h>
#include <yubihsm.h>
#include <openssl/rsa.h>
#include "debug_p11.h"
#include "util_pkcs11.h"
#include "yubihsm_pkcs11.h"
#include "../common/insecure_memzero.h"

Include dependency graph for yubihsm_pkcs11.c:

Go to the source code of this file.

Macros
#define	YUBIHSM_PKCS11_MANUFACTURER   "Yubico (www.yubico.com)"
#define	YUBIHSM_PKCS11_LIBDESC   "YubiHSM PKCS#11 Library"
#define	YUBIHSM_PKCS11_MIN_PIN_LEN   12
#define	YUBIHSM_PKCS11_MAX_PIN_LEN   68
#define	UNUSED(x)
#define	GLOBAL_LOCK_OR_RETURN
#define	GLOBAL_UNLOCK_OR_RETURN

Functions
	CK_DEFINE_FUNCTION (CK_RV, C_Initialize)
	CK_DEFINE_FUNCTION (CK_RV, C_Finalize)
	CK_DEFINE_FUNCTION (CK_RV, C_GetInfo)
	if (ppFunctionList==NULL)
	if (g_yh_initialized==false)
	if (!pulCount)
	if (pSlotList==NULL)
	for (ListItem *item=g_ctx.slots.head;item !=NULL;item=item->next)
	if (overflow==true)
	if (slot==NULL)
	memset (pInfo->slotDescription, ' ', 64)
	memcpy ((char *) pInfo->slotDescription, s, l)
	yh_get_connector_address (slot->connector, &s)
	memcpy ((char *) pInfo->slotDescription+l, s, strlen(s))
	memset (pInfo->manufacturerID, ' ', 32)
	if (yh_connector_has_device(slot->connector)==true)
	yh_get_connector_version (slot->connector, &major, &minor, &patch)
	if (yrc !=YHR_SUCCESS)
	memset (pInfo->model, ' ', 16)
	UNUSED (flags)
	UNUSED (pSlot)
	UNUSED (pReserved)
	if (pulCount==NULL)
	if (rv==CKR_BUFFER_TOO_SMALL)
	DBG_INFO ("Found %lu mechanisms", *pulCount)
	if (pInfo==NULL)
	if (get_mechanism_info(slot, type, pInfo)==false)
	UNUSED (slotID)
	UNUSED (pPin)
	UNUSED (ulPinLen)
	UNUSED (pLabel)
	UNUSED (hSession)
	UNUSED (pOldPin)
	UNUSED (ulOldLen)
	UNUSED (pNewPin)
	UNUSED (ulNewLen)
	UNUSED (Notify)
	UNUSED (pApplication)
	if (phSession==NULL)
	if ((flags &CKF_SERIAL_SESSION)==0)
	if (create_session(slot, flags, phSession)==false)
	DBG_INFO ("Allocated session %lu", *phSession)
	CK_DEFINE_FUNCTION (CK_RV, C_CloseSession)
	CK_DEFINE_FUNCTION (CK_RV, C_CloseAllSessions)
	if (ret !=CKR_OK)
	switch (session->session_state)
	UNUSED (pOperationState)
	UNUSED (pulOperationStateLen)
	UNUSED (ulOperationStateLen)
	UNUSED (hEncryptionKey)
	UNUSED (hAuthenticationKey)
	if (userType !=CKU_USER)
	if (ulPinLen< YUBIHSM_PKCS11_MIN_PIN_LEN||ulPinLen > YUBIHSM_PKCS11_MAX_PIN_LEN)
	if (parse_hex(pPin, 4,(uint8_t *) &key_id)==false)
	if (rv !=CKR_OK)
	CK_DEFINE_FUNCTION (CK_RV, C_Logout)
	if (pTemplate==NULL||ulCount==0||phObject==NULL)
	if (session->operation.type !=OPERATION_NOOP)
memset &	template (template)
	for (CK_ULONG i=0;i< ulCount;i++)
	if (class.set==false)
	if (template.exportable==ATTRIBUTE_TRUE)
	if (yh_util_get_object_info(session->slot->device_session, template.id, type, &object) !=YHR_SUCCESS)
	DBG_INFO ("Created object %08lx", *phObject)
	UNUSED (hObject)
	UNUSED (pTemplate)
	UNUSED (ulCount)
	UNUSED (phNewObject)
	if (type==ECDH_KEY_TYPE)
	if (object==NULL)
	if (yh_util_delete_object(session->slot->device_session, object->object.id, object->object.type) !=YHR_SUCCESS)
	DBG_INFO ("Deleted object %08lx", hObject)
	delete_object_from_cache (session->slot->objects, hObject)
	if (pulSize==NULL)
	DBG_INFO ("For object %08lx", hObject)
	if (ulCount !=0 &&pTemplate==NULL)
	if (session->session_state &SESSION_NOT_AUTHENTICATED)
	DBG_INFO ("find with %lu attributes", ulCount)
	if (unknown==false)
	if (phObject==NULL||ulMaxObjectCount==0||pulObjectCount==NULL)
	DBG_INFO ("Can return %lu object(s)", ulMaxObjectCount)
	for (uint16_t i=0;i< ulMaxObjectCount &&session->operation.op.find.current_object< session->operation.op.find.n_objects;session->operation.op.find.current_object++)
	DBG_INFO ("Returning %lu object(s)", *pulObjectCount)
	CK_DEFINE_FUNCTION (CK_RV, C_FindObjectsFinal)
	if (pMechanism==NULL||pMechanism->mechanism !=CKM_YUBICO_AES_CCM_WRAP)
	DBG_INFO ("Trying to encrypt data with mechanism 0x%04lx and key %08lx", pMechanism->mechanism, hKey)
	if (check_encrypt_mechanism(session->slot, pMechanism) !=true)
	if (object->object.type !=YH_WRAP_KEY)
	if (session->operation.mechanism.mechanism !=CKM_YUBICO_AES_CCM_WRAP)
	DBG_INFO ("The size of the data will be %lu", datalen)
	if (pEncryptedData==NULL)
	DBG_INFO ("Encrypting %lu bytes", ulDataLen)
	DBG_INFO ("Got %lu butes back", *pulEncryptedDataLen)
	if (terminate==true)
	if (pPart==NULL)
	DBG_INFO ("Encrypt update with %lu bytes", ulPartLen)
	UNUSED (pEncryptedPart)
	if (session->operation.mechanism.mechanism==CKM_YUBICO_AES_CCM_WRAP)
	if (pLastEncryptedPart==NULL)
	DBG_INFO ("Got %lu bytes back", *pulLastEncryptedPartLen)
	DBG_INFO ("Trying to decrypt data with mechanism 0x%04lx and key %08lx", pMechanism->mechanism, hKey)
	if (check_decrypt_mechanism(session->slot, pMechanism) !=true)
	if (object->object.type==YH_ASYMMETRIC_KEY &&yh_is_rsa(object->object.algorithm))
	if (pData==NULL)
	if (session->operation.op.decrypt.finalized==false)
	DBG_INFO ("Using key %04x", session->operation.op.decrypt.key_id)
	if (pEncryptedPart==NULL)
	DBG_INFO ("Decrypt update with %lu bytes", ulEncryptedPartLen)
	UNUSED (pPart)
	if (pLastPart==NULL)
	DBG_INFO ("Trying to digest data with mechanism 0x%04lx", pMechanism->mechanism)
	if (check_digest_mechanism(pMechanism) !=true)
	if (session->operation.op.digest.is_multipart==true)
	if (pulDigestLen==NULL)
	if (pDigest==NULL)
	DBG_INFO ("Sending %lu bytes to digest", ulDataLen)
	DBG_INFO ("Digest update with %lu bytes", ulPartLen)
	UNUSED (hKey)
	DBG_INFO ("Trying to sign data with mechanism 0x%04lx and key %08lx", pMechanism->mechanism, hKey)
	if (check_sign_mechanism(session->slot, pMechanism) !=true)
	DBG_INFO ("The size of the signature will be %u", session->operation.op.sign.sig_len)
	if (pSignature==NULL)
	DBG_INFO ("Sending %lu bytes to sign", ulDataLen)
	DBG_INFO ("Using key %04x", session->operation.op.sign.key_id)
	DBG_INFO ("After padding and transformation there are %u bytes", session->operation.buffer_length)
	DBG_INFO ("Signature update with %lu bytes", ulPartLen)
	UNUSED (pMechanism)
	UNUSED (pData)
	UNUSED (ulDataLen)
	UNUSED (pSignature)
	UNUSED (pulSignatureLen)
	DBG_INFO ("Trying to verify data with mechanism 0x%04lx and key %lx", pMechanism->mechanism, hKey)
	if (check_verify_mechanism(session->slot, pMechanism) !=true)
	if (yh_is_rsa(object->object.algorithm))
	if (is_HMAC_sign_mechanism(session->operation.mechanism.mechanism)==true)
else	if (is_RSA_sign_mechanism(session->operation.mechanism.mechanism)==true)
else	if (is_ECDSA_sign_mechanism(session->operation.mechanism.mechanism))
	if (ulSignatureLen !=siglen)
	DBG_INFO ("Using key %04x", session->operation.op.verify.key_id)
	DBG_INFO ("Signature successfully verified")
	DBG_ERR ("Verification update with %lu bytes", ulPartLen)
	UNUSED (ulSignatureLen)
	UNUSED (pulDataLen)
	UNUSED (ulPartLen)
	UNUSED (pulEncryptedPartLen)
	UNUSED (ulEncryptedPartLen)
	UNUSED (pulPartLen)
	if (pMechanism->mechanism !=CKM_GENERIC_SECRET_KEY_GEN)
memset &	template (yubihsm_pkcs11_object_template)
	if (key_type.set==false||class.set==false)
	if (pMechanism->mechanism==CKM_RSA_PKCS_KEY_PAIR_GEN)
	if (yh_is_rsa(template.algorithm))
	if (rc !=YHR_SUCCESS)
	if (yh_util_get_object_info(session->slot->device_session, template.id, YH_ASYMMETRIC_KEY, &object) !=YHR_SUCCESS)
c_gkp_out	sizeof (template))
	if (wrapped_key_type==ECDH_KEY_TYPE||wrapping_key_type==ECDH_KEY_TYPE)
	if (pWrappedKey==NULL)
	if (check_wrap_mechanism(session->slot, pMechanism) !=true)
	if (key==NULL)
	if (yh_check_capability(&key->object.capabilities, "export-wrapped")==false)
	if (yh_check_capability(&object->object.capabilities, "exportable-under-wrap")==false)
	if (len > *pulWrappedKeyLen)
	memcpy (pWrappedKey, buf, len)
	UNUSED (ulAttributeCount)
	if (unwrapping_key_type==ECDH_KEY_TYPE)
	if (yh_util_get_object_info(session->slot->device_session, target_id, target_type, &object) !=YHR_SUCCESS)
	DBG_INFO ("Unwrapped object %08lx", *phKey)
	if (basekey_type==ECDH_KEY_TYPE)
	if (params->kdf==CKD_NULL)
	if (in_len !=params->ulPublicDataLen)
	if (seq > MAX_ECDH_SESSION_KEYS)
memset &	ecdh_key (ecdh_key)
	if ((expected_key_length > 0) &&(expected_key_length !=out_len))
	memcpy (ecdh_key.label, label_buf, label_len)
list_append &	session (void *) &ecdh_key
	insecure_memzero (ecdh_key.ecdh_key, out_len)
	DBG_INFO ("Created object %04lx", *phKey)
	UNUSED (pSeed)
	UNUSED (ulSeedLen)
	if (len !=ulRandomLen||pRandomData==NULL)
	CK_DEFINE_FUNCTION (CK_RV, C_CancelFunction)

Variables
CK_FUNCTION_LIST	function_list
CK_FUNCTION_LIST_PTR_PTR	ppFunctionList
	DIN
	DOUT
return	CKR_OK
CK_BBOOL	tokenPresent
CK_BBOOL CK_SLOT_ID_PTR	pSlotList
CK_BBOOL CK_SLOT_ID_PTR CK_ULONG_PTR	pulCount
	GLOBAL_LOCK_OR_RETURN
uint16_t	j = 0
bool	full = false
bool	overflow = false
	GLOBAL_UNLOCK_OR_RETURN
CK_SLOT_ID	slotID = session->slot->id
CK_SLOT_ID CK_SLOT_INFO_PTR	pInfo
yubihsm_pkcs11_slot *	slot = get_slot(&g_ctx, slotID)
char *	s = "YubiHSM Connector "
int	l = strlen(s)
pInfo	flags = CKF_REMOVABLE_DEVICE | CKF_HW_SLOT
uint8_t	major = major
uint8_t	minor = (minor * 100) + patch
uint8_t	patch
CK_RV	rv = CKR_OK
yh_rc	yrc
uint32_t	serial
pInfo	serialNumber [l] = ' '
pInfo	ulMaxSessionCount
pInfo	ulSessionCount
pInfo	ulMaxRwSessionCount
pInfo	ulRwSessionCount
pInfo	ulMaxPinLen
pInfo	ulMinPinLen
pInfo	ulTotalPublicMemory = CK_UNAVAILABLE_INFORMATION
pInfo	ulFreePublicMemory = CK_UNAVAILABLE_INFORMATION
pInfo	ulTotalPrivateMemory = CK_UNAVAILABLE_INFORMATION
pInfo	ulFreePrivateMemory = CK_UNAVAILABLE_INFORMATION
CK_VERSION	ver = {major, (minor * 100) + patch}
pInfo	hardwareVersion = ver
pInfo	firmwareVersion = ver
c_gt_out	__pad0__
CK_FLAGS CK_SLOT_ID_PTR	pSlot
CK_FLAGS CK_SLOT_ID_PTR CK_VOID_PTR	pReserved
return	CKR_FUNCTION_NOT_SUPPORTED
CK_SLOT_ID CK_MECHANISM_TYPE_PTR	pMechanismList
c_gml_out	__pad1__
CK_SLOT_ID CK_MECHANISM_TYPE	type = hObject >> 16
	else
CK_SLOT_ID CK_UTF8CHAR_PTR	pPin = 4
CK_SLOT_ID CK_UTF8CHAR_PTR CK_ULONG	ulPinLen
CK_SLOT_ID CK_UTF8CHAR_PTR CK_ULONG CK_UTF8CHAR_PTR	pLabel
CK_SESSION_HANDLE	hSession
CK_SESSION_HANDLE CK_UTF8CHAR_PTR	pOldPin
CK_SESSION_HANDLE CK_UTF8CHAR_PTR CK_ULONG	ulOldLen
CK_SESSION_HANDLE CK_UTF8CHAR_PTR CK_ULONG CK_UTF8CHAR_PTR	pNewPin
CK_SESSION_HANDLE CK_UTF8CHAR_PTR CK_ULONG CK_UTF8CHAR_PTR CK_ULONG	ulNewLen
CK_SLOT_ID CK_FLAGS CK_VOID_PTR	pApplication
CK_SLOT_ID CK_FLAGS CK_VOID_PTR CK_NOTIFY	Notify
CK_SLOT_ID CK_FLAGS CK_VOID_PTR CK_NOTIFY CK_SESSION_HANDLE_PTR	phSession
c_os_out	__pad2__
yubihsm_pkcs11_session *	session = NULL
CK_RV	ret = get_session(&g_ctx, hSession, &session, 0)
pInfo	ulDeviceError = 0
CK_SESSION_HANDLE CK_BYTE_PTR	pOperationState
CK_SESSION_HANDLE CK_BYTE_PTR CK_ULONG_PTR	pulOperationStateLen
CK_SESSION_HANDLE CK_BYTE_PTR CK_ULONG	ulOperationStateLen
CK_SESSION_HANDLE CK_BYTE_PTR CK_ULONG CK_OBJECT_HANDLE	hEncryptionKey
CK_SESSION_HANDLE CK_BYTE_PTR CK_ULONG CK_OBJECT_HANDLE CK_OBJECT_HANDLE	hAuthenticationKey
CK_SESSION_HANDLE CK_USER_TYPE	userType
uint16_t	key_id = ntohs(key_id)
c_l_out	__pad3__
CK_SESSION_HANDLE CK_ATTRIBUTE_PTR	pTemplate
CK_SESSION_HANDLE CK_ATTRIBUTE_PTR CK_ULONG	ulCount
CK_SESSION_HANDLE CK_ATTRIBUTE_PTR CK_ULONG CK_OBJECT_HANDLE_PTR	phObject
struct {
bool   set
CK_ULONG   d
}	class
struct {
bool   set
CK_ULONG   d
}	key_type
struct {
bool   set
CK_ULONG   d
}	id = id.d
yubihsm_pkcs11_object_template	template
yh_capabilities	capabilities = {{0}}
yh_capabilities	delegated_capabilities = {{0}}
yh_rc	rc
goto	c_co_out
yh_object_descriptor	object
c_co_out	__pad4__
CK_SESSION_HANDLE CK_OBJECT_HANDLE	hObject
CK_SESSION_HANDLE CK_OBJECT_HANDLE CK_ATTRIBUTE_PTR CK_ULONG CK_OBJECT_HANDLE_PTR	phNewObject
c_do_out	__pad5__
CK_SESSION_HANDLE CK_OBJECT_HANDLE CK_ULONG_PTR	pulSize
c_gav_out	__pad6__
c_sav_out	__pad7__
char *	label = NULL
session operation op find	only_private = false
session operation op find	n_objects = 0
uint16_t	domains = 0
bool	pub = false
yh_algorithm	algorithm = 0
bool	unknown = false
bool	secret_key = false
bool	extractable_set = false
session operation op find	current_object = 0
c_foi_out	__pad8__
CK_SESSION_HANDLE CK_OBJECT_HANDLE_PTR CK_ULONG	ulMaxObjectCount
CK_SESSION_HANDLE CK_OBJECT_HANDLE_PTR CK_ULONG CK_ULONG_PTR	pulObjectCount
c_fo_out	__pad9__
CK_SESSION_HANDLE CK_MECHANISM_PTR	pMechanism
CK_SESSION_HANDLE CK_MECHANISM_PTR CK_OBJECT_HANDLE	hKey
session operation mechanism	mechanism = pMechanism->mechanism
session operation	buffer_length = 0
c_ei_out	__pad10__
CK_SESSION_HANDLE CK_BYTE_PTR	pData
CK_SESSION_HANDLE CK_BYTE_PTR CK_ULONG	ulDataLen
CK_SESSION_HANDLE CK_BYTE_PTR CK_ULONG CK_BYTE_PTR	pEncryptedData
CK_SESSION_HANDLE CK_BYTE_PTR CK_ULONG CK_BYTE_PTR CK_ULONG_PTR	pulEncryptedDataLen
bool	terminate = true
CK_ULONG	datalen = YH_CCM_WRAP_OVERHEAD + ulDataLen
goto	c_e_out
c_e_out	__pad11__
CK_SESSION_HANDLE CK_BYTE_PTR	pPart
CK_SESSION_HANDLE CK_BYTE_PTR CK_ULONG	ulPartLen
CK_SESSION_HANDLE CK_BYTE_PTR CK_ULONG CK_BYTE_PTR	pEncryptedPart
CK_SESSION_HANDLE CK_BYTE_PTR CK_ULONG CK_BYTE_PTR CK_ULONG_PTR	pulEncryptedPartLen
c_eu_out	__pad12__
CK_SESSION_HANDLE CK_BYTE_PTR	pLastEncryptedPart
CK_SESSION_HANDLE CK_BYTE_PTR CK_ULONG_PTR	pulLastEncryptedPartLen
goto	c_ef_out
c_ef_out	__pad13__
EVP_MD_CTX *	mdctx = NULL
goto	c_di_out
c_di_out	__pad14__
CK_SESSION_HANDLE CK_BYTE_PTR CK_ULONG	ulEncryptedDataLen
CK_SESSION_HANDLE CK_BYTE_PTR CK_ULONG CK_BYTE_PTR CK_ULONG_PTR	pulDataLen
goto	c_d_out
c_d_out	__pad15__
CK_SESSION_HANDLE CK_BYTE_PTR CK_ULONG	ulEncryptedPartLen
CK_SESSION_HANDLE CK_BYTE_PTR CK_ULONG CK_BYTE_PTR CK_ULONG_PTR	pulPartLen
c_du_out	__pad16__
CK_SESSION_HANDLE CK_BYTE_PTR	pLastPart
CK_SESSION_HANDLE CK_BYTE_PTR CK_ULONG_PTR	pulLastPartLen
goto	c_df_out
c_df_out	__pad17__
CK_ULONG	digest_length = get_digest_bytelength(pMechanism->mechanism)
session operation op digest	digest_len = digest_length
c_di_out	__pad18__
CK_SESSION_HANDLE CK_BYTE_PTR CK_ULONG CK_BYTE_PTR	pDigest
CK_SESSION_HANDLE CK_BYTE_PTR CK_ULONG CK_BYTE_PTR CK_ULONG_PTR	pulDigestLen
c_d_out	__pad19__
session operation op digest	is_multipart = true
c_du_out	__pad20__
c_df_out	__pad21__
size_t	key_length
session operation op sign	key_len = key_length
goto	c_si_out
c_si_out	__pad22__
CK_SESSION_HANDLE CK_BYTE_PTR CK_ULONG CK_BYTE_PTR	pSignature
CK_SESSION_HANDLE CK_BYTE_PTR CK_ULONG CK_BYTE_PTR CK_ULONG_PTR	pulSignatureLen
goto	c_s_out
c_s_out	__pad23__
c_su_out	__pad24__
c_sf_out	__pad25__
goto	c_vi_out
c_vi_out	__pad26__
CK_SESSION_HANDLE CK_BYTE_PTR CK_ULONG CK_BYTE_PTR CK_ULONG	ulSignatureLen
CK_ULONG	siglen
goto	c_v_out
c_v_out	__pad27__
c_vu_out	__pad28__
c_vf_out	__pad29__
CK_SESSION_HANDLE CK_MECHANISM_PTR CK_ATTRIBUTE_PTR CK_ULONG CK_OBJECT_HANDLE_PTR	phKey
goto	c_gk_out
c_gk_out	__pad30__
CK_SESSION_HANDLE CK_MECHANISM_PTR CK_ATTRIBUTE_PTR	pPublicKeyTemplate
CK_SESSION_HANDLE CK_MECHANISM_PTR CK_ATTRIBUTE_PTR CK_ULONG	ulPublicKeyAttributeCount
CK_SESSION_HANDLE CK_MECHANISM_PTR CK_ATTRIBUTE_PTR CK_ULONG CK_ATTRIBUTE_PTR	pPrivateKeyTemplate
CK_SESSION_HANDLE CK_MECHANISM_PTR CK_ATTRIBUTE_PTR CK_ULONG CK_ATTRIBUTE_PTR CK_ULONG	ulPrivateKeyAttributeCount
CK_SESSION_HANDLE CK_MECHANISM_PTR CK_ATTRIBUTE_PTR CK_ULONG CK_ATTRIBUTE_PTR CK_ULONG CK_OBJECT_HANDLE_PTR	phPublicKey = object.sequence << 24 | (object.type | 0x80) << 16 | object.id
CK_SESSION_HANDLE CK_MECHANISM_PTR CK_ATTRIBUTE_PTR CK_ULONG CK_ATTRIBUTE_PTR CK_ULONG CK_OBJECT_HANDLE_PTR CK_OBJECT_HANDLE_PTR	phPrivateKey
goto	c_gkp_out
c_gkp_out	__pad31__
CK_SESSION_HANDLE CK_MECHANISM_PTR CK_OBJECT_HANDLE	hWrappingKey
CK_SESSION_HANDLE CK_MECHANISM_PTR CK_OBJECT_HANDLE CK_OBJECT_HANDLE CK_BYTE_PTR	pWrappedKey
CK_SESSION_HANDLE CK_MECHANISM_PTR CK_OBJECT_HANDLE CK_OBJECT_HANDLE CK_BYTE_PTR CK_ULONG_PTR	pulWrappedKeyLen
int	wrapped_key_type = hKey >> 16
int	wrapping_key_type = hWrappingKey >> 16
yubihsm_pkcs11_object_desc *	key
uint8_t	buf [2048]
size_t	len = sizeof(buf)
c_wk_out	__pad32__
CK_SESSION_HANDLE CK_MECHANISM_PTR CK_OBJECT_HANDLE	hUnwrappingKey
CK_SESSION_HANDLE CK_MECHANISM_PTR CK_OBJECT_HANDLE CK_BYTE_PTR CK_ULONG	ulWrappedKeyLen
CK_SESSION_HANDLE CK_MECHANISM_PTR CK_OBJECT_HANDLE CK_BYTE_PTR CK_ULONG CK_ATTRIBUTE_PTR CK_ULONG	ulAttributeCount
int	unwrapping_key_type = hUnwrappingKey >> 16
uint16_t	target_id
yh_object_type	target_type
c_uk_out	__pad33__
CK_SESSION_HANDLE CK_MECHANISM_PTR CK_OBJECT_HANDLE	hBaseKey
int	basekey_type = hBaseKey >> 16
char *	label_buf = NULL
size_t	label_len = 0
size_t	expected_key_length = 0
CK_ECDH1_DERIVE_PARAMS *	params = pMechanism->pParameter
goto	c_drv_out
size_t	in_len = params->ulPublicDataLen
CK_BYTE_PTR	pubkey = params->pPublicData
int	seq = session->ecdh_session_keys.length + 1
uint16_t	privkey_id = hBaseKey & 0xffff
ecdh_session_key	ecdh_key
size_t	out_len = sizeof(ecdh_key.ecdh_key)
c_drv_out	__pad34__
CK_SESSION_HANDLE CK_BYTE_PTR	pSeed
CK_SESSION_HANDLE CK_BYTE_PTR CK_ULONG	ulSeedLen
return	CKR_RANDOM_SEED_NOT_SUPPORTED
CK_SESSION_HANDLE CK_BYTE_PTR	pRandomData
CK_SESSION_HANDLE CK_BYTE_PTR CK_ULONG	ulRandomLen
c_gr_out	__pad35__
return	CKR_FUNCTION_NOT_PARALLEL

Macro Definition Documentation

GLOBAL_LOCK_OR_RETURN

#define GLOBAL_LOCK_OR_RETURN

Value:

  do {                                                                         \
    if (g_ctx.mutex != NULL) {                                                 \
      CK_RV lock_rv = g_ctx.lock_mutex(g_ctx.mutex);                           \
      if (lock_rv != CKR_OK) {                                                 \
        DBG_ERR("Unable to acquire global lock");                              \
        return lock_rv;                                                        \
      }                                                                        \
    }                                                                          \
  } while (0)

Definition at line 48 of file yubihsm_pkcs11.c.

#define GLOBAL_LOCK_OR_RETURN                                                  \
  do {                                                                         \
    if (g_ctx.mutex != NULL) {                                                 \
      CK_RV lock_rv = g_ctx.lock_mutex(g_ctx.mutex);                           \
      if (lock_rv != CKR_OK) {                                                 \
        DBG_ERR("Unable to acquire global lock");                              \
        return lock_rv;                                                        \
      }                                                                        \
    }                                                                          \
  } while (0)

GLOBAL_UNLOCK_OR_RETURN

#define GLOBAL_UNLOCK_OR_RETURN

Value:

  do {                                                                         \
    if (g_ctx.mutex != NULL) {                                                 \
      CK_RV lock_rv = g_ctx.unlock_mutex(g_ctx.mutex);                         \
      if (lock_rv != CKR_OK) {                                                 \
        DBG_ERR("Unable to release global lock");                              \
        return lock_rv;                                                        \
      }                                                                        \
    }                                                                          \
  } while (0)

Definition at line 59 of file yubihsm_pkcs11.c.

#define GLOBAL_UNLOCK_OR_RETURN                                                \
  do {                                                                         \
    if (g_ctx.mutex != NULL) {                                                 \
      CK_RV lock_rv = g_ctx.unlock_mutex(g_ctx.mutex);                         \
      if (lock_rv != CKR_OK) {                                                 \
        DBG_ERR("Unable to release global lock");                              \
        return lock_rv;                                                        \
      }                                                                        \
    }                                                                          \
  } while (0)

UNUSED

#define UNUSED

(

x

)

Value:

(void) (x)

Definition at line 46 of file yubihsm_pkcs11.c.

YUBIHSM_PKCS11_LIBDESC

#define YUBIHSM_PKCS11_LIBDESC   "YubiHSM PKCS#11 Library"

Definition at line 42 of file yubihsm_pkcs11.c.

YUBIHSM_PKCS11_MANUFACTURER

#define YUBIHSM_PKCS11_MANUFACTURER   "Yubico (www.yubico.com)"

Definition at line 41 of file yubihsm_pkcs11.c.

YUBIHSM_PKCS11_MAX_PIN_LEN

#define YUBIHSM_PKCS11_MAX_PIN_LEN   68

Definition at line 44 of file yubihsm_pkcs11.c.

YUBIHSM_PKCS11_MIN_PIN_LEN

#define YUBIHSM_PKCS11_MIN_PIN_LEN   12

Definition at line 43 of file yubihsm_pkcs11.c.

Function Documentation

CK_DEFINE_FUNCTION() [1/8]

CK_DEFINE_FUNCTION	(	CK_RV	,
		C_CancelFunction	)

Definition at line 5114 of file yubihsm_pkcs11.c.

                                                                        {
 
  DIN;
 
  UNUSED(hSession);
 
  DOUT;
  return CKR_FUNCTION_NOT_PARALLEL;
}

CK_DEFINE_FUNCTION() [2/8]

CK_DEFINE_FUNCTION	(	CK_RV	,
		C_CloseAllSessions	)

Definition at line 916 of file yubihsm_pkcs11.c.

                                                                 {
 
  DIN;
 
  CK_RV rv = CKR_OK;
 
  if (g_yh_initialized == false) {
    DBG_ERR("libyubihsm is not initialized or already finalized");
    return CKR_CRYPTOKI_NOT_INITIALIZED;
  }
 
  yubihsm_pkcs11_slot *slot = get_slot(&g_ctx, slotID);
  if (slot == NULL) {
    DBG_ERR("Invalid slot");
    return CKR_SLOT_ID_INVALID;
  }
 
  DBG_INFO("Closing all sessions for slot %lu", slotID);
 
  if (slot->device_session) {
    if (yh_util_close_session(slot->device_session) != YHR_SUCCESS) {
      DBG_ERR("Failed closing device session, continuing");
    }
    if (yh_destroy_session(&slot->device_session) != YHR_SUCCESS) {
      // TODO: handle or ignore these errrors?
      DBG_ERR("Failed destroying device session");
    }
    slot->device_session = NULL;
  }
 
  list_destroy(&slot->pkcs11_sessions);
  list_create(&slot->pkcs11_sessions, sizeof(yubihsm_pkcs11_session), NULL);
 
  release_slot(&g_ctx, slot);
 
  DOUT;
  return rv;
}

Here is the call graph for this function:

CK_DEFINE_FUNCTION() [3/8]

CK_DEFINE_FUNCTION	(	CK_RV	,
		C_CloseSession	)

Definition at line 868 of file yubihsm_pkcs11.c.

                                                                      {
 
  DIN;
 
  if (g_yh_initialized == false) {
    DBG_ERR("libyubihsm is not initialized or already finalized");
    return CKR_CRYPTOKI_NOT_INITIALIZED;
  }
 
  yubihsm_pkcs11_session *session;
  CK_RV rv = get_session(&g_ctx, hSession, &session, SESSION_AUTHENTICATED);
  if (rv == CKR_OK) {
    if (session->slot->pkcs11_sessions.length == 1) {
      // NOTE: if this is the last session and is authenticated we need to
      // de-auth
      if (yh_util_close_session(session->slot->device_session) != YHR_SUCCESS) {
        DBG_ERR("Failed closing device session, continuing");
      }
 
      if (yh_destroy_session(&session->slot->device_session) != YHR_SUCCESS) {
        DBG_ERR("Failed destroying session");
        // TODO: should we handle the error cases here better?
      }
      session->slot->device_session = NULL;
    }
 
    release_session(&g_ctx, session);
  } else if (rv == CKR_SESSION_HANDLE_INVALID) {
    // BUG(thorduri): piggybacking off of the validation in get_session()
    // above, which might not hold forever.
    DBG_ERR("Trying to close invalid session");
    return CKR_SESSION_HANDLE_INVALID;
  }
 
  if (session) {
    list_destroy(&session->ecdh_session_keys);
  }
  if (delete_session(&g_ctx, &hSession) == false) {
    DBG_ERR("Trying to close invalid session");
    return CKR_SESSION_HANDLE_INVALID;
  }
 
  DBG_INFO("Closing session %lu", hSession);
 
  DOUT;
  return CKR_OK;
}

Here is the call graph for this function:

CK_DEFINE_FUNCTION() [4/8]

CK_DEFINE_FUNCTION	(	CK_RV	,
		C_Finalize	)

Definition at line 334 of file yubihsm_pkcs11.c.

                                                             {
 
  DIN;
 
  if (pReserved != NULL) {
    DBG_ERR("Finalized called with pReserved != NULL");
    return CKR_ARGUMENTS_BAD;
  }
 
  if (g_yh_initialized == false) {
    DBG_ERR("libyubihsm is not initialized or already finalized");
    return CKR_CRYPTOKI_NOT_INITIALIZED;
  }
 
  list_iterate(&g_ctx.slots, destroy_slot_mutex);
  list_destroy(&g_ctx.slots);
 
  if (g_ctx.mutex != NULL) {
    g_ctx.destroy_mutex(g_ctx.mutex);
    g_ctx.mutex = NULL;
  }
 
  g_yh_initialized = false;
 
  yh_exit();
 
  DOUT;
 
  if (_YHP11_OUTPUT != stdout && _YHP11_OUTPUT != stderr &&
      _YHP11_OUTPUT != NULL) {
    fclose(_YHP11_OUTPUT);
    _YHP11_OUTPUT = stderr;
  }
 
  return CKR_OK;
}

Here is the call graph for this function:

CK_DEFINE_FUNCTION() [5/8]

CK_DEFINE_FUNCTION	(	CK_RV	,
		C_FindObjectsFinal	)

Definition at line 2281 of file yubihsm_pkcs11.c.

                                                                          {
 
  DIN;
 
  CK_RV rv = CKR_OK;
 
  if (g_yh_initialized == false) {
    DBG_ERR("libyubihsm is not initialized or already finalized");
    return CKR_CRYPTOKI_NOT_INITIALIZED;
  }
 
  yubihsm_pkcs11_session *session;
  rv = get_session(&g_ctx, hSession, &session, 0);
  if (rv != CKR_OK) {
    DBG_ERR("Unknown session %lu", hSession);
    return rv;
  }
 
  if (session->operation.type != OPERATION_FIND) {
    rv = CKR_OPERATION_NOT_INITIALIZED;
    goto c_fof_out;
  }
 
  session->operation.op.find.current_object = 0;
  session->operation.op.find.n_objects = 0;
 
  session->operation.type = OPERATION_NOOP;
 
  DOUT;
 
c_fof_out:
 
  release_session(&g_ctx, session);
 
  return rv;
}

Here is the call graph for this function:

CK_DEFINE_FUNCTION() [6/8]

CK_DEFINE_FUNCTION	(	CK_RV	,
		C_GetInfo	)

Definition at line 371 of file yubihsm_pkcs11.c.

                                                        {
 
  DIN;
 
  if (g_yh_initialized == false) {
    DBG_ERR("libyubihsm is not initialized or already finalized");
    return CKR_CRYPTOKI_NOT_INITIALIZED;
  }
  if (pInfo == NULL) {
    return CKR_ARGUMENTS_BAD;
  }
 
  CK_VERSION ver = {VERSION_MAJOR, (VERSION_MINOR * 10) + VERSION_PATCH};
 
  pInfo->cryptokiVersion = function_list.version;
 
  memset(pInfo->manufacturerID, ' ', sizeof(pInfo->manufacturerID));
  memcpy((char *) pInfo->manufacturerID, YUBIHSM_PKCS11_MANUFACTURER,
         strlen(YUBIHSM_PKCS11_MANUFACTURER));
 
  pInfo->flags = 0;
 
  memset(pInfo->libraryDescription, ' ', sizeof(pInfo->libraryDescription));
  memcpy((char *) pInfo->libraryDescription, YUBIHSM_PKCS11_LIBDESC,
         strlen(YUBIHSM_PKCS11_LIBDESC));
 
  pInfo->libraryVersion = ver;
 
  DOUT;
  return CKR_OK;
}

Here is the call graph for this function:

CK_DEFINE_FUNCTION() [7/8]

CK_DEFINE_FUNCTION	(	CK_RV	,
		C_Initialize	)

Definition at line 101 of file yubihsm_pkcs11.c.

                                                               {
 
  DIN;
 
  if (g_yh_initialized == true) {
    return CKR_CRYPTOKI_ALREADY_INITIALIZED;
  }
 
  CK_C_INITIALIZE_ARGS_PTR init_args = pInitArgs;
 
  yh_dbg_init(false, false, 0, "stderr");
 
  if (pInitArgs != NULL) {
    if ((init_args->flags & CKF_OS_LOCKING_OK) == 0 &&
        init_args->CreateMutex == NULL && init_args->DestroyMutex == NULL &&
        init_args->LockMutex == NULL && init_args->UnlockMutex == NULL) {
      // NOTE(adma): no threading required
      // all is good, do nothing
      g_ctx.create_mutex = NULL;
      g_ctx.destroy_mutex = NULL;
      g_ctx.lock_mutex = NULL;
      g_ctx.unlock_mutex = NULL;
    } else if ((init_args->flags & CKF_OS_LOCKING_OK) != 0 &&
               init_args->CreateMutex == NULL &&
               init_args->DestroyMutex == NULL &&
               init_args->LockMutex == NULL && init_args->UnlockMutex == NULL) {
      // NOTE(adma): threading with native OS locks
      set_native_locking(&g_ctx);
    } else if ((init_args->flags & CKF_OS_LOCKING_OK) == 0 &&
               init_args->CreateMutex != NULL &&
               init_args->DestroyMutex != NULL &&
               init_args->LockMutex != NULL && init_args->UnlockMutex != NULL) {
      // NOTE(adma): threading with supplied functions
      g_ctx.create_mutex = init_args->CreateMutex;
      g_ctx.destroy_mutex = init_args->DestroyMutex;
      g_ctx.lock_mutex = init_args->LockMutex;
      g_ctx.unlock_mutex = init_args->UnlockMutex;
    } else if ((init_args->flags & CKF_OS_LOCKING_OK) != 0 &&
               init_args->CreateMutex != NULL &&
               init_args->DestroyMutex != NULL &&
               init_args->LockMutex != NULL && init_args->UnlockMutex != NULL) {
      // NOTE(adma): threading with native or supplied functions
      g_ctx.create_mutex = init_args->CreateMutex;
      g_ctx.destroy_mutex = init_args->DestroyMutex;
      g_ctx.lock_mutex = init_args->LockMutex;
      g_ctx.unlock_mutex = init_args->UnlockMutex;
    } else {
      return CKR_ARGUMENTS_BAD;
    }
  }
 
  if (g_ctx.create_mutex != NULL) {
    if (g_ctx.create_mutex(&g_ctx.mutex) != CKR_OK) {
      DBG_ERR("Unable to create global mutex");
      return CKR_FUNCTION_FAILED;
    }
  } else {
    g_ctx.mutex = NULL;
  }
 
  struct cmdline_parser_params params;
 
  struct gengetopt_args_info args_info;
 
  cmdline_parser_params_init(&params);
 
  params.initialize = 1;
  params.check_required = 1;
 
  char *tmp = "";
 
  if (cmdline_parser(0, &tmp, &args_info) != 0) {
    DBG_ERR("Unable to initialize ggo structure");
    return CKR_FUNCTION_FAILED;
  }
 
  params.initialize = 0;
  params.override = 1;
 
  char *args = NULL;
  char *args_parsed = NULL;
 
  yh_connector **connector_list = NULL;
 
  if (init_args != NULL && init_args->pReserved != NULL) {
    args = strdup(init_args->pReserved);
    if (args == NULL) {
      DBG_ERR("Failed copying reserved string");
      return CKR_FUNCTION_FAILED;
    }
 
    char *str = args;
    char *save = NULL;
    char *part;
    while ((part = strtok_r(str, " \r\n\t", &save))) {
      char *new_ptr;
      str = NULL;
      if (args_parsed == NULL) {
        new_ptr = calloc(strlen(part) + 4, sizeof(char));
      } else {
        new_ptr = realloc(args_parsed, strlen(args_parsed) + strlen(part) + 4);
      }
      if (new_ptr) {
        args_parsed = new_ptr;
        sprintf(args_parsed + strlen(args_parsed), "--%s ", part);
      } else {
        DBG_ERR("Failed allocating memory for args");
        goto c_i_failure;
      }
    }
 
    DBG_INFO("Now parsing supplied init args as '%s'", args_parsed);
 
    if (cmdline_parser_string_ext(args_parsed, &args_info,
                                  "yubihsm_pkcs11 module", &params) != 0) {
      DBG_ERR("Parsing of the reserved init args '%s' failed", args);
      goto c_i_failure;
    }
 
    free(args);
    args = NULL;
    free(args_parsed);
    args_parsed = NULL;
  }
 
  // NOTE(thorduri): #TOCTOU
  char *config_file = args_info.config_file_arg;
  struct stat sb;
  if (stat(config_file, &sb) == -1) {
    config_file = getenv("YUBIHSM_PKCS11_CONF");
  }
 
  params.override = 0;
 
  if (config_file != NULL &&
      cmdline_parser_config_file(config_file, &args_info, &params) != 0) {
    DBG_ERR("Unable to parse configuration file");
    return CKR_FUNCTION_FAILED;
  }
 
  yh_dbg_init(args_info.debug_flag, args_info.dinout_flag,
              args_info.libdebug_flag, args_info.debug_file_arg);
 
  // NOTE(adma): it's better to set the argument optional and check its presence
  // here
  if (args_info.connector_given == 0) {
    DBG_ERR("No connector defined");
    return CKR_FUNCTION_FAILED;
  }
 
  if (yh_init() != YHR_SUCCESS) {
    DBG_ERR("Unable to initialize libyubihsm");
    return CKR_FUNCTION_FAILED;
  }
 
  DBG_INFO("Found %u configured connector(s)", args_info.connector_given);
 
  connector_list = calloc(args_info.connector_given, sizeof(yh_connector *));
  if (connector_list == NULL) {
    DBG_ERR("Failed allocating memory");
    goto c_i_failure;
  }
  size_t n_connectors = 0;
  for (unsigned int i = 0; i < args_info.connector_given; i++) {
    if (yh_init_connector(args_info.connector_arg[i], &connector_list[i]) !=
        YHR_SUCCESS) {
      DBG_ERR("Failed to init connector");
      goto c_i_failure;
    }
    if (args_info.cacert_given) {
      if (yh_set_connector_option(connector_list[i], YH_CONNECTOR_HTTPS_CA,
                                  args_info.cacert_arg) != YHR_SUCCESS) {
        DBG_ERR("Failed to set HTTPS CA option");
        goto c_i_failure;
      }
    }
    if (args_info.proxy_given) {
      if (yh_set_connector_option(connector_list[i], YH_CONNECTOR_PROXY_SERVER,
                                  args_info.proxy_arg) != YHR_SUCCESS) {
        DBG_ERR("Failed to set proxy server option");
        goto c_i_failure;
      }
    }
 
    if (yh_connect(connector_list[i], args_info.timeout_arg) != YHR_SUCCESS) {
      DBG_ERR("Failed to connect '%s'", args_info.connector_arg[i]);
      continue;
    } else {
      n_connectors++;
    }
  }
 
  if (add_connectors(&g_ctx, args_info.connector_given, args_info.connector_arg,
                     connector_list) == false) {
    DBG_ERR("Failed building connectors list");
    goto c_i_failure;
  }
 
  cmdline_parser_free(&args_info);
  free(connector_list);
 
  DBG_INFO("Found %zu usable connector(s)", n_connectors);
 
  g_yh_initialized = true;
 
  DOUT;
  return CKR_OK;
 
c_i_failure:
 
  free(args_parsed);
  free(args);
 
  list_iterate(&g_ctx.slots, destroy_slot_mutex);
  list_destroy(&g_ctx.slots);
 
  if (connector_list) {
    for (unsigned int i = 0; i < args_info.connector_given; i++) {
      yh_disconnect(connector_list[i]);
    }
  }
 
  cmdline_parser_free(&args_info);
  free(connector_list);
 
  if (g_ctx.mutex != NULL) {
    g_ctx.destroy_mutex(g_ctx.mutex);
    g_ctx.mutex = NULL;
  }
 
  return CKR_FUNCTION_FAILED;
}

Here is the call graph for this function:

CK_DEFINE_FUNCTION() [8/8]

CK_DEFINE_FUNCTION	(	CK_RV	,
		C_Logout	)

Definition at line 1160 of file yubihsm_pkcs11.c.

                                                                {
 
  DIN;
 
  CK_RV rv = CKR_OK;
 
  if (g_yh_initialized == false) {
    DBG_ERR("libyubihsm is not initialized or already finalized");
    return CKR_CRYPTOKI_NOT_INITIALIZED;
  }
 
  yubihsm_pkcs11_session *session;
  rv = get_session(&g_ctx, hSession, &session, SESSION_AUTHENTICATED);
  if (rv != CKR_OK) {
    DBG_ERR("Invalid session ID: %lu", hSession);
    return rv;
  }
 
  if (yh_util_close_session(session->slot->device_session) != YHR_SUCCESS) {
    DBG_ERR("Failed closing session");
    rv = CKR_FUNCTION_FAILED;
    goto c_l_out;
  }
 
  if (yh_destroy_session(&session->slot->device_session) != YHR_SUCCESS) {
    DBG_ERR("Failed destroying session");
    rv = CKR_FUNCTION_FAILED;
    goto c_l_out;
  }
 
  session->slot->device_session = NULL;
 
  list_iterate(&session->slot->pkcs11_sessions, logout_sessions);
 
  DOUT;
 
c_l_out:
 
  release_session(&g_ctx, session);
 
  return rv;
}

Here is the call graph for this function:

DBG_ERR()

DBG_ERR	(	"Verification update with %lu bytes"	,
		ulPartLen	)

DBG_INFO() [1/31]

DBG_INFO	(	"After padding and transformation there are %u bytes"	,
		session->operation.	buffer_length )

DBG_INFO() [2/31]

DBG_INFO	(	"Allocated session %lu"	,
		*	phSession )

DBG_INFO() [3/31]

DBG_INFO	(	"Can return %lu object(s)"	,
		ulMaxObjectCount	)

DBG_INFO() [4/31]

DBG_INFO	(	"Created object %04lx"	,
		*	phKey )

DBG_INFO() [5/31]

DBG_INFO	(	"Created object %08lx"	,
		*	phObject )

DBG_INFO() [6/31]

DBG_INFO	(	"Decrypt update with %lu bytes"	,
		ulEncryptedPartLen	)

DBG_INFO() [7/31]

DBG_INFO	(	"Deleted object %08lx"	,
		hObject	)

DBG_INFO() [8/31]

DBG_INFO	(	"Digest update with %lu bytes"	,
		ulPartLen	)

DBG_INFO() [9/31]

DBG_INFO	(	"Encrypt update with %lu bytes"	,
		ulPartLen	)

DBG_INFO() [10/31]

DBG_INFO	(	"Encrypting %lu bytes"	,
		ulDataLen	)

DBG_INFO() [11/31]

DBG_INFO	(	"find with %lu attributes"	,
		ulCount	)

DBG_INFO() [12/31]

DBG_INFO	(	"For object %08lx"	,
		hObject	)

DBG_INFO() [13/31]

DBG_INFO	(	"Found %lu mechanisms"	,
		*	pulCount )

DBG_INFO() [14/31]

DBG_INFO	(	"Got %lu butes back"	,
		*	pulEncryptedDataLen )

DBG_INFO() [15/31]

DBG_INFO	(	"Got %lu bytes back"	,
		*	pulLastEncryptedPartLen )

DBG_INFO() [16/31]

DBG_INFO	(	"Returning %lu object(s)"	,
		*	pulObjectCount )

DBG_INFO() [17/31]

DBG_INFO	(	"Sending %lu bytes to digest"	,
		ulDataLen	)

DBG_INFO() [18/31]

DBG_INFO	(	"Sending %lu bytes to sign"	,
		ulDataLen	)

DBG_INFO() [19/31]

DBG_INFO

(

"Signature successfully verified"

)

DBG_INFO() [20/31]

DBG_INFO	(	"Signature update with %lu bytes"	,
		ulPartLen	)

DBG_INFO() [21/31]

DBG_INFO	(	"The size of the data will be %lu"	,
		datalen	)

DBG_INFO() [22/31]

DBG_INFO	(	"The size of the signature will be %u"	,
		session->operation.op.sign.	sig_len )

DBG_INFO() [23/31]

DBG_INFO	(	"Trying to decrypt data with mechanism 0x%04lx and key %08lx"	,
		pMechanism->	mechanism,
		hKey	)

DBG_INFO() [24/31]

DBG_INFO	(	"Trying to digest data with mechanism 0x%04lx"	,
		pMechanism->	mechanism )

DBG_INFO() [25/31]

DBG_INFO	(	"Trying to encrypt data with mechanism 0x%04lx and key %08lx"	,
		pMechanism->	mechanism,
		hKey	)

DBG_INFO() [26/31]

DBG_INFO	(	"Trying to sign data with mechanism 0x%04lx and key %08lx"	,
		pMechanism->	mechanism,
		hKey	)

DBG_INFO() [27/31]

DBG_INFO	(	"Trying to verify data with mechanism 0x%04lx and key %lx"	,
		pMechanism->	mechanism,
		hKey	)

DBG_INFO() [28/31]

DBG_INFO	(	"Unwrapped object %08lx"	,
		*	phKey )

DBG_INFO() [29/31]

DBG_INFO	(	"Using key %04x"	,
		session->operation.op.decrypt.	key_id )

DBG_INFO() [30/31]

DBG_INFO	(	"Using key %04x"	,
		session->operation.op.sign.	key_id )

DBG_INFO() [31/31]

DBG_INFO	(	"Using key %04x"	,
		session->operation.op.verify.	key_id )

delete_object_from_cache()

delete_object_from_cache	(	session->slot->	objects,
		hObject	)

ecdh_key()

memset & ecdh_key

(

ecdh_key

)

for() [1/3]

for

(

)

Definition at line 1245 of file yubihsm_pkcs11.c.

                                         {
    switch (pTemplate[i].type) {
      case CKA_CLASS:
        if (class.set == false) {
          class.d = *((CK_ULONG_PTR) pTemplate[i].pValue);
          class.set = true;
        } else {
          rv = CKR_TEMPLATE_INCONSISTENT;
          goto c_co_out;
        }
        break;
 
      case CKA_KEY_TYPE:
        if (key_type.set == false) {
          key_type.d = *((CK_ULONG_PTR) pTemplate[i].pValue);
          key_type.set = true;
        } else {
          rv = CKR_TEMPLATE_INCONSISTENT;
          goto c_co_out;
        }
        break;
 
      case CKA_ID:
        if (id.set == false) {
          id.d = parse_id_value(pTemplate[i].pValue, pTemplate[i].ulValueLen);
          if (id.d == (CK_ULONG) -1) {
            rv = CKR_ATTRIBUTE_VALUE_INVALID;
            goto c_co_out;
          }
          id.set = true;
        } else {
          rv = CKR_TEMPLATE_INCONSISTENT;
          goto c_co_out;
        }
        break;
 
      case CKA_LABEL:
        if (pTemplate[i].ulValueLen > YH_OBJ_LABEL_LEN) {
          rv = CKR_ATTRIBUTE_VALUE_INVALID;
          goto c_co_out;
        }
 
        memcpy(template.label, pTemplate[i].pValue, pTemplate[i].ulValueLen);
 
        break;
 
      case CKA_EXTRACTABLE:
        if ((rv = set_template_attribute(&template.exportable,
                                         pTemplate[i].pValue)) != CKR_OK) {
          goto c_co_out;
        }
    }
  }

Here is the call graph for this function:

for() [2/3]

for

(

ListItem *

item = g_ctx.slots.head; item != NULL; item = item->next

)

Definition at line 468 of file yubihsm_pkcs11.c.

                                                                           {
    if (j == *pulCount) {
      full = true;
    }
 
    yubihsm_pkcs11_slot *slot = (yubihsm_pkcs11_slot *) item->data;
    if (tokenPresent == CK_TRUE) {
      if (yh_connector_has_device(slot->connector) != true) {
        continue;
      }
    }
    if (full == false) {
      pSlotList[j] = slot->id;
 
      DBG_INFO("Returning slot %lu", pSlotList[j]);
    } else {
      overflow = true;
    }
 
    j += 1;
  }

Here is the call graph for this function:

for() [3/3]

for

(

uint16_t

i = 0; i < ulMaxObjectCount && session->operation.op.find.current_object < session->operation.op.find.n_objects; session->operation.op.find.current_object++

)

Definition at line 2227 of file yubihsm_pkcs11.c.

                                                    {
    yh_object_descriptor *object =
      &session->operation.op.find
         .objects[session->operation.op.find.current_object];
    uint32_t id;
    switch (object->type) {
      case YH_ASYMMETRIC_KEY:
      case YH_OPAQUE:
      case YH_WRAP_KEY:
      case YH_HMAC_KEY:
      case YH_PUBLIC_KEY:
        id = object->sequence << 24;
        id |= object->type << 16;
        id |= object->id;
        break;
      default:
        if (object->type == ECDH_KEY_TYPE) {
          id = ECDH_KEY_TYPE << 16;
          id |= object->id;
        } else {
          DBG_INFO("Found unknown object type %x, skipping over", object->type);
          continue;
        }
    }
 
    phObject[i++] = id;
 
    *pulObjectCount += 1;
 
    if (!session->operation.op.find.only_private &&
        object->type == YH_ASYMMETRIC_KEY) {
      object->type |= 0x80;
      session->operation.op.find.current_object--;
      DBG_INFO("stepping back");
    }
 
    DBG_INFO("Returning object %d as %08x",
             session->operation.op.find.current_object, id);
  }

if() [1/81]

if

(

!

pulCount

)

Definition at line 432 of file yubihsm_pkcs11.c.

                 {
    DBG_ERR("pulCount argument bad");
    return CKR_ARGUMENTS_BAD;
  }

if() [2/81]

if

(

(expected_key_length > 0) &&(expected_key_length !=out_len)

)

Definition at line 5008 of file yubihsm_pkcs11.c.

                                                                     {
    DBG_ERR("Failed to derive a key with the expected length");
    rv = CKR_FUNCTION_FAILED;
    goto c_drv_out;
  }

if() [3/81]

if

(

(flags &CKF_SERIAL_SESSION)

= = 0

)

Definition at line 829 of file yubihsm_pkcs11.c.

                                         {
    // NOTE(adma): required by specs
    DBG_ERR("Open session called without CKF_SERIAL_SESSION set");
    return CKR_SESSION_PARALLEL_NOT_SUPPORTED;
  }

if() [4/81]

if

(

basekey_type

= = ECDH_KEY_TYPE

)

Definition at line 4931 of file yubihsm_pkcs11.c.

                                     {
    DBG_ERR("Cannot derive an ECDH key from another ECDH key");
    rv = CKR_ARGUMENTS_BAD;
    goto c_drv_out;
  }

if() [5/81]

if

(

check_decrypt_mechanism(session->slot, pMechanism) !

= true

)

Definition at line 2673 of file yubihsm_pkcs11.c.

                                                                  {
    DBG_ERR("Decryption mechanism %lu not supported", pMechanism->mechanism);
    rv = CKR_MECHANISM_INVALID;
    goto c_di_out;
  }

if() [6/81]

if

(

check_digest_mechanism(pMechanism) !

= true

)

Definition at line 3116 of file yubihsm_pkcs11.c.

                                                  {
    DBG_ERR("Digest mechanism %lu not supported", pMechanism->mechanism);
    rv = CKR_MECHANISM_INVALID;
    goto c_di_out;
  }

if() [7/81]

if

(

check_encrypt_mechanism(session->slot, pMechanism) !

= true

)

Definition at line 2369 of file yubihsm_pkcs11.c.

                                                                  {
    DBG_ERR("Encryption mechanism %lu not supported", pMechanism->mechanism);
    rv = CKR_MECHANISM_INVALID;
    goto c_ei_out;
  }

if() [8/81]

if

(

check_sign_mechanism(session->slot, pMechanism) !

= true

)

Definition at line 3477 of file yubihsm_pkcs11.c.

                                                               {
    DBG_ERR("Signing mechanism %lu not supported", pMechanism->mechanism);
    rv = CKR_MECHANISM_INVALID;
    goto c_si_out;
  }

if() [9/81]

if

(

check_verify_mechanism(session->slot, pMechanism) !

= true

)

Definition at line 3901 of file yubihsm_pkcs11.c.

                                                                 {
    DBG_ERR("Verification mechanism %lu not supported", pMechanism->mechanism);
    rv = CKR_MECHANISM_INVALID;
    goto c_vi_out;
  }

if() [10/81]

if

(

check_wrap_mechanism(session->slot, pMechanism) !

= true

)

Definition at line 4741 of file yubihsm_pkcs11.c.

                                                               {
    DBG_ERR("Wrapping mechanism %lu not supported", pMechanism->mechanism);
    rv = CKR_MECHANISM_INVALID;
    goto c_wk_out;
  }

if() [11/81]

if

(

class.

set = = false

)

Definition at line 1299 of file yubihsm_pkcs11.c.

                          {
    rv = CKR_TEMPLATE_INCOMPLETE;
    goto c_co_out;
  }

if() [12/81]

if

(

create_session(slot, flags, phSession)

= = false

)

Definition at line 851 of file yubihsm_pkcs11.c.

                                                       {
    DBG_ERR("Connector %lu has too many open sessions", slotID);
    rv = CKR_SESSION_COUNT;
    goto c_os_out;
  }

if() [13/81]

if

(

g_yh_initialized

= = false

)

Definition at line 427 of file yubihsm_pkcs11.c.

                                 {
    DBG_ERR("libyubihsm is not initialized or already finalized");
    return CKR_CRYPTOKI_NOT_INITIALIZED;
  }

if() [14/81]

if

(

get_mechanism_info(slot, type, pInfo)

= = false

)

Definition at line 752 of file yubihsm_pkcs11.c.

                                                      {
    DBG_ERR("Invalid mechanism %lu", type);
    rv = CKR_MECHANISM_INVALID;
  } else {

if() [15/81]

if

(

in_len !

= params->ulPublicDataLen

)

Definition at line 4979 of file yubihsm_pkcs11.c.

                                         {
    DBG_ERR("Invalid parameter");
    return CKR_ARGUMENTS_BAD;
  }

if() [16/81]

else if

(

is_ECDSA_sign_mechanism(session->operation.mechanism.mechanism)

)

Definition at line 4054 of file yubihsm_pkcs11.c.

                                                                              {
    siglen = ((session->operation.op.verify.key_len + 7) / 8) * 2;
  } else {

if() [17/81]

if

(

is_HMAC_sign_mechanism(session->operation.mechanism.mechanism)

= = true

)

Definition at line 4030 of file yubihsm_pkcs11.c.

                                                                              {
    switch (session->operation.mechanism.mechanism) {
      case CKM_SHA_1_HMAC:
        siglen = 20;
        break;
 
      case CKM_SHA256_HMAC:
        siglen = 32;
        break;
 
      case CKM_SHA384_HMAC:
        siglen = 48;
        break;
 
      case CKM_SHA512_HMAC:
        siglen = 64;
        break;
      default:
        rv = CKR_ARGUMENTS_BAD;
        goto c_v_out;
    }
  } else if (is_RSA_sign_mechanism(session->operation.mechanism.mechanism) ==

Here is the call graph for this function:

if() [18/81]

else if

(

is_RSA_sign_mechanism(session->operation.mechanism.mechanism)

= = true

)

Definition at line 4051 of file yubihsm_pkcs11.c.

                   {
    siglen = (session->operation.op.verify.key_len + 7) / 8;
  } else if (is_ECDSA_sign_mechanism(session->operation.mechanism.mechanism)) {

if() [19/81]

if

(

key

= = NULL

)

Definition at line 4750 of file yubihsm_pkcs11.c.

                   {
    DBG_ERR("No wrap key found");
    rv = CKR_WRAPPING_KEY_HANDLE_INVALID;
    goto c_wk_out;
  }

if() [20/81]

if

(

key_type.

set = = false || class.set == false

)

Definition at line 4413 of file yubihsm_pkcs11.c.

                                                   {
    rv = CKR_TEMPLATE_INCOMPLETE;
    goto c_gk_out;
  }

if() [21/81]

if

(

len !

= ulRandomLen || pRandomData == NULL

)

Definition at line 5063 of file yubihsm_pkcs11.c.

                                                 {
    DBG_ERR("Invalid parameter");
    return CKR_ARGUMENTS_BAD;
  }

if() [22/81]

if	(	len	,
		*	pulWrappedKeyLen )

Definition at line 4782 of file yubihsm_pkcs11.c.

                               {
    DBG_ERR("buffer to small, needed %lu, got %lu", (unsigned long) len,
            *pulWrappedKeyLen);
    rv = CKR_BUFFER_TOO_SMALL;
    goto c_wk_out;
  }

if() [23/81]

if

(

object->object.type !

= YH_WRAP_KEY

)

Definition at line 2376 of file yubihsm_pkcs11.c.

                                          {
    DBG_ERR("Wrong key type or algorithm");
    rv = CKR_KEY_TYPE_INCONSISTENT;
    goto c_ei_out;
  }

if() [24/81]

else if

(

object->object.

type = = YH_ASYMMETRIC_KEY && yh_is_rsa(object->object.algorithm)

)

Definition at line 2680 of file yubihsm_pkcs11.c.

                                           {
    DBG_INFO("RSA decryption requested");
 
    size_t key_length;
    yh_rc yrc = yh_get_key_bitlength(object->object.algorithm, &key_length);
    if (yrc != YHR_SUCCESS) {
      DBG_ERR("Unable to get key length: %s", yh_strerror(yrc));
      rv = CKR_FUNCTION_FAILED;
      goto c_di_out;
    }
 
    session->operation.op.decrypt.key_len = key_length;
 
    if (pMechanism->mechanism == CKM_RSA_PKCS_OAEP) {
      if (pMechanism->ulParameterLen != sizeof(CK_RSA_PKCS_OAEP_PARAMS)) {
        DBG_ERR("Length of mechanism parameters does not match expected value: "
                "found %lu, expected %zu",
                pMechanism->ulParameterLen, sizeof(CK_RSA_PKCS_OAEP_PARAMS));
        rv = CKR_MECHANISM_PARAM_INVALID;
        goto c_di_out;
      }
 
      CK_RSA_PKCS_OAEP_PARAMS *params = pMechanism->pParameter;
 
      if (params->source == 0 && params->ulSourceDataLen != 0) {
        DBG_ERR("Source parameter empty but sourceDataLen != 0");
        rv = CKR_MECHANISM_PARAM_INVALID;
        goto c_di_out;
      } else if (params->source != 0 && params->source != CKZ_DATA_SPECIFIED) {
        DBG_ERR("Unknown value in parameter source");
        rv = CKR_MECHANISM_PARAM_INVALID;
        goto c_di_out;
      }
 
      switch (params->mgf) {
        case CKG_MGF1_SHA1:
          session->operation.mechanism.oaep.mgf1Algo = YH_ALGO_MGF1_SHA1;
          break;
        case CKG_MGF1_SHA256:
          session->operation.mechanism.oaep.mgf1Algo = YH_ALGO_MGF1_SHA256;
          break;
        case CKG_MGF1_SHA384:
          session->operation.mechanism.oaep.mgf1Algo = YH_ALGO_MGF1_SHA384;
          break;
        case CKG_MGF1_SHA512:
          session->operation.mechanism.oaep.mgf1Algo = YH_ALGO_MGF1_SHA512;
          break;
        default:
          rv = CKR_MECHANISM_PARAM_INVALID;
          goto c_di_out;
      };
 
      const EVP_MD *md = NULL;
 
      switch (params->hashAlg) {
        case CKM_SHA_1:
          md = EVP_sha1();
          break;
        case CKM_SHA256:
          md = EVP_sha256();
          break;
        case CKM_SHA384:
          md = EVP_sha384();
          break;
        case CKM_SHA512:
          md = EVP_sha512();
          break;
        default:
          rv = CKR_MECHANISM_PARAM_INVALID;
          goto c_di_out;
      }
      mdctx = EVP_MD_CTX_create();
 
      if (EVP_DigestInit_ex(mdctx, md, NULL) == 0) {
        rv = CKR_MECHANISM_PARAM_INVALID;
        goto c_di_out;
      }
 
      if (EVP_DigestUpdate(mdctx, params->pSourceData,
                           params->ulSourceDataLen) != 1) {
        rv = CKR_FUNCTION_FAILED;
        goto c_di_out;
      }
      if (EVP_DigestFinal_ex(mdctx, session->operation.mechanism.oaep.label,
                             &session->operation.mechanism.oaep.label_len) !=
          1) {
        rv = CKR_FUNCTION_FAILED;
        goto c_di_out;
      }
    } else if (pMechanism->mechanism != CKM_RSA_PKCS) {
      DBG_ERR("Mechanism %lu not supported", pMechanism->mechanism);
      rv = CKR_MECHANISM_INVALID;
      goto c_di_out;
    }
  } else if (object->object.type == YH_WRAP_KEY &&

Here is the call graph for this function:

if() [25/81]

if

(

object

= = NULL

)

Definition at line 1626 of file yubihsm_pkcs11.c.

                        {
      DBG_ERR("Object not found");
      rv = CKR_OBJECT_HANDLE_INVALID;
      goto c_do_out;
    }

if() [26/81]

if

(

overflow

= = true

)

Definition at line 492 of file yubihsm_pkcs11.c.

                        {
    GLOBAL_UNLOCK_OR_RETURN;
    return CKR_BUFFER_TOO_SMALL;
  }

if() [27/81]

if

(

params->

kdf = = CKD_NULL

)

Definition at line 4965 of file yubihsm_pkcs11.c.

                               {
    if ((params->pSharedData != NULL) || (params->ulSharedDataLen != 0)) {
      DBG_ERR("Mechanism parameters incompatible with key derivation function "
              "CKD_NULL");
      rv = CKR_MECHANISM_PARAM_INVALID;
      goto c_drv_out;
    }
  } else {

if() [28/81]

if

(

parse_hex(pPin, 4,(uint8_t *) &key_id)

= = false

)

Definition at line 1106 of file yubihsm_pkcs11.c.

                                                        {
    DBG_ERR(
      "PIN contains invalid characters, first four digits must be [0-9A-Fa-f]");
    return CKR_PIN_INCORRECT;
  }

if() [29/81]

if

(

pData

= = NULL

)

Definition at line 2863 of file yubihsm_pkcs11.c.

                     {
    // NOTE(adma): Just return the size of the data
    *pulDataLen = datalen;
 
    rv = CKR_OK;
    terminate = false;
 
    DOUT;
    goto c_d_out;
  }

if() [30/81]

if

(

pDigest

= = NULL

)

Definition at line 3186 of file yubihsm_pkcs11.c.

                       {
    // NOTE(adma): Just return the size of the digest
    DBG_INFO("The size of the digest will be %lu",
             session->operation.op.digest.digest_len);
 
    *pulDigestLen = session->operation.op.digest.digest_len;
 
    rv = CKR_OK;
    terminate = false;
 
    DOUT;
    goto c_d_out;
  }

if() [31/81]

if

(

pEncryptedData

= = NULL

)

Definition at line 2431 of file yubihsm_pkcs11.c.

                              {
    // NOTE: if data is NULL, just return size we'll need
    *pulEncryptedDataLen = datalen;
    rv = CKR_OK;
    terminate = false;
 
    DOUT;
    goto c_e_out;
  }

if() [32/81]

if

(

pEncryptedPart

= = NULL

)

Definition at line 2956 of file yubihsm_pkcs11.c.

                              {
    DBG_ERR("No data provided");
    rv = CKR_ARGUMENTS_BAD;
    goto c_du_out;
  }

if() [33/81]

if

(

phObject

= = NULL || ulMaxObjectCount == 0 || pulObjectCount == NULL

)

Definition at line 2214 of file yubihsm_pkcs11.c.

                                                                           {
    rv = CKR_ARGUMENTS_BAD;
    goto c_fo_out;
  }

if() [34/81]

if

(

phSession

= = NULL

)

Definition at line 824 of file yubihsm_pkcs11.c.

                         {
    DBG_ERR("Wrong/Missing parameter");
    return CKR_ARGUMENTS_BAD;
  }

if() [35/81]

if

(

pInfo

= = NULL

)

Definition at line 741 of file yubihsm_pkcs11.c.

                     {
    DBG_ERR("Wrong/missing parameter");
    return CKR_ARGUMENTS_BAD;
  }

if() [36/81]

if

(

pLastEncryptedPart

= = NULL

)

Definition at line 2589 of file yubihsm_pkcs11.c.

                                  {
    // NOTE: should this rather return length and ok?
    DBG_ERR("No buffer provided");
    rv = CKR_ARGUMENTS_BAD;
    goto c_ef_out;
  }

if() [37/81]

if

(

pLastPart

= = NULL

)

Definition at line 3040 of file yubihsm_pkcs11.c.

                         {
    DBG_ERR("No buffer provided, length check only");
    *pulLastPartLen = datalen;
    rv = CKR_OK;
    terminate = false;
    goto c_df_out;
  }

if() [38/81]

if

(

pMechanism->mechanism !

= CKM_GENERIC_SECRET_KEY_GEN

)

Definition at line 4345 of file yubihsm_pkcs11.c.

                                                           {
    DBG_ERR("Invalid mechanism %lu", pMechanism->mechanism);
    rv = CKR_MECHANISM_INVALID;
    goto c_gk_out;
  }

if() [39/81]

else if

(

pMechanism->

mechanism = = CKM_RSA_PKCS_KEY_PAIR_GEN

)

Definition at line 4573 of file yubihsm_pkcs11.c.

                                                          {
    rv =
      parse_rsa_generate_template(pPublicKeyTemplate, ulPublicKeyAttributeCount,
                                  pPrivateKeyTemplate,
                                  ulPrivateKeyAttributeCount, &template);
  } else if (pMechanism->mechanism == CKM_EC_KEY_PAIR_GEN) {

Here is the call graph for this function:

if() [40/81]

if

(

pMechanism

= = NULL || pMechanism->mechanism != CKM_YUBICO_AES_CCM_WRAP

)

Definition at line 2331 of file yubihsm_pkcs11.c.

                                                                              {
    DBG_ERR("Invalid Mechanism");
    return CKR_ARGUMENTS_BAD;
  }

if() [41/81]

if

(

pPart

= = NULL

)

Definition at line 2508 of file yubihsm_pkcs11.c.

                     {
    DBG_ERR("No data provided");
    rv = CKR_ARGUMENTS_BAD;
    goto c_eu_out;
  }

if() [42/81]

if

(

ppFunctionList

= = NULL

)

Definition at line 409 of file yubihsm_pkcs11.c.

                              {
    DBG_ERR("GetFunctionList called with ppFunctionList = NULL");
    return CKR_ARGUMENTS_BAD;
  }

Here is the caller graph for this function:

if() [43/81]

if

(

pSignature

= = NULL

)

Definition at line 3623 of file yubihsm_pkcs11.c.

                          {
    // NOTE(adma): Just return the size of the signature
    *pulSignatureLen = session->operation.op.sign.sig_len;
 
    rv = CKR_OK;
    terminate = false;
    DOUT;
    goto c_s_out;
  }

if() [44/81]

if

(

pSlotList

= = NULL

)

Definition at line 439 of file yubihsm_pkcs11.c.

                         {
    *pulCount = 0;
    // NOTE(adma) just return the number of slots
    if (tokenPresent == CK_TRUE) {
      for (ListItem *item = g_ctx.slots.head; item != NULL; item = item->next) {
        yubihsm_pkcs11_slot *slot = (yubihsm_pkcs11_slot *) item->data;
        if (yh_connector_has_device(slot->connector) == true) {
          *pulCount += 1;
        }
      }
 
      DBG_INFO("Number of slots with a token is %lu", *pulCount);
    } else {
      *pulCount = g_ctx.slots.length;
 
      DBG_INFO("Total number of slots is %lu", *pulCount);
    }
    // NOTE(adma): actually return the slot IDs
    DBG_INFO("Can return %lu slot(s)", *pulCount);
 
    GLOBAL_UNLOCK_OR_RETURN;
 
    DOUT;
    return CKR_OK;
  }

Here is the call graph for this function:

if() [45/81]

if

(

pTemplate

= = NULL || ulCount == 0 || phObject == NULL

)

Definition at line 1216 of file yubihsm_pkcs11.c.

                                                             {
    DBG_ERR("Called with invalid parameters: pTemplate=%p ulCount=%lu "
            "phObject=%p",
            (void *) pTemplate, ulCount, (void *) phObject);
    return CKR_ARGUMENTS_BAD;
  }

if() [46/81]

if

(

pulCount

= = NULL

)

Definition at line 698 of file yubihsm_pkcs11.c.

                        {
    DBG_ERR("Wrong/missing parameter");
    return CKR_ARGUMENTS_BAD;
  }

if() [47/81]

if

(

pulDigestLen

= = NULL

)

Definition at line 3180 of file yubihsm_pkcs11.c.

                            {
    DBG_ERR("Wrong/missing parameter");
    rv = CKR_ARGUMENTS_BAD;
    goto c_d_out;
  }

if() [48/81]

if

(

pulSize

= = NULL

)

Definition at line 1664 of file yubihsm_pkcs11.c.

                       {
    return CKR_ARGUMENTS_BAD;
  }

if() [49/81]

if

(

pWrappedKey

= = NULL

)

Definition at line 4727 of file yubihsm_pkcs11.c.

                           {
    *pulWrappedKeyLen =
      sizeof(yh_object_descriptor) + object->object.len + YH_CCM_WRAP_OVERHEAD;
    DBG_INFO("Calculated that wrapping will need %lu bytes", *pulWrappedKeyLen);
    rv = CKR_OK;
    goto c_wk_out;
  }

if() [50/81]

if

(

rc !

= YHR_SUCCESS

)

Definition at line 4656 of file yubihsm_pkcs11.c.

                           {
      DBG_ERR("Failed writing EC key to device");
      rv = CKR_FUNCTION_FAILED;
      goto c_gkp_out;
    }

if() [51/81]

if

(

ret !

= CKR_OK

)

Definition at line 974 of file yubihsm_pkcs11.c.

                     {
    DBG_ERR("Session handle invalid");
    return ret;
  }

if() [52/81]

if

(

rv !

= CKR_OK

)

Definition at line 1119 of file yubihsm_pkcs11.c.

                    {
    DBG_ERR("Invalid session ID: %lu", hSession);
    return rv;
  }

if() [53/81]

if

(

rv

= = CKR_BUFFER_TOO_SMALL

)

Definition at line 710 of file yubihsm_pkcs11.c.

                                  {
    DBG_ERR("Mechanism buffer too small");
    goto c_gml_out;
  } else if (rv == CKR_FUNCTION_FAILED) {

if() [54/81]

if	(	seq	,
		MAX_ECDH_SESSION_KEYS	)

Definition at line 4987 of file yubihsm_pkcs11.c.

                                   {
    DBG_ERR("There are already %d ECDH keys available for this session. "
            "Cannot derive more",
            MAX_ECDH_SESSION_KEYS);
    rv = CKR_FUNCTION_FAILED;
    goto c_drv_out;
  }

if() [55/81]

if

(

session->operation.mechanism.mechanism !

= CKM_YUBICO_AES_CCM_WRAP

)

Definition at line 2422 of file yubihsm_pkcs11.c.

                                                                         {
    DBG_ERR("Wrong mechanism: %lu", session->operation.mechanism.mechanism);
    rv = CKR_MECHANISM_INVALID;
    goto c_e_out;
  }

Here is the call graph for this function:

if() [56/81]

else if

(

session->operation.mechanism.

mechanism = = CKM_YUBICO_AES_CCM_WRAP

)

Definition at line 2568 of file yubihsm_pkcs11.c.

                                                                         {
    datalen = session->operation.buffer_length + YH_CCM_WRAP_OVERHEAD;
  } else {

if() [57/81]

if

(

session->operation.op.decrypt.

finalized = = false

)

Definition at line 2878 of file yubihsm_pkcs11.c.

                                                        {
    DBG_INFO("Sending %lu bytes to decrypt", ulEncryptedDataLen);
 
    rv = apply_decrypt_mechanism_update(&session->operation, pEncryptedData,
                                        ulEncryptedDataLen);
    if (rv != CKR_OK) {
      DBG_ERR("Unable to perform decrypt operation step");
      goto c_d_out;
    }
 
    rv = apply_decrypt_mechanism_finalize(&session->operation);
    if (rv != CKR_OK) {
      DBG_ERR("Unable to finalize decrypt operation");
      goto c_d_out;
    }
  }

Here is the call graph for this function:

if() [58/81]

if

(

session->operation.op.digest.

is_multipart = = true

)

Definition at line 3174 of file yubihsm_pkcs11.c.

                                                         {
    DBG_ERR("Another digest operation is already active");
    rv = CKR_OPERATION_ACTIVE;
    goto c_d_out;
  }

if() [59/81]

if

(

session->operation.type !

= OPERATION_NOOP

)

Definition at line 1230 of file yubihsm_pkcs11.c.

                                                 {
    DBG_ERR("A different operation is already active");
    rv = CKR_OPERATION_ACTIVE;
    goto c_co_out;
  }

if() [60/81]

if

(

session->session_state &

SESSION_NOT_AUTHENTICATED

)

Definition at line 1911 of file yubihsm_pkcs11.c.

                                                          {
    rv = CKR_OK;
    // NOTE: we need to take extra care here, we're lying about the operation
    // being succesful, so we need to setup the internal state correctly as
    // well.
    session->operation.type = OPERATION_FIND;
    session->operation.op.find.current_object = 0;
    DOUT;
    goto c_foi_out;
  }

if() [61/81]

if

(

slot

= = NULL

)

Definition at line 519 of file yubihsm_pkcs11.c.

                    {
    DBG_ERR("Invalid slot ID %lu", slotID);
    return CKR_SLOT_ID_INVALID;
  }

if() [62/81]

if

(

template.

exportable = = ATTRIBUTE_TRUE

)

Definition at line 1310 of file yubihsm_pkcs11.c.

                                             {
    rc = yh_string_to_capabilities("exportable-under-wrap", &capabilities);
    if (rc != YHR_SUCCESS) {
      DBG_ERR("Failed setting exportable-under-wrap capability");
      rv = CKR_FUNCTION_FAILED;
      goto c_co_out;
    }
  }

Here is the call graph for this function:

if() [63/81]

if

(

terminate

= = true

)

Definition at line 2474 of file yubihsm_pkcs11.c.

                           {
      session->operation.type = OPERATION_NOOP;
    }

if() [64/81]

if

(

type

= = ECDH_KEY_TYPE

)

Definition at line 1608 of file yubihsm_pkcs11.c.

                             {
    ListItem *item =
      list_get(&session->ecdh_session_keys, &hObject, compare_ecdh_keys);
    if (item) {
      list_delete(&session->ecdh_session_keys, item);
      DBG_INFO("Deleted ECDH session key %08lx", hObject);
    } else {
      DBG_INFO("No ECDH session key with ID %08lx was found", hObject);
    }
  } else {

Here is the call graph for this function:

if() [65/81]

if

(

ulCount !

= 0 && pTemplate == NULL

)

Definition at line 1890 of file yubihsm_pkcs11.c.

                                         {
    DBG_ERR("Asking for specific objects but no template given");
    return CKR_ARGUMENTS_BAD;
  }

if() [66/81]

if

(

ulPinLen< YUBIHSM_PKCS11_MIN_PIN_LEN||ulPinLen >

YUBIHSM_PKCS11_MAX_PIN_LEN

)

Definition at line 1097 of file yubihsm_pkcs11.c.

                                             {
    DBG_ERR("Wrong PIN length, must be [%d, %d] got %lu",
            YUBIHSM_PKCS11_MIN_PIN_LEN, YUBIHSM_PKCS11_MAX_PIN_LEN, ulPinLen);
    return CKR_ARGUMENTS_BAD;
  }

if() [67/81]

if

(

ulSignatureLen !

= siglen

)

Definition at line 4063 of file yubihsm_pkcs11.c.

                                {
    DBG_ERR("Wrong data length, expected %lu, got %lu", siglen, ulSignatureLen);
    rv = CKR_SIGNATURE_LEN_RANGE;
    goto c_v_out;
  }

if() [68/81]

if

(

unknown

= = false

)

Definition at line 2098 of file yubihsm_pkcs11.c.

                        {
    uint16_t found_objects = 0;
    if (secret_key == true) {
      // NOTE(adma): looking for a secret key. Get items of all types and filter
      // manually
      yh_object_descriptor
        tmp_objects[YH_MAX_ITEMS_COUNT + MAX_ECDH_SESSION_KEYS];
      size_t tmp_n_objects = YH_MAX_ITEMS_COUNT + MAX_ECDH_SESSION_KEYS;
      rc = yh_util_list_objects(session->slot->device_session, id, 0, domains,
                                &capabilities, algorithm, label, tmp_objects,
                                &tmp_n_objects);
      if (rc != YHR_SUCCESS) {
        DBG_ERR("Failed to get object list");
        rv = CKR_FUNCTION_FAILED;
        goto c_foi_out;
      }
 
      for (uint16_t i = 0; i < tmp_n_objects; i++) {
        if (tmp_objects[i].type == YH_WRAP_KEY ||
            tmp_objects[i].type == YH_HMAC_KEY) {
          memcpy(session->operation.op.find.objects + found_objects,
                 tmp_objects + i, sizeof(yh_object_descriptor));
          found_objects++;
        }
      }
    } else {
      session->operation.op.find.n_objects =
        YH_MAX_ITEMS_COUNT + MAX_ECDH_SESSION_KEYS;
      rc = yh_util_list_objects(session->slot->device_session, id, type,
                                domains, &capabilities, algorithm, label,
                                session->operation.op.find.objects,
                                &session->operation.op.find.n_objects);
      if (rc != YHR_SUCCESS) {
        DBG_ERR("Failed to get object list");
        rv = CKR_FUNCTION_FAILED;
        goto c_foi_out;
      }
      found_objects = session->operation.op.find.n_objects;
 
      if (pub) {
        for (uint16_t i = 0; i < session->operation.op.find.n_objects; i++) {
          if (session->operation.op.find.objects[i].type == YH_ASYMMETRIC_KEY) {
            session->operation.op.find.objects[i].type |= 0x80;
          }
        }
      }
    }
 
    if (ulCount == 0 ||
        should_include_sessionkeys(secret_key, extractable_set,
                                   session->operation.op.find.only_private,
                                   id)) {
      for (ListItem *item = session->ecdh_session_keys.head; item != NULL;
           item = item->next) {
        ecdh_session_key *key = (ecdh_session_key *) item->data;
 
        if (label == NULL || strcmp(label, key->label) == 0) {
 
          yh_object_descriptor desc;
          memset(&desc, 0, sizeof(desc));
          desc.id = key->id & 0xffff;
          desc.len = key->len;
          desc.type = ECDH_KEY_TYPE;
          memcpy(desc.label, key->label, strlen(key->label) + 1);
 
          // Add this item/key to the list of found objects
          memcpy(session->operation.op.find.objects + found_objects, &desc,
                 sizeof(yh_object_descriptor));
 
          found_objects++;
        }
      }
    }
 
    session->operation.op.find.n_objects = found_objects;
  }

Here is the call graph for this function:

if() [69/81]

if

(

unwrapping_key_type

= = ECDH_KEY_TYPE

)

Definition at line 4839 of file yubihsm_pkcs11.c.

                                            {
    DBG_ERR("Unwrapping using ECDH session key is not supported");
    rv = CKR_FUNCTION_NOT_SUPPORTED;
    goto c_uk_out;
  }

if() [70/81]

if

(

userType !

= CKU_USER

)

Definition at line 1092 of file yubihsm_pkcs11.c.

                            {
    DBG_ERR("Inalid user type, only regular user allowed");
    return CKR_USER_TYPE_INVALID;
  }

if() [71/81]

if

(

wrapped_key_type

= = ECDH_KEY_TYPE || wrapping_key_type == ECDH_KEY_TYPE

)

Definition at line 4711 of file yubihsm_pkcs11.c.

                                                                               {
    DBG_ERR("Wrapping involving ECDH session keys is not supported");
    rv = CKR_FUNCTION_NOT_SUPPORTED;
    goto c_wk_out;
  }

if() [72/81]

if

(

yh_check_capability &->., "-"

wrapped = = false

)

Definition at line 4756 of file yubihsm_pkcs11.c.

             {
    DBG_ERR("Wrap key does not have \"export-wrapped\" set");
    rv = CKR_WRAPPING_KEY_TYPE_INCONSISTENT; // TODO: say something better?
    goto c_wk_out;
  }

if() [73/81]

if

(

yh_check_capability &->., "--"

wrap = = false

)

Definition at line 4763 of file yubihsm_pkcs11.c.

                                                             {
    DBG_ERR("Key to be wrapped does not have \"exportable-under-wrap\" set");
    rv = CKR_KEY_UNEXTRACTABLE;
    goto c_wk_out;
  }

if() [74/81]

if

(

yh_connector_has_device(slot->connector)

= = true

)

Definition at line 542 of file yubihsm_pkcs11.c.

                                                        {
    pInfo->flags |= CKF_TOKEN_PRESENT;
  }

if() [75/81]

if

(

yh_is_rsa(object->object.algorithm)

)

Definition at line 3927 of file yubihsm_pkcs11.c.

                                           {
    if (is_PSS_sign_mechanism(session->operation.mechanism.mechanism)) {
      if (pMechanism->ulParameterLen != sizeof(CK_RSA_PKCS_PSS_PARAMS)) {
        DBG_ERR("Length of mechanism parameters does not match expected value, "
                "%lu != %zu",
                pMechanism->ulParameterLen, sizeof(CK_RSA_PKCS_PSS_PARAMS));
        rv = CKR_MECHANISM_PARAM_INVALID;
        goto c_vi_out;
      }
 
      // TODO: validate that params->hashAlg matches mechanism
      CK_RSA_PKCS_PSS_PARAMS *params = pMechanism->pParameter;
 
      session->operation.op.verify.padding = RSA_PKCS1_PSS_PADDING;
      session->operation.op.verify.saltLen = params->sLen;
      switch (params->mgf) {
        case CKG_MGF1_SHA1:
          session->operation.op.verify.mgf1md = EVP_sha1();
          break;
        case CKG_MGF1_SHA256:
          session->operation.op.verify.mgf1md = EVP_sha256();
          break;
        case CKG_MGF1_SHA384:
          session->operation.op.verify.mgf1md = EVP_sha384();
          break;
        case CKG_MGF1_SHA512:
          session->operation.op.verify.mgf1md = EVP_sha512();
          break;
        default:
          DBG_ERR("Unsupported mgf algorithm: %lu", params->mgf);
          rv = CKR_MECHANISM_PARAM_INVALID;
          goto c_vi_out;
      }
      switch (params->hashAlg) {
        case CKM_SHA_1:
          session->operation.op.verify.md = EVP_sha1();
          break;
        case CKM_SHA256:
          session->operation.op.verify.md = EVP_sha256();
          break;
        case CKM_SHA384:
          session->operation.op.verify.md = EVP_sha384();
          break;
        case CKM_SHA512:
          session->operation.op.verify.md = EVP_sha512();
          break;
        default:
          DBG_ERR("Unsupported pss hash algorithm: %lu", params->hashAlg);
          rv = CKR_MECHANISM_PARAM_INVALID;
          goto c_vi_out;
      }
    } else if (is_PKCS1v1_5_sign_mechanism(
                 session->operation.mechanism.mechanism)) {
      session->operation.op.verify.padding = RSA_PKCS1_PADDING;
    }
  }

Here is the call graph for this function:

if() [76/81]

if

(

yh_is_rsa(template.algorithm)

)

Definition at line 4607 of file yubihsm_pkcs11.c.

                                     {
 
    if (template.sign == ATTRIBUTE_TRUE) {
      rc = yh_string_to_capabilities("sign-pkcs,sign-pss", &capabilities);
      if (rc != YHR_SUCCESS) {
        rv = CKR_FUNCTION_FAILED;
        goto c_gkp_out;
      }
    }
 
    if (template.decrypt == ATTRIBUTE_TRUE) {
      rc =
        yh_string_to_capabilities("decrypt-pkcs,decrypt-oaep", &capabilities);
      if (rc != YHR_SUCCESS) {
        rv = CKR_FUNCTION_FAILED;
        goto c_gkp_out;
      }
    }
 
    rc = yh_util_generate_rsa_key(session->slot->device_session, &template.id,
                                  template.label, 0xffff, &capabilities,
                                  template.algorithm);
    if (rc != YHR_SUCCESS) {
      DBG_ERR("Failed writing RSA key to device");
      rv = CKR_FUNCTION_FAILED;
      goto c_gkp_out;
    }
  } else {

Here is the call graph for this function:

if() [77/81]

if

(

yh_util_delete_object(session->slot->device_session, object->object.id, object->object.type) !

= YHR_SUCCESS

)

Definition at line 1632 of file yubihsm_pkcs11.c.

                                                                   {
      DBG_ERR("Failed deleting object");
      rv = CKR_FUNCTION_FAILED;
      goto c_do_out;
    }

if() [78/81]

if

(

yh_util_get_object_info(session->slot->device_session, target_id, target_type, &object) !

= YHR_SUCCESS

)

Definition at line 4879 of file yubihsm_pkcs11.c.

                                                                    {
    rv = CKR_FUNCTION_FAILED;
    goto c_uk_out;
  }

if() [79/81]

if

(

yh_util_get_object_info(session->slot->device_session, template.id, type, &object) !

= YHR_SUCCESS

)

Definition at line 1545 of file yubihsm_pkcs11.c.

                                                       {
    DBG_ERR("Failed executing get object info after creating");
    rv = CKR_FUNCTION_FAILED;
    goto c_co_out;
  }

if() [80/81]

if

(

yh_util_get_object_info(session->slot->device_session, template.id, YH_ASYMMETRIC_KEY, &object) !

= YHR_SUCCESS

)

Definition at line 4664 of file yubihsm_pkcs11.c.

                                                                          {
    rv = CKR_FUNCTION_FAILED;
    goto c_gkp_out;
  }

if() [81/81]

if

(

yrc !

= YHR_SUCCESS

)

Definition at line 615 of file yubihsm_pkcs11.c.

                          {
    DBG_ERR("Unable to get device version and serial number: %s",
            yh_strerror(yrc));
    rv = CKR_DEVICE_ERROR;
    goto c_gt_out;
  }

Here is the call graph for this function:

insecure_memzero()

insecure_memzero	(	ecdh_key.	ecdh_key,
		out_len	)

memcpy() [1/4]

memcpy	(	(char *) pInfo->slotDescription+	l,
		s	,
		strlen(s)	)

memcpy() [2/4]

memcpy	(	(char *) pInfo->	slotDescription,
		s	,
		l	)

memcpy() [3/4]

memcpy	(	ecdh_key.	label,
		label_buf	,
		label_len	)

memcpy() [4/4]

memcpy	(	pWrappedKey	,
		buf	,
		len	)

memset() [1/3]

memset	(	pInfo->	manufacturerID,
		' '	,
		32	)

memset() [2/3]

memset	(	pInfo->	model,
		' '	,
		16	)

memset() [3/3]

memset	(	pInfo->	slotDescription,
		' '	,
		64	)

session()

list_append & session

(

void *

)

&

sizeof()

c_gkp_out sizeof

(

template

)

switch()

switch

(

session->

session_state

)

Definition at line 982 of file yubihsm_pkcs11.c.

                                  {
    case SESSION_RESERVED_RO:
      pInfo->state = CKS_RO_PUBLIC_SESSION;
      break;
 
    case SESSION_RESERVED_RW:
      pInfo->state = CKS_RW_PUBLIC_SESSION;
      pInfo->flags |= CKF_RW_SESSION;
      break;
 
    case SESSION_AUTHENTICATED_RO:
      pInfo->state = CKS_RO_USER_FUNCTIONS;
      break;
 
    case SESSION_AUTHENTICATED_RW:
      pInfo->state = CKS_RW_USER_FUNCTIONS;
      pInfo->flags |= CKF_RW_SESSION;
      break;
 
    default:
      DBG_ERR("Unknown session %lu", hSession);
      rv = CKR_SESSION_HANDLE_INVALID;
  }

template() [1/2]

memset & template

(

template

)

template() [2/2]

memset & template

(

yubihsm_pkcs11_object_template

)

UNUSED() [1/40]

UNUSED

(

flags

)

UNUSED() [2/40]

UNUSED

(

hAuthenticationKey

)

UNUSED() [3/40]

UNUSED

(

hEncryptionKey

)

UNUSED() [4/40]

UNUSED

(

hKey

)

UNUSED() [5/40]

UNUSED

(

hObject

)

UNUSED() [6/40]

UNUSED

(

hSession

)

UNUSED() [7/40]

UNUSED

(

Notify

)

UNUSED() [8/40]

UNUSED

(

pApplication

)

UNUSED() [9/40]

UNUSED

(

pData

)

UNUSED() [10/40]

UNUSED

(

pEncryptedPart

)

UNUSED() [11/40]

UNUSED

(

phNewObject

)

UNUSED() [12/40]

UNUSED

(

pLabel

)

UNUSED() [13/40]

UNUSED

(

pMechanism

)

UNUSED() [14/40]

UNUSED

(

pNewPin

)

UNUSED() [15/40]

UNUSED

(

pOldPin

)

UNUSED() [16/40]

UNUSED

(

pOperationState

)

UNUSED() [17/40]

UNUSED

(

pPart

)

UNUSED() [18/40]

UNUSED

(

pPin

)

UNUSED() [19/40]

UNUSED

(

pReserved

)

UNUSED() [20/40]

UNUSED

(

pSeed

)

UNUSED() [21/40]

UNUSED

(

pSignature

)

UNUSED() [22/40]

UNUSED

(

pSlot

)

UNUSED() [23/40]

UNUSED

(

pTemplate

)

UNUSED() [24/40]

UNUSED

(

pulDataLen

)

UNUSED() [25/40]

UNUSED

(

pulEncryptedPartLen

)

UNUSED() [26/40]

UNUSED

(

pulOperationStateLen

)

UNUSED() [27/40]

UNUSED

(

pulPartLen

)

UNUSED() [28/40]

UNUSED

(

pulSignatureLen

)

UNUSED() [29/40]

UNUSED

(

slotID

)

UNUSED() [30/40]

UNUSED

(

ulAttributeCount

)

UNUSED() [31/40]

UNUSED

(

ulCount

)

UNUSED() [32/40]

UNUSED

(

ulDataLen

)

UNUSED() [33/40]

UNUSED

(

ulEncryptedPartLen

)

UNUSED() [34/40]

UNUSED

(

ulNewLen

)

UNUSED() [35/40]

UNUSED

(

ulOldLen

)

UNUSED() [36/40]

UNUSED

(

ulOperationStateLen

)

UNUSED() [37/40]

UNUSED

(

ulPartLen

)

UNUSED() [38/40]

UNUSED

(

ulPinLen

)

UNUSED() [39/40]

UNUSED

(

ulSeedLen

)

UNUSED() [40/40]

UNUSED

(

ulSignatureLen

)

yh_get_connector_address()

yh_get_connector_address	(	slot->	connector,
		&	s )

yh_get_connector_version()

yh_get_connector_version	(	slot->	connector,
		&	major,
		&	minor,
		&	patch )

Variable Documentation

__pad0__

c_gt_out __pad0__

Definition at line 665 of file yubihsm_pkcs11.c.

__pad10__

c_ei_out __pad10__

Definition at line 2388 of file yubihsm_pkcs11.c.

__pad11__

c_e_out __pad11__

Definition at line 2471 of file yubihsm_pkcs11.c.

__pad12__

c_eu_out __pad12__

Definition at line 2527 of file yubihsm_pkcs11.c.

__pad13__

c_ef_out __pad13__

Definition at line 2609 of file yubihsm_pkcs11.c.

__pad14__

c_di_out __pad14__

Definition at line 2799 of file yubihsm_pkcs11.c.

__pad15__

c_d_out __pad15__

Definition at line 2913 of file yubihsm_pkcs11.c.

__pad16__

c_du_out __pad16__

Definition at line 2978 of file yubihsm_pkcs11.c.

__pad17__

c_df_out __pad17__

Definition at line 3071 of file yubihsm_pkcs11.c.

__pad18__

c_di_out __pad18__

Definition at line 3138 of file yubihsm_pkcs11.c.

__pad19__

c_d_out __pad19__

Definition at line 3238 of file yubihsm_pkcs11.c.

__pad1__

c_gml_out __pad1__

Definition at line 722 of file yubihsm_pkcs11.c.

__pad20__

c_du_out __pad20__

Definition at line 3298 of file yubihsm_pkcs11.c.

__pad21__

c_df_out __pad21__

Definition at line 3404 of file yubihsm_pkcs11.c.

__pad22__

c_si_out __pad22__

Definition at line 3584 of file yubihsm_pkcs11.c.

__pad23__

c_s_out __pad23__

Definition at line 3672 of file yubihsm_pkcs11.c.

__pad24__

c_su_out __pad24__

Definition at line 3730 of file yubihsm_pkcs11.c.

__pad25__

c_sf_out __pad25__

Definition at line 3798 of file yubihsm_pkcs11.c.

__pad26__

c_vi_out __pad26__

Definition at line 3988 of file yubihsm_pkcs11.c.

__pad27__

c_v_out __pad27__

Definition at line 4094 of file yubihsm_pkcs11.c.

__pad28__

c_vu_out __pad28__

Definition at line 4150 of file yubihsm_pkcs11.c.

__pad29__

c_vf_out __pad29__

Definition at line 4210 of file yubihsm_pkcs11.c.

__pad2__

c_os_out __pad2__

Definition at line 861 of file yubihsm_pkcs11.c.

__pad30__

c_gk_out __pad30__

Definition at line 4528 of file yubihsm_pkcs11.c.

__pad31__

c_gkp_out __pad31__

Definition at line 4674 of file yubihsm_pkcs11.c.

__pad32__

c_wk_out __pad32__

Definition at line 4794 of file yubihsm_pkcs11.c.

__pad33__

c_uk_out __pad33__

Definition at line 4890 of file yubihsm_pkcs11.c.

__pad34__

c_drv_out __pad34__

Definition at line 5028 of file yubihsm_pkcs11.c.

__pad35__

c_gr_out __pad35__

Definition at line 5094 of file yubihsm_pkcs11.c.

__pad3__

c_l_out __pad3__

Definition at line 1153 of file yubihsm_pkcs11.c.

__pad4__

c_co_out __pad4__

Definition at line 1557 of file yubihsm_pkcs11.c.

__pad5__

c_do_out __pad5__

Definition at line 1645 of file yubihsm_pkcs11.c.

__pad6__

c_gav_out __pad6__

Definition at line 1775 of file yubihsm_pkcs11.c.

__pad7__

c_sav_out __pad7__

Definition at line 1856 of file yubihsm_pkcs11.c.

__pad8__

c_foi_out __pad8__

Definition at line 2182 of file yubihsm_pkcs11.c.

__pad9__

c_fo_out __pad9__

Definition at line 2274 of file yubihsm_pkcs11.c.

algorithm

yh_algorithm algorithm = 0

Definition at line 1929 of file yubihsm_pkcs11.c.

basekey_type

int basekey_type = hBaseKey >> 16

Definition at line 4930 of file yubihsm_pkcs11.c.

buf

uint8_t buf[2048]

Definition at line 4770 of file yubihsm_pkcs11.c.

buffer_length

session operation buffer_length = 0

Definition at line 2384 of file yubihsm_pkcs11.c.

c_co_out

goto c_co_out

Definition at line 1541 of file yubihsm_pkcs11.c.

c_d_out

goto c_d_out

Definition at line 2858 of file yubihsm_pkcs11.c.

c_df_out

goto c_df_out

Definition at line 3037 of file yubihsm_pkcs11.c.

c_di_out

goto c_di_out

Definition at line 2781 of file yubihsm_pkcs11.c.

c_drv_out

goto c_drv_out

Definition at line 4975 of file yubihsm_pkcs11.c.

c_e_out

goto c_e_out

Definition at line 2448 of file yubihsm_pkcs11.c.

c_ef_out

goto c_ef_out

Definition at line 2574 of file yubihsm_pkcs11.c.

c_gk_out

goto c_gk_out

Definition at line 4512 of file yubihsm_pkcs11.c.

c_gkp_out

goto c_gkp_out

Definition at line 4586 of file yubihsm_pkcs11.c.

c_s_out

goto c_s_out

Definition at line 3640 of file yubihsm_pkcs11.c.

c_si_out

goto c_si_out

Definition at line 3565 of file yubihsm_pkcs11.c.

c_v_out

goto c_v_out

Definition at line 4060 of file yubihsm_pkcs11.c.

c_vi_out

goto c_vi_out

Definition at line 3916 of file yubihsm_pkcs11.c.

capabilities

yh_capabilities capabilities = {{0}}

Definition at line 1305 of file yubihsm_pkcs11.c.

{{0}};

CKR_FUNCTION_NOT_PARALLEL

return CKR_FUNCTION_NOT_PARALLEL

Definition at line 5111 of file yubihsm_pkcs11.c.

CKR_FUNCTION_NOT_SUPPORTED

return CKR_FUNCTION_NOT_SUPPORTED

Definition at line 682 of file yubihsm_pkcs11.c.

CKR_OK

return CKR_OK

Definition at line 417 of file yubihsm_pkcs11.c.

CKR_RANDOM_SEED_NOT_SUPPORTED

return CKR_RANDOM_SEED_NOT_SUPPORTED

Definition at line 5047 of file yubihsm_pkcs11.c.

[struct]

struct { ... } class

current_object

session operation op find current_object = 0

Definition at line 2178 of file yubihsm_pkcs11.c.

d

CK_ULONG d

Definition at line 1238 of file yubihsm_pkcs11.c.

datalen

CK_ULONG datalen = YH_CCM_WRAP_OVERHEAD + ulDataLen

Definition at line 2428 of file yubihsm_pkcs11.c.

delegated_capabilities

yh_capabilities delegated_capabilities = {{0}}

Definition at line 1306 of file yubihsm_pkcs11.c.

{{0}};

digest_len

session operation op digest digest_len = digest_length

Definition at line 3126 of file yubihsm_pkcs11.c.

digest_length

digest_length = get_digest_bytelength(pMechanism->mechanism)

Definition at line 3123 of file yubihsm_pkcs11.c.

DIN

DIN

Definition at line 407 of file yubihsm_pkcs11.c.

domains

uint16_t domains = 0

Definition at line 1926 of file yubihsm_pkcs11.c.

DOUT

DOUT

Definition at line 416 of file yubihsm_pkcs11.c.

ecdh_key

ecdh_session_key ecdh_key

Definition at line 4998 of file yubihsm_pkcs11.c.

else

else

Initial value:

{
    DOUT

Definition at line 755 of file yubihsm_pkcs11.c.

expected_key_length

size_t expected_key_length = 0

Definition at line 4939 of file yubihsm_pkcs11.c.

extractable_set

bool extractable_set = false

Definition at line 1932 of file yubihsm_pkcs11.c.

firmwareVersion

pInfo firmwareVersion = ver

Definition at line 661 of file yubihsm_pkcs11.c.

flags

pInfo flags = CKF_REMOVABLE_DEVICE | CKF_HW_SLOT

Definition at line 540 of file yubihsm_pkcs11.c.

full

bool full = false

Definition at line 466 of file yubihsm_pkcs11.c.

function_list

CK_FUNCTION_LIST function_list

Definition at line 5124 of file yubihsm_pkcs11.c.

                                 {
  {CRYPTOKI_VERSION_MAJOR, CRYPTOKI_VERSION_MINOR},
  C_Initialize,
  C_Finalize,
  C_GetInfo,
  C_GetFunctionList,
  C_GetSlotList,
  C_GetSlotInfo,
  C_GetTokenInfo,
  C_GetMechanismList,
  C_GetMechanismInfo,
  C_InitToken,
  C_InitPIN,
  C_SetPIN,
  C_OpenSession,
  C_CloseSession,
  C_CloseAllSessions,
  C_GetSessionInfo,
  C_GetOperationState,
  C_SetOperationState,
  C_Login,
  C_Logout,
  C_CreateObject,
  C_CopyObject,
  C_DestroyObject,
  C_GetObjectSize,
  C_GetAttributeValue,
  C_SetAttributeValue,
  C_FindObjectsInit,
  C_FindObjects,
  C_FindObjectsFinal,
  C_EncryptInit,
  C_Encrypt,
  C_EncryptUpdate,
  C_EncryptFinal,
  C_DecryptInit,
  C_Decrypt,
  C_DecryptUpdate,
  C_DecryptFinal,
  C_DigestInit,
  C_Digest,
  C_DigestUpdate,
  C_DigestKey,
  C_DigestFinal,
  C_SignInit,
  C_Sign,
  C_SignUpdate,
  C_SignFinal,
  C_SignRecoverInit,
  C_SignRecover,
  C_VerifyInit,
  C_Verify,
  C_VerifyUpdate,
  C_VerifyFinal,
  C_VerifyRecoverInit,
  C_VerifyRecover,
  C_DigestEncryptUpdate,
  C_DecryptDigestUpdate,
  C_SignEncryptUpdate,
  C_DecryptVerifyUpdate,
  C_GenerateKey,
  C_GenerateKeyPair,
  C_WrapKey,
  C_UnwrapKey,
  C_DeriveKey,
  C_SeedRandom,
  C_GenerateRandom,
  C_GetFunctionStatus,
  C_CancelFunction,
  C_WaitForSlotEvent,
};

GLOBAL_LOCK_OR_RETURN

GLOBAL_LOCK_OR_RETURN

Definition at line 437 of file yubihsm_pkcs11.c.

GLOBAL_UNLOCK_OR_RETURN

GLOBAL_UNLOCK_OR_RETURN

Definition at line 497 of file yubihsm_pkcs11.c.

hardwareVersion

pInfo hardwareVersion = ver

Definition at line 659 of file yubihsm_pkcs11.c.

hAuthenticationKey

CK_SESSION_HANDLE CK_BYTE_PTR CK_ULONG CK_OBJECT_HANDLE CK_OBJECT_HANDLE hAuthenticationKey

Initial value:

{
 
  DIN

Definition at line 1035 of file yubihsm_pkcs11.c.

hBaseKey

CK_SESSION_HANDLE CK_MECHANISM_PTR CK_OBJECT_HANDLE hBaseKey

Definition at line 4899 of file yubihsm_pkcs11.c.

hEncryptionKey

CK_SESSION_HANDLE CK_BYTE_PTR CK_ULONG CK_OBJECT_HANDLE hEncryptionKey

Definition at line 1034 of file yubihsm_pkcs11.c.

hKey

CK_SESSION_HANDLE CK_MECHANISM_PTR CK_OBJECT_HANDLE CK_OBJECT_HANDLE hKey

Initial value:

{
 
  DIN

Definition at line 2320 of file yubihsm_pkcs11.c.

hObject

CK_SESSION_HANDLE CK_OBJECT_HANDLE hObject

Initial value:

{
 
  DIN

Definition at line 1565 of file yubihsm_pkcs11.c.

hSession

CK_SESSION_HANDLE hSession

Initial value:

{
 
  DIN

Definition at line 780 of file yubihsm_pkcs11.c.

hUnwrappingKey

CK_SESSION_HANDLE CK_MECHANISM_PTR CK_OBJECT_HANDLE hUnwrappingKey

Definition at line 4803 of file yubihsm_pkcs11.c.

hWrappingKey

CK_SESSION_HANDLE CK_MECHANISM_PTR CK_OBJECT_HANDLE hWrappingKey

Definition at line 4685 of file yubihsm_pkcs11.c.

id

ecdh_key id = id.d

Definition at line 1304 of file yubihsm_pkcs11.c.

in_len

size_t in_len = params->ulPublicDataLen

Definition at line 4978 of file yubihsm_pkcs11.c.

is_multipart

session operation op digest is_multipart = true

Definition at line 3294 of file yubihsm_pkcs11.c.

j

uint16_t j = 0

Definition at line 465 of file yubihsm_pkcs11.c.

key

yubihsm_pkcs11_object_desc* key

Initial value:

=
    get_object_desc(session->slot->device_session, session->slot->objects,
                    hWrappingKey)

Definition at line 4747 of file yubihsm_pkcs11.c.

key_id

session operation op verify key_id = ntohs(key_id)

Definition at line 1104 of file yubihsm_pkcs11.c.

key_len

session operation op verify key_len = key_length

Definition at line 3475 of file yubihsm_pkcs11.c.

key_length

size_t key_length

Definition at line 3467 of file yubihsm_pkcs11.c.

[struct]

struct { ... } key_type

l

int l = strlen(s)

Definition at line 525 of file yubihsm_pkcs11.c.

label

label = NULL

Definition at line 1883 of file yubihsm_pkcs11.c.

label_buf

char* label_buf = NULL

Definition at line 4937 of file yubihsm_pkcs11.c.

label_len

size_t label_len = 0

Definition at line 4938 of file yubihsm_pkcs11.c.

len

size_t len = sizeof(buf)

Definition at line 4771 of file yubihsm_pkcs11.c.

major

uint8_t major = major

Definition at line 546 of file yubihsm_pkcs11.c.

mdctx

EVP_MD_CTX* mdctx = NULL

Definition at line 2628 of file yubihsm_pkcs11.c.

mechanism

session operation mechanism mechanism = pMechanism->mechanism

Definition at line 2374 of file yubihsm_pkcs11.c.

minor

uint8_t minor = (minor * 100) + patch

Definition at line 547 of file yubihsm_pkcs11.c.

n_objects

session operation op find n_objects = 0

Definition at line 1909 of file yubihsm_pkcs11.c.

Notify

CK_SLOT_ID CK_FLAGS CK_VOID_PTR CK_NOTIFY Notify

Definition at line 809 of file yubihsm_pkcs11.c.

object

yh_object_descriptor object

Initial value:

=
    get_object_desc(session->slot->device_session, session->slot->objects,
                    hObject)

Definition at line 1544 of file yubihsm_pkcs11.c.

only_private

session operation op find only_private = false

Definition at line 1908 of file yubihsm_pkcs11.c.

out_len

size_t out_len = sizeof(ecdh_key.ecdh_key)

Definition at line 5000 of file yubihsm_pkcs11.c.

overflow

bool overflow = false

Definition at line 467 of file yubihsm_pkcs11.c.

pApplication

CK_SLOT_ID CK_FLAGS CK_VOID_PTR pApplication

Definition at line 809 of file yubihsm_pkcs11.c.

params

CK_ECDH1_DERIVE_PARAMS* params = pMechanism->pParameter

Definition at line 4963 of file yubihsm_pkcs11.c.

patch

uint8_t patch

Definition at line 548 of file yubihsm_pkcs11.c.

pData

CK_SESSION_HANDLE CK_BYTE_PTR CK_ULONG CK_BYTE_PTR pData

Definition at line 2394 of file yubihsm_pkcs11.c.

pDigest

CK_SESSION_HANDLE CK_BYTE_PTR pDigest

Definition at line 3147 of file yubihsm_pkcs11.c.

pEncryptedData

CK_SESSION_HANDLE CK_BYTE_PTR pEncryptedData

Definition at line 2395 of file yubihsm_pkcs11.c.

pEncryptedPart

CK_SESSION_HANDLE CK_BYTE_PTR pEncryptedPart

Definition at line 2483 of file yubihsm_pkcs11.c.

phKey

* phKey

Initial value:

{
 
  DIN

Definition at line 4316 of file yubihsm_pkcs11.c.

phNewObject

CK_SESSION_HANDLE CK_OBJECT_HANDLE CK_ATTRIBUTE_PTR CK_ULONG CK_OBJECT_HANDLE_PTR phNewObject

Initial value:

{
 
  DIN

Definition at line 1567 of file yubihsm_pkcs11.c.

phObject

CK_SESSION_HANDLE CK_OBJECT_HANDLE_PTR phObject

Initial value:

{
 
  DIN

Definition at line 1205 of file yubihsm_pkcs11.c.

phPrivateKey

* phPrivateKey

Initial value:

{
 
  DIN

Definition at line 4539 of file yubihsm_pkcs11.c.

phPublicKey

* phPublicKey = object.sequence << 24 | (object.type | 0x80) << 16 | object.id

Definition at line 4539 of file yubihsm_pkcs11.c.

phSession

CK_SLOT_ID CK_FLAGS CK_VOID_PTR CK_NOTIFY CK_SESSION_HANDLE_PTR phSession

Initial value:

{
 
  DIN

Definition at line 810 of file yubihsm_pkcs11.c.

pInfo

CK_SESSION_HANDLE CK_SESSION_INFO_PTR pInfo

Initial value:

{
 
  DIN

Definition at line 504 of file yubihsm_pkcs11.c.

pLabel

CK_SLOT_ID CK_UTF8CHAR_PTR CK_ULONG CK_UTF8CHAR_PTR pLabel

Initial value:

{
 
  DIN

Definition at line 766 of file yubihsm_pkcs11.c.

pLastEncryptedPart

CK_SESSION_HANDLE CK_BYTE_PTR pLastEncryptedPart

Definition at line 2540 of file yubihsm_pkcs11.c.

pLastPart

CK_SESSION_HANDLE CK_BYTE_PTR pLastPart

Definition at line 2991 of file yubihsm_pkcs11.c.

pMechanism

CK_SESSION_HANDLE CK_MECHANISM_PTR pMechanism

Initial value:

{
 
  DIN

Definition at line 2319 of file yubihsm_pkcs11.c.

pMechanismList

CK_SLOT_ID CK_MECHANISM_TYPE_PTR pMechanismList

Definition at line 686 of file yubihsm_pkcs11.c.

pNewPin

CK_SESSION_HANDLE CK_UTF8CHAR_PTR CK_ULONG CK_UTF8CHAR_PTR pNewPin

Definition at line 794 of file yubihsm_pkcs11.c.

pOldPin

CK_SESSION_HANDLE CK_UTF8CHAR_PTR pOldPin

Definition at line 793 of file yubihsm_pkcs11.c.

pOperationState

CK_SESSION_HANDLE CK_BYTE_PTR pOperationState

Definition at line 1019 of file yubihsm_pkcs11.c.

pPart

CK_SESSION_HANDLE CK_BYTE_PTR CK_ULONG CK_BYTE_PTR pPart

Definition at line 2482 of file yubihsm_pkcs11.c.

ppFunctionList

* ppFunctionList

Initial value:

{
  yh_dbg_init(false, false, 0, "stderr")

Definition at line 404 of file yubihsm_pkcs11.c.

pPin

CK_SESSION_HANDLE CK_USER_TYPE CK_UTF8CHAR_PTR pPin = 4

Definition at line 765 of file yubihsm_pkcs11.c.

pPrivateKeyTemplate

CK_SESSION_HANDLE CK_MECHANISM_PTR CK_ATTRIBUTE_PTR CK_ULONG CK_ATTRIBUTE_PTR pPrivateKeyTemplate

Definition at line 4538 of file yubihsm_pkcs11.c.

pPublicKeyTemplate

CK_SESSION_HANDLE CK_MECHANISM_PTR CK_ATTRIBUTE_PTR pPublicKeyTemplate

Definition at line 4537 of file yubihsm_pkcs11.c.

pRandomData

CK_SESSION_HANDLE CK_BYTE_PTR pRandomData

Definition at line 5051 of file yubihsm_pkcs11.c.

pReserved

CK_FLAGS CK_SLOT_ID_PTR CK_VOID_PTR pReserved

Initial value:

{
 
  DIN

Definition at line 673 of file yubihsm_pkcs11.c.

privkey_id

uint16_t privkey_id = hBaseKey & 0xffff

Definition at line 4996 of file yubihsm_pkcs11.c.

pSeed

CK_SESSION_HANDLE CK_BYTE_PTR pSeed

Definition at line 5038 of file yubihsm_pkcs11.c.

pSignature

CK_SESSION_HANDLE CK_BYTE_PTR pSignature

Definition at line 3593 of file yubihsm_pkcs11.c.

pSlot

CK_FLAGS CK_SLOT_ID_PTR pSlot

Definition at line 673 of file yubihsm_pkcs11.c.

pSlotList

CK_BBOOL CK_SLOT_ID_PTR pSlotList

Definition at line 423 of file yubihsm_pkcs11.c.

pTemplate

CK_SESSION_HANDLE CK_MECHANISM_PTR CK_OBJECT_HANDLE CK_ATTRIBUTE_PTR pTemplate

Definition at line 1204 of file yubihsm_pkcs11.c.

pub

bool pub = false

Definition at line 1928 of file yubihsm_pkcs11.c.

pubkey

CK_BYTE_PTR pubkey = params->pPublicData

Definition at line 4984 of file yubihsm_pkcs11.c.

pulCount

CK_SLOT_ID CK_MECHANISM_TYPE_PTR CK_ULONG_PTR pulCount

Initial value:

{
 
  DIN

Definition at line 423 of file yubihsm_pkcs11.c.

pulDataLen

CK_SESSION_HANDLE CK_BYTE_PTR CK_ULONG CK_BYTE_PTR CK_ULONG_PTR pulDataLen

Initial value:

{
 
  DIN

Definition at line 2812 of file yubihsm_pkcs11.c.

pulDigestLen

* pulDigestLen

Initial value:

{
 
  DIN

Definition at line 3147 of file yubihsm_pkcs11.c.

pulEncryptedDataLen

* pulEncryptedDataLen

Initial value:

{
 
  DIN

Definition at line 2395 of file yubihsm_pkcs11.c.

pulEncryptedPartLen

CK_SESSION_HANDLE CK_BYTE_PTR CK_ULONG CK_BYTE_PTR CK_ULONG_PTR pulEncryptedPartLen

Initial value:

{
 
  DIN

Definition at line 2483 of file yubihsm_pkcs11.c.

pulLastEncryptedPartLen

* pulLastEncryptedPartLen

Initial value:

{
 
  DIN

Definition at line 2541 of file yubihsm_pkcs11.c.

pulLastPartLen

CK_SESSION_HANDLE CK_BYTE_PTR CK_ULONG_PTR pulLastPartLen

Initial value:

{
 
  DIN

Definition at line 2992 of file yubihsm_pkcs11.c.

pulObjectCount

* pulObjectCount

Initial value:

{
 
  DIN

Definition at line 2196 of file yubihsm_pkcs11.c.

pulOperationStateLen

CK_SESSION_HANDLE CK_BYTE_PTR CK_ULONG_PTR pulOperationStateLen

Initial value:

{
 
  DIN

Definition at line 1020 of file yubihsm_pkcs11.c.

pulPartLen

CK_SESSION_HANDLE CK_BYTE_PTR CK_ULONG CK_BYTE_PTR CK_ULONG_PTR pulPartLen

Initial value:

{
 
  DIN

Definition at line 2927 of file yubihsm_pkcs11.c.

pulSignatureLen

CK_SESSION_HANDLE CK_BYTE_PTR CK_ULONG CK_BYTE_PTR CK_ULONG_PTR pulSignatureLen

Initial value:

{
 
  DIN

Definition at line 3593 of file yubihsm_pkcs11.c.

pulSize

CK_SESSION_HANDLE CK_OBJECT_HANDLE CK_ULONG_PTR pulSize

Initial value:

{
 
  DIN

Definition at line 1653 of file yubihsm_pkcs11.c.

pulWrappedKeyLen

* pulWrappedKeyLen

Initial value:

{
 
  DIN

Definition at line 4686 of file yubihsm_pkcs11.c.

pWrappedKey

CK_SESSION_HANDLE CK_MECHANISM_PTR CK_OBJECT_HANDLE CK_BYTE_PTR pWrappedKey

Definition at line 4685 of file yubihsm_pkcs11.c.

rc

yh_rc rc

Definition at line 1308 of file yubihsm_pkcs11.c.

ret

CK_RV ret = get_session(&g_ctx, hSession, &session, 0)

Definition at line 973 of file yubihsm_pkcs11.c.

rv

return rv = CKR_OK

Definition at line 569 of file yubihsm_pkcs11.c.

s

char * s = "YubiHSM Connector "

Definition at line 524 of file yubihsm_pkcs11.c.

secret_key

bool secret_key = false

Definition at line 1931 of file yubihsm_pkcs11.c.

seq

int seq = session->ecdh_session_keys.length + 1

Definition at line 4986 of file yubihsm_pkcs11.c.

serial

uint32_t serial

Definition at line 611 of file yubihsm_pkcs11.c.

serialNumber

pInfo serialNumber[l] = ' '

Definition at line 629 of file yubihsm_pkcs11.c.

session

c_gr_out session = NULL

Definition at line 972 of file yubihsm_pkcs11.c.

set

bool set

Definition at line 1237 of file yubihsm_pkcs11.c.

siglen

CK_ULONG siglen

Definition at line 4029 of file yubihsm_pkcs11.c.

slot

c_os_out slot = get_slot(&g_ctx, slotID)

Definition at line 518 of file yubihsm_pkcs11.c.

slotID

pInfo slotID = session->slot->id

Definition at line 504 of file yubihsm_pkcs11.c.

target_id

uint16_t target_id

Definition at line 4867 of file yubihsm_pkcs11.c.

target_type

yh_object_type target_type

Definition at line 4868 of file yubihsm_pkcs11.c.

template

memset & template

Definition at line 1242 of file yubihsm_pkcs11.c.

terminate

bool terminate = true

Definition at line 2400 of file yubihsm_pkcs11.c.

tokenPresent

CK_BBOOL tokenPresent

Definition at line 423 of file yubihsm_pkcs11.c.

type

uint8_t type = hObject >> 16

Definition at line 730 of file yubihsm_pkcs11.c.

ulAttributeCount

CK_SESSION_HANDLE CK_MECHANISM_PTR CK_OBJECT_HANDLE CK_ATTRIBUTE_PTR CK_ULONG ulAttributeCount

Definition at line 4805 of file yubihsm_pkcs11.c.

ulCount

CK_SESSION_HANDLE CK_MECHANISM_PTR CK_ATTRIBUTE_PTR CK_ULONG ulCount

Initial value:

{
 
  DIN

Definition at line 1204 of file yubihsm_pkcs11.c.

ulDataLen

CK_SESSION_HANDLE CK_BYTE_PTR CK_ULONG ulDataLen

Definition at line 2394 of file yubihsm_pkcs11.c.

ulDeviceError

pInfo ulDeviceError = 0

Definition at line 1007 of file yubihsm_pkcs11.c.

ulEncryptedDataLen

CK_SESSION_HANDLE CK_BYTE_PTR CK_ULONG ulEncryptedDataLen

Definition at line 2812 of file yubihsm_pkcs11.c.

ulEncryptedPartLen

CK_SESSION_HANDLE CK_BYTE_PTR CK_ULONG ulEncryptedPartLen

Definition at line 2927 of file yubihsm_pkcs11.c.

ulFreePrivateMemory

pInfo ulFreePrivateMemory = CK_UNAVAILABLE_INFORMATION

Definition at line 655 of file yubihsm_pkcs11.c.

ulFreePublicMemory

pInfo ulFreePublicMemory = CK_UNAVAILABLE_INFORMATION

Definition at line 653 of file yubihsm_pkcs11.c.

ulMaxObjectCount

CK_SESSION_HANDLE CK_OBJECT_HANDLE_PTR CK_ULONG ulMaxObjectCount

Definition at line 2196 of file yubihsm_pkcs11.c.

ulMaxPinLen

pInfo ulMaxPinLen

Initial value:

=
    YUBIHSM_PKCS11_MAX_PIN_LEN

Definition at line 648 of file yubihsm_pkcs11.c.

ulMaxRwSessionCount

pInfo ulMaxRwSessionCount

Initial value:

=
    CK_EFFECTIVELY_INFINITE

Definition at line 641 of file yubihsm_pkcs11.c.

ulMaxSessionCount

pInfo ulMaxSessionCount

Initial value:

=
    CK_EFFECTIVELY_INFINITE

Definition at line 634 of file yubihsm_pkcs11.c.

ulMinPinLen

pInfo ulMinPinLen

Initial value:

=
    YUBIHSM_PKCS11_MIN_PIN_LEN

Definition at line 650 of file yubihsm_pkcs11.c.

ulNewLen

CK_SESSION_HANDLE CK_UTF8CHAR_PTR CK_ULONG CK_UTF8CHAR_PTR CK_ULONG ulNewLen

Initial value:

{
 
  DIN

Definition at line 794 of file yubihsm_pkcs11.c.

ulOldLen

CK_SESSION_HANDLE CK_UTF8CHAR_PTR CK_ULONG ulOldLen

Definition at line 793 of file yubihsm_pkcs11.c.

ulOperationStateLen

CK_SESSION_HANDLE CK_BYTE_PTR CK_ULONG ulOperationStateLen

Definition at line 1034 of file yubihsm_pkcs11.c.

ulPartLen

CK_SESSION_HANDLE CK_BYTE_PTR CK_ULONG ulPartLen

Initial value:

{
 
  DIN

Definition at line 2482 of file yubihsm_pkcs11.c.

ulPinLen

CK_SESSION_HANDLE CK_USER_TYPE CK_UTF8CHAR_PTR CK_ULONG ulPinLen

Initial value:

{
 
  DIN

Definition at line 765 of file yubihsm_pkcs11.c.

ulPrivateKeyAttributeCount

CK_SESSION_HANDLE CK_MECHANISM_PTR CK_ATTRIBUTE_PTR CK_ULONG CK_ATTRIBUTE_PTR CK_ULONG ulPrivateKeyAttributeCount

Definition at line 4538 of file yubihsm_pkcs11.c.

ulPublicKeyAttributeCount

CK_SESSION_HANDLE CK_MECHANISM_PTR CK_ATTRIBUTE_PTR CK_ULONG ulPublicKeyAttributeCount

Definition at line 4537 of file yubihsm_pkcs11.c.

ulRandomLen

CK_SESSION_HANDLE CK_BYTE_PTR CK_ULONG ulRandomLen

Initial value:

{
 
  DIN

Definition at line 5051 of file yubihsm_pkcs11.c.

ulRwSessionCount

pInfo ulRwSessionCount

Initial value:

=
    CK_UNAVAILABLE_INFORMATION

Definition at line 645 of file yubihsm_pkcs11.c.

ulSeedLen

CK_SESSION_HANDLE CK_BYTE_PTR CK_ULONG ulSeedLen

Initial value:

{
 
  DIN

Definition at line 5038 of file yubihsm_pkcs11.c.

ulSessionCount

pInfo ulSessionCount

Initial value:

=
    CK_UNAVAILABLE_INFORMATION

Definition at line 638 of file yubihsm_pkcs11.c.

ulSignatureLen

CK_SESSION_HANDLE CK_BYTE_PTR CK_ULONG ulSignatureLen

Initial value:

{
 
  DIN

Definition at line 3997 of file yubihsm_pkcs11.c.

ulTotalPrivateMemory

pInfo ulTotalPrivateMemory = CK_UNAVAILABLE_INFORMATION

Definition at line 654 of file yubihsm_pkcs11.c.

ulTotalPublicMemory

pInfo ulTotalPublicMemory = CK_UNAVAILABLE_INFORMATION

Definition at line 652 of file yubihsm_pkcs11.c.

ulWrappedKeyLen

CK_SESSION_HANDLE CK_MECHANISM_PTR CK_OBJECT_HANDLE CK_BYTE_PTR CK_ULONG ulWrappedKeyLen

Definition at line 4804 of file yubihsm_pkcs11.c.

unknown

bool unknown = false

Definition at line 1930 of file yubihsm_pkcs11.c.

unwrapping_key_type

int unwrapping_key_type = hUnwrappingKey >> 16

Definition at line 4838 of file yubihsm_pkcs11.c.

userType

CK_SESSION_HANDLE CK_USER_TYPE userType

Definition at line 1080 of file yubihsm_pkcs11.c.

ver

CK_VERSION ver = {major, (minor * 100) + patch}

Definition at line 657 of file yubihsm_pkcs11.c.

{major, (minor * 100) + patch};

wrapped_key_type

int wrapped_key_type = hKey >> 16

Definition at line 4709 of file yubihsm_pkcs11.c.

wrapping_key_type

int wrapping_key_type = hWrappingKey >> 16

Definition at line 4710 of file yubihsm_pkcs11.c.

yrc

yh_rc yrc

Initial value:

= yh_util_get_device_info(slot->connector, &major, &minor, &patch,
                                &serial, NULL, NULL, NULL, NULL)

Definition at line 606 of file yubihsm_pkcs11.c.