CK_RV C_CloseSession(CK_SESSION_HANDLE hSession)
{
P11_SESSION *pSession = NULL;
P11_SLOT *pSlot = NULL;
CK_RV ret;
log_trace(WHERE, "I: enter");
ret = p11_lock();
if (ret != CKR_OK)
{
log_trace(WHERE, "I: leave, p11_lock failed with %i",ret);
return ret;
}
log_trace(WHERE, "S: C_CloseSession (session %d)", hSession);
//get session, of pSession is found, regardless the ret value, we can clean it up
ret = p11_get_session(hSession, &pSession);
if (pSession == NULL)
{
log_trace(WHERE, "E: Invalid session handle (%d)", hSession);
goto cleanup;
}
//get slot, if not exist, we allow to close session anyway
pSlot = p11_get_slot(pSession->hslot);
if (pSlot == NULL)
{
log_trace(WHERE, "W: Invalid slot (%d) for session (%d)", pSession->hslot, hSession);
//ret = CKR_OK;
}
else
{
//
if (pSlot->nsessions > 0)
pSlot->nsessions--;
if ((pSlot->nsessions < 1) && (pSlot->login_type >= 0) )
{
//TODO what to do if no session longer exists?
// cal_logout(pSlot);
pSlot->login_type = -1;
}
//disconnect this session to device
ret = cal_disconnect(pSession->hslot);
}
//clear data so it can be reused
pSession->state = 0;
pSession->inuse = 0;
pSession->flags = 0;
pSession->hslot = 0;
pSession->pdNotify = NULL;
pSession->pfNotify = NULL;
cleanup:
p11_unlock();
log_trace(WHERE, "I: leave, ret = %i",ret);
return ret;
}
CK_RV p11_close_all_sessions(CK_SLOT_ID slotID)
{
int ret = 0;
unsigned int i = 0;
P11_SLOT *pSlot = NULL;
P11_SESSION *pSession = NULL;
pSlot = p11_get_slot(slotID);
if (pSlot == NULL)
{
log_trace(WHERE, "E: Invalid slot (%d)", slotID);
ret = CKR_SLOT_ID_INVALID;
goto cleanup;
}
if (pSlot->nsessions == 0)
{
ret = CKR_OK;
goto cleanup;
}
//walk through all sessions and clean the ones related to this slot
for (i=0; (i < nSessions) && (pSession = &gpSessions[i]) ;i++)
{
if ( (pSession->inuse) && (pSession->hslot == slotID) )
{
ret = p11_close_session(pSlot, pSession);
}
}
cleanup:
return (ret);
}
CK_RV p11_close_all_sessions(CK_SLOT_ID slotID)
{
int ret = 0;
unsigned int i = 0;
P11_SLOT *pSlot = NULL;
P11_SESSION *pSession = NULL;
pSlot = p11_get_slot(slotID);
if (pSlot == NULL)
{
log_trace(WHERE, "E: Invalid slot (%d)", slotID);
ret = CKR_SLOT_ID_INVALID;
goto cleanup;
}
if (pSlot->nsessions == 0)
{
ret = CKR_OK;
goto cleanup;
}
//walk through all sessions and clean the ones related to this slot
for (i=0; (i < nSessions) && (pSession = &gpSessions[i]) ; i++)
{
if ( (pSession->inuse) && (pSession->hslot == slotID) )
{
if (pSlot->nsessions > 0)
pSlot->nsessions--;
if ((pSlot->nsessions == 0) && (pSlot->login_type >= 0) )
{
cal_logout(slotID);
pSlot->login_type = -1;
}
//clear data so it can be reused
pSession->inuse = 0;
pSession->flags = 0;
pSession->hslot = 0;
pSession->pdNotify = NULL;
pSession->pfNotify = NULL;
pSession->state = 0;
}
}
cleanup:
return (ret);
}
CK_RV C_Logout(CK_SESSION_HANDLE hSession) /* the session's handle */
{
int ret = CKR_OK;
P11_SESSION *pSession = NULL;
P11_SLOT *pSlot = NULL;
log_trace(WHERE, "I: enter");
ret = p11_lock();
if (ret != CKR_OK)
{
log_trace(WHERE, "I: leave, p11_lock failed with %i",ret);
return ret;
}
log_trace(WHERE, "S: Logout (session %d)", hSession);
ret = p11_get_session(hSession, &pSession);
if (ret)
{
log_trace(WHERE, "E: Invalid session handle (%d)", hSession);
goto cleanup;
}
pSlot = p11_get_slot(pSession->hslot);
if (pSlot == NULL)
{
log_trace(WHERE, "E: Slot not found for session %d", hSession);
ret = CKR_SESSION_HANDLE_INVALID;
goto cleanup;
}
if (pSlot->login_type >= 0)
{
pSlot->login_type = -1;
//printf("We ask for cal_logout...\n");
ret = cal_logout(pSession->hslot);
//printf("We are done!\n");
}
else
ret = CKR_USER_NOT_LOGGED_IN;
/* TODO cleanup all active operations (see standard) */
/* TODO: invalidate all private objects */
/* TODO: destroy all private session objects (we only have private token objects and they are unreadable anyway) */
cleanup:
p11_unlock();
log_trace(WHERE, "I: leave, ret = %i",ret);
return ret;
}
CK_RV p11_close_sessions_finalize()
{
CK_RV r, ret;
P11_SESSION *pSession;
P11_SLOT *pSlot;
unsigned int i;
ret = CKR_OK;
for(i=0;i<nSessions; i++) {
if((pSession = &gpSessions[i])) {
if(pSession->inuse) {
pSlot = p11_get_slot(pSession->hslot);
// don't overwrite previous errors
if((r = p11_close_session(pSlot, pSession)) != CKR_OK) {
ret = r;
}
}
}
}
return ret;
}
CK_RV C_GetAttributeValue(CK_SESSION_HANDLE hSession, /* the session's handle */
CK_OBJECT_HANDLE hObject, /* the object's handle */
CK_ATTRIBUTE_PTR pTemplate, /* specifies attributes, gets values */
CK_ULONG ulCount) /* attributes in template */
{
/*
This function returns the values from the object.
Object is cached so objects are read only once and remain valid until new session is setup with token.
Objects are allready initialized (but not read) during connection with token.
*/
int status, ret = 0;
P11_SESSION *pSession = NULL;
P11_SLOT *pSlot = NULL;
P11_OBJECT *pObject = NULL;
unsigned int j = 0;
void *pValue = NULL;
CK_ULONG len = 0;
log_trace(WHERE, "I: enter");
if (p11_get_init() != BEIDP11_INITIALIZED)
{
log_trace(WHERE, "I: leave, CKR_CRYPTOKI_NOT_INITIALIZED");
return (CKR_CRYPTOKI_NOT_INITIALIZED);
}
ret = p11_lock();
if (ret != CKR_OK)
return ret;
log_trace(WHERE, "S: C_GetAttributeValue(hObject=%d)",hObject);
ret = p11_get_session(hSession, &pSession);
if (ret)
{
log_trace(WHERE, "E: Invalid session handle (%d)", hSession);
goto cleanup;
}
pSlot = p11_get_slot(pSession->hslot);
if (pSlot == NULL)
{
log_trace(WHERE, "E: p11_get_slot(%d) returns null", pSession->hslot);
ret = CKR_SLOT_ID_INVALID;
goto cleanup;
}
pObject = p11_get_slot_object(pSlot, hObject);
if (pObject == NULL)
{
log_trace(WHERE, "E: slot %d: object %d does not exist", pSession->hslot, hObject);
ret = CKR_OBJECT_HANDLE_INVALID;
goto cleanup;
}
//read object from token if not cached allready
if (pObject->state != P11_CACHED)
{
ret = cal_read_object(pSession->hslot, pObject);
if (ret != 0)
{
log_trace(WHERE, "E: p11_read_object() returned %d", ret);
goto cleanup;
}
}
/* if (pSlot->login_type < 0) //CKU_SO=0; CKU_USER=1
{
if (p11_get_attribute_value(pObject->pAttr, pObject->count, CKA_PRIVATE, (CK_VOID_PTR *) &pbPrivate, &len) != CKR_OK)
{
log_trace(WHERE, "E: missing CKA_PRIVATE attribute in our object: bad implementation");
continue;
}
if ( (len == sizeof(CK_BBOOL)) && (*pbPrivate == CK_TRUE) )
{
log_trace(WHERE, "E: Not allowed to retrieve private objects");
continue;
}
}*/
//retrieve all objects as listed in template and fill the template
//action is done for all attributes, even if some attributes give errors or buffer is too small
//there is however only one return code to return so we have to keep the most important return code.
for (j = 0; j < ulCount; j++)
{
status = p11_get_attribute_value(pObject->pAttr, pObject->count, pTemplate[j].type, (CK_VOID_PTR *) &pValue, &len);
if (status != CKR_OK)
{
log_template("E: C_GetAttributeValue status != CKR_OK", &pTemplate[j], 1);
log_trace(WHERE, "E: p11_get_attribute_value (object=%d) returned %s", hObject, log_map_error(status));
pTemplate[j].ulValueLen = (CK_ULONG) -1;
ret = status;
continue;
}
if (pTemplate[j].pValue == NULL)
{
/* in this case we return the real length of the value */
pTemplate[j].ulValueLen = len;
continue;
}
if (len > pTemplate[j].ulValueLen)
{
pTemplate[j].ulValueLen = (CK_ULONG) -1;
ret = CKR_BUFFER_TOO_SMALL;
continue;
}
pTemplate[j].ulValueLen = len;
memcpy(pTemplate[j].pValue, pValue, len);
}
if (ulCount != 0)
log_template("I: Template out:", pTemplate, ulCount);
cleanup:
p11_unlock();
return ret;
}
CK_RV C_FindObjects(CK_SESSION_HANDLE hSession, /* the session's handle */
CK_OBJECT_HANDLE_PTR phObject, /* receives object handle array */
CK_ULONG ulMaxObjectCount, /* max handles to be returned */
CK_ULONG_PTR pulObjectCount) /* actual number returned */
{
/*
this function finds handles to objects but does not actually reads them.
this function returns handles to objects that exist on the token.
PKCS15 defines existance of attributes that should be readable from token
*/
int ret = 0;
P11_SESSION *pSession = NULL;
P11_SLOT *pSlot = NULL;
P11_FIND_DATA *pData = NULL;
P11_OBJECT *pObject = NULL;
CK_BBOOL *pbToken = NULL;
void *p = NULL;
CK_ULONG *pclass = NULL;
int match = 0;
unsigned int h,j = 0;
CK_ULONG len = 0;
log_trace(WHERE, "I: enter");
if (p11_get_init() != BEIDP11_INITIALIZED)
{
log_trace(WHERE, "I: leave, CKR_CRYPTOKI_NOT_INITIALIZED");
return (CKR_CRYPTOKI_NOT_INITIALIZED);
}
ret = p11_lock();
if (ret != CKR_OK)
return ret;
log_trace(WHERE, "S: C_FindObjects(session %d)", hSession);
ret = p11_get_session(hSession, &pSession);
if (pSession == NULL || ret != CKR_OK)
// if (ret)
{
log_trace(WHERE, "E: Invalid session handle (%d)", hSession);
goto cleanup;
}
if (pSession->Operation[P11_OPERATION_FIND].active == 0)
{
log_trace(WHERE, "E: For this session no search operation is initiated");
ret = CKR_OPERATION_NOT_INITIALIZED;
goto cleanup;
}
//get search template
pData = (P11_FIND_DATA *) pSession->Operation[P11_OPERATION_FIND].pData;
if (pData == NULL)
{
log_trace(WHERE, "E: Session (%d): search data not initialized correctly", hSession);
ret = CKR_OPERATION_NOT_INITIALIZED;
goto cleanup;
}
/* VSC this code was moved to here since Sun-PKCS11 cannot handle CKR_Attribute_value_invalid in C_FindObjectsInit() properly!!! */
/* here we just return 0 objects in case of class type that is not supported */
ret = p11_get_attribute_value(pData->pSearch, pData->size, CKA_CLASS, (CK_VOID_PTR *) &pclass, &len);
if ( (ret == 0) && (len == sizeof(CK_ULONG) ) )
{
if ( (*pclass != CKO_CERTIFICATE) && (*pclass != CKO_PRIVATE_KEY) && (*pclass != CKO_PUBLIC_KEY) && (*pclass != CKO_DATA) )
{
ret = CKR_OK; //ret = CKR_ATTRIBUTE_VALUE_INVALID;
*pulObjectCount = 0;
goto cleanup;
}
}
//check if we have a TOKEN attribute to look for
//in case of null search template we search for all objects
//Firefox does not set TOKEN object for CKO_PRIVATE_KEY objects so for the moment we allow looking for them, id has to match anyway.
len = sizeof(CK_BBOOL);
if (pData->size > 0)
{
ret = p11_get_attribute_value(pData->pSearch, pData->size, CKA_TOKEN, (CK_VOID_PTR *) &pbToken, &len);
//if ((ret != CKR_OK) || ( (len == sizeof(CK_BBOOL) ) && (*pbToken == CK_FALSE) ) )
//for the moment if CKA_TOKEN is specified and set to false, we reply that only token objects can be searched for and continue with ok
if ((ret == CKR_OK) && (len == sizeof(CK_BBOOL)) && (*pbToken == CK_FALSE) )
{
log_trace(WHERE, "W: only token objects can be searched for");
*pulObjectCount = 0;
ret = CKR_OK;
goto cleanup;
}
}
pSlot = p11_get_slot(pSession->hslot);
if (pSlot == NULL)
{
log_trace(WHERE, "E: p11_get_slot(%d) returns null", pSession->hslot);
ret = CKR_SLOT_ID_INVALID;
goto cleanup;
}
*pulObjectCount = 0;
//for all objects in token, match with search template as long as we need, keep handle to current token object
for (h = pData->hCurrent; h <= (pSlot->nobjects) && (*pulObjectCount < ulMaxObjectCount); h++, pData->hCurrent++)
{
pObject = p11_get_slot_object(pSlot, h);
if (pObject == NULL)
{
log_trace(WHERE, "E: invalid object handle, call C_FindObjectsInit() first");
ret = CKR_OPERATION_NOT_INITIALIZED;
goto cleanup;
}
if (pObject->inuse == 0)
continue; //this object is not in use by the token()
//if not logged in, objects with missing CKA_PRIVATE or CKA_PRIVATE set to false will be ignored
#if 0 //TODO
if (pSlot->login_type < 0) //CKU_SO=0; CKU_USER=1
{
if (p11_get_attribute_value(pObject->pAttr, pObject->count, CKA_PRIVATE, (CK_VOID_PTR *) &pbPrivate, &len) != CKR_OK)
{
log_trace(WHERE, "E: missing CKA_PRIVATE attribute in our object: bad implementation");
continue;
}
if ( (len == sizeof(CK_BBOOL)) && (*pbPrivate == CK_TRUE) )
{
log_trace(WHERE, "E: Not allowed to retrieve private objects");
continue;
}
}
#endif
// Try to match every attribute
match = 1;
//if pData->size = 0 => this means that we will search for every object!!! match = 1 so for() is skipped and object is returned
for (j = 0; j < pData->size; j++)
{
//get the value of the attribute from the token object and compare with the search attribute
if (p11_get_attribute_value(pObject->pAttr, pObject->count, pData->pSearch[j].type, &p, &len) != CKR_OK)
{
match = 0;
break;
}
// printf("pData->pSearch[%d].ulValueLen=%d <> len=%d\n",j,pData->pSearch[j].ulValueLen,len);
if (pData->pSearch[j].ulValueLen != len)
{
match = 0;
break;
}
if (memcmp(pData->pSearch[j].pValue, p, len) != 0)
{
match = 0;
break;
}
}
if (match)
{
log_trace(WHERE, "I: Slot %d: Object %d matches", pSession->hslot, h);
//put handle to object in list
phObject[*pulObjectCount] = (CK_OBJECT_HANDLE) h;
*pulObjectCount +=1;
}
else
log_trace(WHERE, "I: Slot %d: Object %d no match with search template", pSession->hslot, h);
}
ret = CKR_OK;
cleanup:
p11_unlock();
return ret;
}
CK_RV C_SignInit(CK_SESSION_HANDLE hSession, /* the session's handle */
CK_MECHANISM_PTR pMechanism, /* the signature mechanism */
CK_OBJECT_HANDLE hKey) /* handle of the signature key */
{
CK_RV ret;
P11_SESSION *pSession = NULL;
P11_SLOT *pSlot = NULL;
P11_SIGN_DATA *pSignData = NULL;
P11_OBJECT *pObject = NULL;
CK_BBOOL *pcan_sign = NULL;
CK_KEY_TYPE *pkeytype = NULL;
CK_ULONG *pmodsize = NULL;
CK_ULONG *pid = NULL;
CK_ULONG *pclass = NULL;
CK_ULONG len = 0;
CK_MECHANISM_TYPE_PTR pMechanismsSupported = NULL;
CK_ULONG ulSupportedMechLen = 0;
CK_ULONG ulcounter = 0;
int ihash;
if (p11_get_init() != BEIDP11_INITIALIZED)
{
log_trace(WHERE, "I: leave, CKR_CRYPTOKI_NOT_INITIALIZED");
return (CKR_CRYPTOKI_NOT_INITIALIZED);
}
p11_lock();
log_trace(WHERE, "I: enter");
ret = p11_get_session(hSession, &pSession);
if (ret)
{
log_trace(WHERE, "E: Invalid session handle (%d)", hSession);
goto cleanup;
}
//is there an active sign operation for this session
if (pSession->Operation[P11_OPERATION_SIGN].active)
{
log_trace(WHERE, "W: Session %d: sign operation allready exists", hSession);
ret = CKR_OPERATION_ACTIVE;
goto cleanup;
}
pSlot = p11_get_slot(pSession->hslot);
if (pSlot == NULL)
{
log_trace(WHERE, "E: Slot not found for session %d", hSession);
ret = CKR_SESSION_HANDLE_INVALID;
goto cleanup;
}
if(!(pSlot->ulCardDataCached & CACHED_DATA_TYPE_CDF))
{
log_trace(WHERE, "E: Key handle but no CDF read yet!");
ret = CKR_KEY_HANDLE_INVALID;
goto cleanup;
}
#ifndef PKCS11_FF
ret = cal_init_objects(pSlot);
if(ret != CKR_OK)
{
log_trace(WHERE, "E: cal_init_objects() returns %s_", log_map_error(ret));
}
#endif
//check mechanism
//since this module is only for BEID, we check for RSA here and we do not check the device capabilities
//check mechanism table for signing depending on token in slot
//get number of mechanisms
ret = cal_get_mechanism_list(pSession->hslot, pMechanismsSupported, &ulSupportedMechLen);
if (ret != CKR_OK)
{
log_trace(WHERE, "E: cal_get_mechanism_list(slotid=%d) returns %s", pSession->hslot, log_map_error(ret));
goto cleanup;
}
//get the mechanisms list
pMechanismsSupported = (CK_MECHANISM_TYPE_PTR) malloc (sizeof(CK_MECHANISM_TYPE)*ulSupportedMechLen);
if(pMechanismsSupported != NULL)
{
ret = cal_get_mechanism_list(pSession->hslot, pMechanismsSupported, &ulSupportedMechLen);
if (ret != CKR_OK)
{
log_trace(WHERE, "E: cal_get_mechanism_list(slotid=%d) returns %s", pSession->hslot, log_map_error(ret));
free(pMechanismsSupported);
goto cleanup;
}
ret = CKR_MECHANISM_INVALID;
for(ulcounter = 0; ulcounter < ulSupportedMechLen ; ulcounter++)
{
if(pMechanismsSupported[ulcounter] == pMechanism->mechanism)
{
ret = CKR_OK;
break;
}
}
if(ret == CKR_MECHANISM_INVALID)
{
free(pMechanismsSupported);
goto cleanup;
}
free(pMechanismsSupported);
}
switch(pMechanism->mechanism)
{
case CKM_MD5_RSA_PKCS:
case CKM_SHA1_RSA_PKCS:
case CKM_RIPEMD160_RSA_PKCS:
case CKM_SHA256_RSA_PKCS:
case CKM_SHA384_RSA_PKCS:
case CKM_SHA512_RSA_PKCS:
case CKM_SHA1_RSA_PKCS_PSS:
case CKM_SHA256_RSA_PKCS_PSS:
case CKM_ECDSA_SHA256:
case CKM_ECDSA_SHA384:
case CKM_ECDSA_SHA512:
ihash = 1; break;
case CKM_RSA_PKCS:
case CKM_ECDSA:
ihash = 0; break;
default:
ret = CKR_MECHANISM_INVALID;
goto cleanup;
}
//can we use the object for signing?
pObject = p11_get_slot_object(pSlot, hKey);
if (pObject == NULL || pObject->count == 0)
{
log_trace(WHERE, "E: invalid key handle");
ret = CKR_KEY_HANDLE_INVALID;
goto cleanup;
}
//check class, keytype and sign attribute CKO_PRIV_KEY
/* CKR_KEY_TYPE_INCONSISTENT has higher rank than CKR_KEY_FUNCTION_NOT_PERMITTED */
ret = p11_get_attribute_value(pObject->pAttr, pObject->count, CKA_KEY_TYPE, (CK_VOID_PTR*) &pkeytype, &len);
if (ret || (len != sizeof(CK_KEY_TYPE)) || (*pkeytype != CKK_RSA))
{
log_trace(WHERE, "E: Wrong keytype");
ret = CKR_KEY_TYPE_INCONSISTENT;
goto cleanup;
}
ret = p11_get_attribute_value(pObject->pAttr, pObject->count, CKA_CLASS, (CK_VOID_PTR*) &pclass, &len);
if (ret || (len != sizeof(CK_ULONG)) || (*pclass != CKO_PRIVATE_KEY))
{
log_trace(WHERE, "E: Key is not CKO_PRIVATE_KEY");
ret = CKR_KEY_FUNCTION_NOT_PERMITTED;
goto cleanup;
}
ret = p11_get_attribute_value(pObject->pAttr, pObject->count, CKA_SIGN, (CK_VOID_PTR*) &pcan_sign, &len);
if (ret || (len != sizeof(CK_BBOOL)) || (*pcan_sign != CK_TRUE))
{
log_trace(WHERE, "E: Key cannot be used for signing");
ret = CKR_KEY_FUNCTION_NOT_PERMITTED;
goto cleanup;
}
ret = p11_get_attribute_value(pObject->pAttr, pObject->count, CKA_MODULUS_BITS, (CK_VOID_PTR*) &pmodsize, &len);
if (ret || (len != sizeof(CK_ULONG)) )
{
log_trace(WHERE, "E: Lengh not defined for modulus bits for private key");
ret = CKR_FUNCTION_FAILED;
goto cleanup;
}
/* get ID to identify signature key */
/* at this time, id should be available, otherwise, device is not connected and objects are not initialized */
ret = p11_get_attribute_value(pObject->pAttr, pObject->count, CKA_ID, (CK_VOID_PTR*) &pid, &len);
if (ret || (len != sizeof(CK_ULONG)))
{
log_trace(WHERE, "E: ID missing for key");
ret = CKR_FUNCTION_FAILED;
goto cleanup;
}
/* init sign operation */
if((pSignData = pSession->Operation[P11_OPERATION_SIGN].pData) == NULL)
{
pSignData = pSession->Operation[P11_OPERATION_SIGN].pData = (P11_SIGN_DATA *) malloc (sizeof(P11_SIGN_DATA));
if (pSignData == NULL)
{
log_trace( WHERE, "E: error allocating memory");
ret = CKR_HOST_MEMORY;
goto cleanup;
}
}
memset(pSignData, 0, sizeof(P11_SIGN_DATA));
pSignData->mechanism = pMechanism->mechanism;
pSignData->hKey = hKey;
pSignData->l_sign = (*pmodsize+7)/8;
pSignData->id = *pid;
if (ihash)
{
ret = hash_init(pMechanism, &(pSignData->phash), &(pSignData->l_hash));
if(ret)
{
log_trace(WHERE, "E: could not initialize hash()");
ret = CKR_FUNCTION_FAILED;
goto cleanup;
}
}
pSession->Operation[P11_OPERATION_SIGN].active = 1;
cleanup:
p11_unlock();
log_trace(WHERE, "I: leave, ret = 0x%08x",ret);
return ret;
}
CK_RV C_OpenSession(CK_SLOT_ID slotID, /* the slot's ID */
CK_FLAGS flags, /* defined in CK_SESSION_INFO */
CK_VOID_PTR pApplication, /* pointer passed to callback */
CK_NOTIFY Notify, /* notification callback function */
CK_SESSION_HANDLE_PTR phSession) /* receives new session handle */
{
int ret;
P11_SLOT* pSlot = NULL;
P11_SESSION *pSession = NULL;
// CAutoMutex(&g_oSlotMutex);
log_trace(WHERE, "I: enter");
ret = p11_lock(slotID); /* mutex per slot slot 0 tot 9 FF=global slot*/
if (ret != CKR_OK)
{
log_trace(WHERE, "I: leave, p11_lock failed with %i",ret);
return ret;
}
log_trace(WHERE, "S: C_OpenSession (slot %d)", slotID);
if (!(flags & CKF_SERIAL_SESSION))
{
ret = CKR_SESSION_PARALLEL_NOT_SUPPORTED;
goto cleanup;
}
//XXX check this
/* if (flags & ~(CKF_SERIAL_SESSION | CKF_RW_SESSION))
{
ret = CKR_ARGUMENTS_BAD;
goto cleanup;
}*/
pSlot = p11_get_slot(slotID);
if (pSlot == NULL)
{
log_trace(WHERE, "E: p11_get_slot(%d) returns null", slotID);
ret = CKR_SLOT_ID_INVALID;
goto cleanup;
}
/* Check that no conflictions sessions exist */
/* RO session when SO session exists is not allowed */
if ( !(flags & CKF_RW_SESSION) && (pSlot->login_type == CKU_SO))
{
log_trace(WHERE, "E: R/W Session exists", slotID);
ret = CKR_SESSION_READ_WRITE_SO_EXISTS;
goto cleanup;
}
//get a free session object reserve it by setting inuse flag
ret = p11_get_free_session(phSession, &pSession);
if (ret != CKR_OK)
{
log_trace(WHERE, "E: p11_get_free_session() returns %d", ret);
goto cleanup;
}
//connect to card if present
ret = cal_connect(slotID);
if (ret != CKR_OK)
{
//printf("Did not connect to card!!!!\n");
log_trace(WHERE, "E: cal_connect(slot %d) failed", slotID);
//release session so it can be reused
pSession->inuse = 0;
goto cleanup;
}
//printf("in use? %d... slotID = %d\n",pSession->inuse,slotID);
pSession->hslot = slotID;
pSession->flags = flags;
pSession->pdNotify = pApplication;
pSession->pfNotify = Notify;
//initial state
pSession->state = P11_CARD_STILL_PRESENT;
/* keep the nr of sessions for this slot */
pSlot->nsessions++;
log_trace(WHERE, "S: Open session (slot %d: hsession = %d )", slotID, *phSession);
cleanup:
p11_unlock();
log_trace(WHERE, "I: leave, ret = %i",ret);
return ret;
}
CK_RV C_Login(CK_SESSION_HANDLE hSession, /* the session's handle */
CK_USER_TYPE userType, /* the user type */
CK_CHAR_PTR pPin, /* the user's PIN */
CK_ULONG ulPinLen) /* the length of the PIN */
{
int ret;
P11_SESSION *pSession = NULL;
P11_SLOT *pSlot = NULL;
CK_TOKEN_INFO tokeninfo;
printf("\n********************\n");
printf("CK_RV C_Login called\n");
//return(CKR_OK);
log_trace(WHERE, "I: enter");
ret = p11_lock();
//printf("p11_lock returns: %s\n",!ret ? "OK" : "ERROR");
if (ret != CKR_OK)
{
log_trace(WHERE, "I: leave, p11_lock failed with %i",ret);
//printf("LOCK failled!\n");
//printf("\n********************\n");
return ret;
}
if (isAcroread())
{
return CKR_OK;
}
memset(&tokeninfo, 0, sizeof(CK_TOKEN_INFO));
log_trace(WHERE, "S: Login (session %d)", hSession);
printf("Login (session %d)\n",hSession);
if (userType != CKU_USER && userType != CKU_SO)
{
ret = CKR_USER_TYPE_INVALID;
//printf("TIPO DE UTILIZADOR INVALIDO\n");
goto cleanup;
}
ret = p11_get_session(hSession, &pSession);
if (ret)
{
//log_trace(WHERE, "E: Invalid session handle (%d)", hSession);
//printf("INVALID SESSION HANDLE - %d -\n",hSession);
goto cleanup;
}
pSlot = p11_get_slot(pSession->hslot);
if (pSlot == NULL)
{
log_trace(WHERE, "E: Slot not found for session %d", hSession);
ret = CKR_SESSION_HANDLE_INVALID;
//printf("SLOT NOT FOUND FOR SESSION\n");
goto cleanup;
}
if (pSlot->login_type >= 0)
{
// Needed for Acrobat, in case you want to sign with a 2nd card
ret = CKR_OK; //CKR_USER_ALREADY_LOGGED_IN;
//printf("Acrobat caso especial!");
goto cleanup;
}
/* ret = cal_get_token_info(pSlot, &tokeninfo);
if (ret != CKR_OK)
{
log_trace(WHERE, "E: could not find tokeninfo for slot %d", pSession->hslot);
goto cleanup;
}
if ( !(tokeninfo.flags & CKF_USER_PIN_INITIALIZED) )
{
ret = CKR_USER_PIN_NOT_INITIALIZED;
goto cleanup;
}*/
ret = cal_logon(pSession->hslot, ulPinLen, pPin, 0);
if (ret == CKR_OK){
pSlot->login_type = userType;
//printf("Tudo OK! - ret = %d\n",ret);
}
cleanup:
p11_unlock();
log_trace(WHERE, "I: leave, ret = %i",ret);
//printf("RET = %d\n",ret);
//printf("\n********************\n");
return ret;
}
CK_RV C_GetSessionInfo(CK_SESSION_HANDLE hSession, /* the session's handle */
CK_SESSION_INFO_PTR pInfo) /* receives session information */
{
int ret;
char buf[256];
P11_SESSION *pSession = NULL;
P11_SLOT *pSlot = NULL;
CK_TOKEN_INFO tokeninfo;
log_trace(WHERE, "I: enter");
ret = p11_lock();
if (ret != CKR_OK)
{
log_trace(WHERE, "I: leave, p11_lock failed with %i",ret);
return ret;
}
log_trace(WHERE, "S: C_GetSessionInfo(session %d)", hSession);
if (pInfo == NULL_PTR)
{
ret = CKR_ARGUMENTS_BAD;
goto cleanup;
}
ret = p11_get_session(hSession, &pSession);
if (ret)
{
log_trace(WHERE, "E: Invalid session handle (%d) (%s)", hSession, log_map_error(ret));
goto cleanup;
}
pInfo->slotID = pSession->hslot;
pInfo->flags = pSession->flags;
pInfo->ulDeviceError = 0;
pSlot = p11_get_slot(pSession->hslot);
if (pSlot == NULL)
{
log_trace(WHERE, "E: slot not found for session %d", hSession);
ret = CKR_SESSION_HANDLE_INVALID;
goto cleanup;
}
//SO only can create RW_SO sessions
if (pSlot->login_type == CKU_SO)
{
pInfo->state = CKS_RW_SO_FUNCTIONS;
}
//USER can create RW or RO sessions
else if (pSlot->login_type == CKU_USER)
{
pInfo->state = (pSession->flags & CKF_RW_SESSION)? CKS_RW_USER_FUNCTIONS : CKS_RO_USER_FUNCTIONS;
}
//if login not required => we can also get USER sessions without being logged on
else
{
ret = cal_get_token_info(pSession->hslot, &tokeninfo);
if ( (ret == CKR_OK) && !(tokeninfo.flags & CKF_LOGIN_REQUIRED) )
pInfo->state = (pSession->flags & CKF_RW_SESSION)? CKS_RW_USER_FUNCTIONS : CKS_RO_USER_FUNCTIONS;
else
pInfo->state = (pSession->flags & CKF_RW_SESSION) ? CKS_RW_PUBLIC_SESSION : CKS_RO_PUBLIC_SESSION;
}
cleanup:
p11_unlock();
log_trace(WHERE, "I: leave, ret = %i",ret);
return ret;
}
CK_RV C_WaitForSlotEvent(CK_FLAGS flags, /* blocking/nonblocking flag */
CK_SLOT_ID_PTR pSlot, /* location that receives the slot ID */
CK_VOID_PTR pReserved) /* reserved. Should be NULL_PTR */
{
CK_RV ret = CKR_OK;
int h;
P11_SLOT *p11Slot = NULL;
int i = 0;
CK_BBOOL locked = CK_FALSE;
#ifdef PKCS11_FF
CK_BBOOL bRunning = CK_TRUE;
long error = 0;
#endif
log_trace(WHERE, "I: enter");
//need to check initialization before lock, as lock might be in progress of being set up
if (p11_get_init() != BEIDP11_INITIALIZED)
{
log_trace(WHERE, "I: leave, CKR_CRYPTOKI_NOT_INITIALIZED");
return (CKR_CRYPTOKI_NOT_INITIALIZED);
}
#ifdef PKCS11_FF
/*error = cal_check_pcsc(&bRunning);
if(bRunning == CK_FALSE)
{
while( (error == 0) && (bRunning == CK_FALSE) )
{
cal_wait (500);
error = cal_check_pcsc(&bRunning);
//check if pkcs11 isn't finalizing
if (p11_get_init() != BEIDP11_INITIALIZED)
{
log_trace(WHERE, "I: leave, CKR_CRYPTOKI_NO_LONGER_INITIALIZED");
return (CKR_CRYPTOKI_NOT_INITIALIZED);
}
}
//pcsc just got launched, so establish a new context
ret = p11_lock();
if (ret != CKR_OK)
{
log_trace(WHERE, "I: leave, p11_lock failed with %i",ret);
return ret;
}
//check if nowhere else the context has been reestablished
//TODO : if()
cal_re_establish_context();
p11_unlock();
}*/
#endif
ret = p11_lock();
if (ret != CKR_OK)
{
log_trace(WHERE, "I: leave, p11_lock failed with %i",ret);
return ret;
}
//check again, in case c_finalize got the lock right before we did
//(then c_finalize will give us a chance to fall through, right before he resets the lock))
if (p11_get_init() != BEIDP11_INITIALIZED)
{
log_trace(WHERE, "I: leave, CKR_CRYPTOKI_NOT_INITIALIZED");
p11_unlock();
return (CKR_CRYPTOKI_NOT_INITIALIZED);
}
locked = CK_TRUE;
log_trace(WHERE, "S: C_WaitForSlotEvent(flags = 0x%0x)", flags);
// Doesn't seem to work on Linux: if you insert a card then Mozilla freezes
// until you remove the card. This function however seems to work fine.
#ifndef _WIN32
CLEANUP(CKR_FUNCTION_NOT_SUPPORTED);
#endif
//first check if no events are set for slots in previous run
//this could happen if more cards are inserted/removed at the same time
for (i=0; i < p11_get_nreaders(); i++)
{
p11Slot = p11_get_slot(i);
if(p11Slot == NULL)
CLEANUP(CKR_FUNCTION_FAILED);
if (p11Slot->ievent != P11_EVENT_NONE)
{
#ifdef PKCS11_FF
//in case the upnp reader caused the event, return a new slotnumber
if( (i+1) == p11_get_nreaders())
{
if(cal_getgnFFReaders() == 0)
{
cal_setgnFFReaders(p11_get_nreaders()+1);
}
else
{
cal_incgnFFReaders();
}
i = (cal_getgnFFReaders()-1);
}
#endif
*pSlot = i;
//clear event
p11Slot->ievent = P11_EVENT_NONE;
CLEANUP(CKR_OK);
}
}
if (flags & CKF_DONT_BLOCK)
{
ret = cal_wait_for_slot_event(0);//0 means don't block
}
else
{
ret = cal_wait_for_slot_event(1);//1 means block, lock will get released here
//ret is 0x30 when SCardGetStatusChange gets cancelled
if ((p11_get_init() == BEIDP11_NOT_INITIALIZED ) ||
(p11_get_init() == BEIDP11_DEINITIALIZING) ||
(ret == CKR_CRYPTOKI_NOT_INITIALIZED) )
{
log_trace(WHERE, "I: CKR_CRYPTOKI_NOT_INITIALIZED");
p11_unlock();
return(CKR_CRYPTOKI_NOT_INITIALIZED);
}
}
if(ret != CKR_OK)
goto cleanup;
ret = cal_get_slot_changes(&h);
if (ret == CKR_OK)
*pSlot = h;
//else CKR_NO_EVENT
/* Firefox 1.5 tries to call this function (with the blocking flag)
* in a separate thread; and this causes the pkcs11 lib to hang on Linux
* So we might have to return "not supported" in which case Ff 1.5 defaults
* to polling in the main thread, like before. */
cleanup:
if(locked == CK_TRUE)
p11_unlock();
log_trace(WHERE, "I: leave, ret = %i",ret);
return ret;
}
CK_RV C_GetSlotInfo(CK_SLOT_ID slotID, CK_SLOT_INFO_PTR pInfo)
{
CK_RV ret;
P11_SLOT *slot;
static int l=0;
int isPresent = 0;
log_trace(WHERE, "I: enter");
if (p11_get_init() != BEIDP11_INITIALIZED)
{
log_trace(WHERE, "I: leave, CKR_CRYPTOKI_NOT_INITIALIZED");
return (CKR_CRYPTOKI_NOT_INITIALIZED);
}
ret = p11_lock();
if (ret != CKR_OK)
{
log_trace(WHERE, "I: leave, p11_lock failed with %i",ret);
return ret;
}
if (++l < LOG_MAX_REC)
log_trace(WHERE, "S: C_GetSlotInfo(slot %d)", slotID);
if (pInfo == NULL_PTR)
{
log_trace(WHERE, "E: pInfo = NULL");
CLEANUP(CKR_ARGUMENTS_BAD);
}
slot = p11_get_slot(slotID);
if (slot == NULL)
{
log_trace(WHERE, "E: p11_get_slot(%d) returns null", slotID);
CLEANUP(CKR_SLOT_ID_INVALID);
}
//fill in slot info
strcpy_n(pInfo->slotDescription, slot->name, 64, ' ');
strcpy_n(pInfo->manufacturerID, "_ID_", 32, ' ');
pInfo->flags = CKF_REMOVABLE_DEVICE | CKF_HW_SLOT;
pInfo->hardwareVersion.major = 1;
pInfo->hardwareVersion.minor = 0;
pInfo->firmwareVersion.major = 1;
pInfo->firmwareVersion.minor = 0;
//check if token is present
ret = (cal_token_present(slotID, &isPresent));
if(ret != CKR_OK)
goto cleanup;
if (isPresent)
{
pInfo->flags |= CKF_TOKEN_PRESENT;
}
cleanup:
p11_unlock();
log_trace(WHERE, "I: leave, ret = %i",ret);
return ret;
}
CK_RV C_GetSlotList(CK_BBOOL tokenPresent, /* only slots with token present */
CK_SLOT_ID_PTR pSlotList, /* receives the array of slot IDs */
CK_ULONG_PTR pulCount) /* receives the number of slots */
{
P11_SLOT *pSlot;
CK_RV ret = CKR_OK;
int h;
CK_ULONG c = 0;
static int l=0;
log_trace(WHERE, "I: enter");
if (p11_get_init() != BEIDP11_INITIALIZED)
{
log_trace(WHERE, "I: leave, CKR_CRYPTOKI_NOT_INITIALIZED");
return (CKR_CRYPTOKI_NOT_INITIALIZED);
}
ret = p11_lock();
log_trace(WHERE, "I: p11_lock() acquiered");
if (ret != CKR_OK)
{
log_trace(WHERE, "I: leave, p11_lock failed with %i",ret);
return (ret);
}
if (++l<LOG_MAX_REC)
log_trace(WHERE, "S: C_GetSlotList()");
if (pulCount == NULL_PTR)
{
ret = CKR_ARGUMENTS_BAD;
goto cleanup;
}
#ifdef PKCS11_V2_20
if(pSlotList == NULL){
ret = cal_refresh_readers();
}
#endif
//init slots allready done
//update info on tokens in slot, could be removed if thread keeps track of these token states
//BUG in Adobe Acrobat reader: adobe asks for slots with pSlotList = NULL, so only nr of slots will be returned. This is ok.
//a second time Adobe calls this, pSlotList still is NULL, so the array with SlotIDs cannot be returned, again, nr of slots is returned.
//Adobe just assumes that the first slot has ID=0 !!! and uses this ID=0 for all further actions.
//to overcome this problem, we start our SlotIDs from 0 and not 1 !!!
log_trace(WHERE, "I: h=0");
//Do not show the virtual reader (used to capture the reader connect events)
//for (h=0; h < (p11_get_nreaders()-1); h++)
for (h=0; h < p11_get_nreaders(); h++)
{
log_trace(WHERE, "I: h=%i",h);
pSlot = p11_get_slot(h);
if (l < LOG_MAX_REC)
log_trace(WHERE, "I: slot[%d]: %s", h, pSlot->name);
if (tokenPresent == CK_TRUE)
{
int pPresent = 0;
ret = cal_token_present(h, &pPresent);
if(ret != CKR_OK && ret != CKR_TOKEN_NOT_RECOGNIZED)
{
goto cleanup;
}
if (pPresent)
{
log_trace(WHERE, "I: cal_token_present");
c++;
if ((pSlotList != NULL_PTR) && (c <= *pulCount) )
pSlotList[c-1] = h;
}
continue;
}
else
{
//get all slots
c++;
if ((pSlotList != NULL_PTR) && (c <= *pulCount) )
{
pSlotList[c-1] = h;
}
continue;
}
} //end for
#ifdef PKCS11_FF
//return the fake slotID for the attached/removed reader
if (cal_getgnFFReaders()!= 0)
{
//return a higher number of slots, so FF starts waiting for slotchanges again
if(pSlotList == NULL)
{
c = cal_getgnFFReaders();
}
else
{
for(; h < cal_getgnFFReaders(); h++)
{
log_trace(WHERE, "I: h=%i",h);
c++;
if (c <= *pulCount )
pSlotList[c-1] = h;
}
}
}
#endif
//if more slots are found than can be returned in slotlist, return buffer too smal
if ((c > *pulCount) && (pSlotList != NULL_PTR) )
ret = CKR_BUFFER_TOO_SMALL;
//number of slots should always be returned.
*pulCount = c;
cleanup:
log_trace(WHERE, "I: p11_unlock()");
p11_unlock();
log_trace(WHERE, "I: leave, ret = %i",ret);
return ret;
}
