/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
/*
* Internal PKCS #11 functions. Should only be called by pkcs11.c
*/
#include "pkcs11.h"
#include "pkcs11i.h"
#include "lowkeyi.h"
#include "secasn1.h"
#include "blapi.h"
#include "secerr.h"
#include "prnetdb.h" /* for PR_ntohl */
#include "sftkdb.h"
#include "softoken.h"
#include "secoid.h"
#include "softkver.h"
#if !
defined(NSS_FIPS_DISABLED) &&
defined(NSS_ENABLE_FIPS_INDICATORS)
/* handle special cases. Classes require existing code to already be
* in place for that class */
typedef enum {
SFTKFIPSNone =
0,
SFTKFIPSDH,
/* allow only specific primes */
SFTKFIPSECC,
/* not just keys but specific curves */
SFTKFIPSAEAD,
/* single shot AEAD functions not allowed in FIPS mode */
SFTKFIPSRSAPSS,
SFTKFIPSTlsKeyCheck
} SFTKFIPSSpecialClass;
typedef struct SFTKFIPSAlgorithmListStr SFTKFIPSAlgorithmList;
struct SFTKFIPSAlgorithmListStr {
CK_MECHANISM_TYPE type;
CK_MECHANISM_INFO info;
CK_ULONG step;
SFTKFIPSSpecialClass special;
};
/* this file should be supplied by the vendor and include all the
* algorithms which have Algorithm certs and have been reviewed by
* the lab. A blank file is included for the base so that FIPS mode
* will still be compiled and run, but FIPS indicators will always
* return PR_FALSE
*/
#include "fips_algorithms.h"
#define NSS_HAS_FIPS_INDICATORS
1
#endif
/*
* ******************** Error mapping *******************************
*/
/*
* map all the SEC_ERROR_xxx error codes that may be returned by freebl
* functions to CKR_xxx. return CKR_DEVICE_ERROR by default for backward
* compatibility.
*/
CK_RV
sftk_MapCryptError(
int error)
{
switch (error) {
case SEC_ERROR_INVALID_ARGS:
case SEC_ERROR_BAD_DATA:
/* MP_RANGE gets mapped to this */
return CKR_ARGUMENTS_BAD;
case SEC_ERROR_INPUT_LEN:
return CKR_DATA_LEN_RANGE;
case SEC_ERROR_OUTPUT_LEN:
return CKR_BUFFER_TOO_SMALL;
case SEC_ERROR_LIBRARY_FAILURE:
return CKR_GENERAL_ERROR;
case SEC_ERROR_NO_MEMORY:
return CKR_HOST_MEMORY;
case SEC_ERROR_BAD_SIGNATURE:
return CKR_SIGNATURE_INVALID;
case SEC_ERROR_INVALID_KEY:
return CKR_KEY_SIZE_RANGE;
case SEC_ERROR_BAD_KEY:
/* an EC public key that fails validation */
return CKR_KEY_SIZE_RANGE;
/* the closest error code */
case SEC_ERROR_UNSUPPORTED_EC_POINT_FORM:
return CKR_TEMPLATE_INCONSISTENT;
case SEC_ERROR_UNSUPPORTED_KEYALG:
return CKR_MECHANISM_INVALID;
case SEC_ERROR_UNSUPPORTED_ELLIPTIC_CURVE:
return CKR_DOMAIN_PARAMS_INVALID;
/* key pair generation failed after max number of attempts */
case SEC_ERROR_NEED_RANDOM:
return CKR_FUNCTION_FAILED;
}
return CKR_DEVICE_ERROR;
}
/*
* functions which adjust the mapping based on different contexts
* (Decrypt or Verify).
*/
/* used by Decrypt and UnwrapKey (indirectly) and Decrypt message */
CK_RV
sftk_MapDecryptError(
int error)
{
switch (error) {
/* usually a padding error, or aead tag mismatch */
case SEC_ERROR_BAD_DATA:
return CKR_ENCRYPTED_DATA_INVALID;
default:
return sftk_MapCryptError(error);
}
}
/*
* return CKR_SIGNATURE_INVALID instead of CKR_DEVICE_ERROR by default for
* backward compatibilty.
*/
CK_RV
sftk_MapVerifyError(
int error)
{
CK_RV crv = sftk_MapCryptError(error);
if (crv == CKR_DEVICE_ERROR)
crv = CKR_SIGNATURE_INVALID;
return crv;
}
/*
* ******************** Attribute Utilities *******************************
*/
/*
* create a new attribute with type, value, and length. Space is allocated
* to hold value.
*/
static SFTKAttribute *
sftk_InitAttribute(SFTKSessionObject *so,
int index,
CK_ATTRIBUTE_TYPE type,
const void *value, CK_ULONG len)
{
SFTKAttribute *attribute;
PORT_Assert(index < MAX_OBJS_ATTRS);
if (index >= MAX_OBJS_ATTRS)
return NULL;
attribute = &so->attrList[index];
attribute->attrib.type = type;
attribute->freeAttr = PR_FALSE;
attribute->freeData = PR_FALSE;
if (value) {
if (len <= ATTR_SPACE) {
attribute->attrib.pValue = attribute->space;
}
else {
attribute->attrib.pValue = PORT_Alloc(len);
attribute->freeData = PR_TRUE;
}
if (attribute->attrib.pValue == NULL) {
return NULL;
}
PORT_Memcpy(attribute->attrib.pValue, value, len);
attribute->attrib.ulValueLen = len;
}
else {
attribute->attrib.pValue = NULL;
attribute->attrib.ulValueLen =
0;
}
attribute->attrib.type = type;
attribute->handle = type;
attribute->next = attribute->prev = NULL;
return attribute;
}
static SFTKAttribute *
sftk_NewAttribute(SFTKObject *object,
CK_ATTRIBUTE_TYPE type,
const void *value, CK_ULONG len)
{
SFTKSessionObject *so = sftk_narrowToSessionObject(object);
int index;
if (so == NULL) {
/* allocate new attribute in a buffer */
PORT_Assert(
0);
return NULL;
}
/*
* We attempt to keep down contention on Malloc and Arena locks by
* limiting the number of these calls on high traversed paths. This
* is done for attributes by 'allocating' them from a pool already
* allocated by the parent object.
*/
PR_Lock(so->attributeLock);
index = so->nextAttr++;
PR_Unlock(so->attributeLock);
return sftk_InitAttribute(so, index, type, value, len);
}
/*
* Free up all the memory associated with an attribute. Reference count
* must be zero to call this.
*/
static void
sftk_DestroyAttribute(SFTKAttribute *attribute)
{
if (attribute->attrib.pValue) {
/* clear out the data in the attribute value... it may have been
* sensitive data */
PORT_Memset(attribute->attrib.pValue,
0, attribute->attrib.ulValueLen);
if (attribute->freeData) {
PORT_Free(attribute->attrib.pValue);
attribute->attrib.pValue = NULL;
attribute->freeData = PR_FALSE;
}
}
if (attribute->freeAttr) {
PORT_Free(attribute);
}
}
/*
* release a reference to an attribute structure
*/
void
sftk_FreeAttribute(SFTKAttribute *attribute)
{
if (attribute && attribute->freeAttr) {
sftk_DestroyAttribute(attribute);
return;
}
}
static SFTKAttribute *
sftk_FindTokenAttribute(SFTKTokenObject *object, CK_ATTRIBUTE_TYPE type)
{
SFTKAttribute *myattribute = NULL;
SFTKDBHandle *dbHandle = NULL;
CK_RV crv = CKR_HOST_MEMORY;
if (object == NULL) {
return NULL;
}
myattribute = (SFTKAttribute *)PORT_Alloc(
sizeof(SFTKAttribute));
if (myattribute == NULL) {
goto loser;
}
dbHandle = sftk_getDBForTokenObject(object->obj.slot, object->obj.handle);
myattribute->handle = type;
myattribute->attrib.type = type;
myattribute->attrib.pValue = myattribute->space;
myattribute->attrib.ulValueLen = ATTR_SPACE;
myattribute->next = myattribute->prev = NULL;
myattribute->freeAttr = PR_TRUE;
myattribute->freeData = PR_FALSE;
crv = sftkdb_GetAttributeValue(dbHandle, object->obj.handle,
&myattribute->attrib,
1);
/* attribute is bigger than our attribute space buffer, malloc it */
if (crv == CKR_BUFFER_TOO_SMALL) {
myattribute->attrib.pValue = NULL;
crv = sftkdb_GetAttributeValue(dbHandle, object->obj.handle,
&myattribute->attrib,
1);
if (crv != CKR_OK) {
goto loser;
}
myattribute->attrib.pValue = PORT_Alloc(myattribute->attrib.ulValueLen);
if (myattribute->attrib.pValue == NULL) {
crv = CKR_HOST_MEMORY;
goto loser;
}
myattribute->freeData = PR_TRUE;
crv = sftkdb_GetAttributeValue(dbHandle, object->obj.handle,
&myattribute->attrib,
1);
}
loser:
if (dbHandle) {
sftk_freeDB(dbHandle);
}
if (crv != CKR_OK) {
if (myattribute) {
myattribute->attrib.ulValueLen =
0;
sftk_FreeAttribute(myattribute);
myattribute = NULL;
}
}
return myattribute;
}
/*
* Make a detached, owned copy of a session object's attribute. Must be
* called with sessObject->attributeLock held so the (pValue, ulValueLen)
* pair is captured atomically with respect to sftk_forceAttribute() and
* friends. The copy carries freeAttr = PR_TRUE, so sftk_FreeAttribute()
* releases it; callers may read it without holding any lock.
*/
static SFTKAttribute *
sftk_CopyAttribute(
const SFTKAttribute *attribute)
{
SFTKAttribute *copy = (SFTKAttribute *)PORT_Alloc(
sizeof(SFTKAttribute));
if (copy == NULL) {
return NULL;
}
copy->next = copy->prev = NULL;
copy->freeAttr = PR_TRUE;
copy->freeData = PR_FALSE;
copy->handle = attribute->handle;
copy->attrib.type = attribute->attrib.type;
if (attribute->attrib.pValue == NULL) {
copy->attrib.pValue = NULL;
copy->attrib.ulValueLen =
0;
return copy;
}
if (attribute->attrib.ulValueLen <= ATTR_SPACE) {
copy->attrib.pValue = copy->space;
}
else {
copy->attrib.pValue = PORT_Alloc(attribute->attrib.ulValueLen);
if (copy->attrib.pValue == NULL) {
PORT_Free(copy);
return NULL;
}
copy->freeData = PR_TRUE;
}
PORT_Memcpy(copy->attrib.pValue, attribute->attrib.pValue,
attribute->attrib.ulValueLen);
copy->attrib.ulValueLen = attribute->attrib.ulValueLen;
return copy;
}
/*
* look up and attribute structure from a type and Object structure.
* The returned attribute is referenced and needs to be freed when
* it is no longer needed.
*/
SFTKAttribute *
sftk_FindAttribute(SFTKObject *object, CK_ATTRIBUTE_TYPE type)
{
SFTKAttribute *attribute;
SFTKSessionObject *sessObject = sftk_narrowToSessionObject(object);
/* validation flags are stored as FIPS indicators */
if (type == CKA_OBJECT_VALIDATION_FLAGS) {
return &object->validation_attribute;
}
if (sessObject == NULL) {
return sftk_FindTokenAttribute(sftk_narrowToTokenObject(object), type);
}
/* Return a detached copy rather than the live pool entry: callers
* dereference attrib.pValue after the lock is dropped, while a
* concurrent sftk_forceAttribute() may free and reassign it.
* Snapshotting under the lock gives the caller a stable,
* private value (this matches the token-object path above). */
PR_Lock(sessObject->attributeLock);
sftkqueue_find(attribute, type, sessObject->head, sessObject->hashSize);
if (attribute != NULL) {
attribute = sftk_CopyAttribute(attribute);
}
PR_Unlock(sessObject->attributeLock);
return (attribute);
}
/*
* Look up an attribute while the caller holds the object's attributeLock.
* Returns a BORROWED reference to the live node in sessObject->head[] (or
* the object's embedded validation attribute): valid only until the lock is
* released, and never to be passed to sftk_FreeAttribute().
*
* This is only valid for session objects (and CKA_OBJECT_VALIDATION_FLAGS).
* Token objects have no live node; callers that may see one must fall back
* to sftk_FindAttribute(). Returns NULL if the attribute is absent.
*
* The lock is NOT reentrant: while holding it, the caller must not call any
* attribute API that takes it itself (sftk_FindAttribute,
* sftk_AddAttributeType, sftk_forceAttribute, sftk_DeleteAttributeType).
*/
static SFTKAttribute *
sftk_FindAttributeLocked(SFTKObject *object, CK_ATTRIBUTE_TYPE type)
{
SFTKSessionObject *sessObject;
SFTKAttribute *attribute;
/* validation flags are stored as FIPS indicators */
if (type == CKA_OBJECT_VALIDATION_FLAGS) {
return &object->validation_attribute;
}
sessObject = sftk_narrowToSessionObject(object);
PORT_Assert(sessObject != NULL);
if (sessObject == NULL) {
return NULL;
}
sftkqueue_find(attribute, type, sessObject->head, sessObject->hashSize);
return attribute;
}
/*
* Take a buffer and it's length and return it's true size in bits;
*/
unsigned int
sftk_GetLengthInBits(
unsigned char *buf,
unsigned int bufLen)
{
unsigned int size = bufLen *
8;
unsigned int i;
/* Get the real length in bytes */
for (i =
0; i < bufLen; i++) {
unsigned char c = *buf++;
if (c !=
0) {
unsigned char m;
for (m =
0x80; m >
0; m = m >>
1) {
if ((c & m) !=
0) {
break;
}
size--;
}
break;
}
size -=
8;
}
return size;
}
/*
* Constrain a big num attribute. to size and padding
* minLength means length of the object must be greater than equal to minLength
* maxLength means length of the object must be less than equal to maxLength
* minMultiple means that object length mod minMultiple must equal 0.
* all input sizes are in bits.
* if any constraint is '0' that constraint is not checked.
*/
CK_RV
sftk_ConstrainAttribute(SFTKObject *object, CK_ATTRIBUTE_TYPE type,
int minLength,
int maxLength,
int minMultiple)
{
SFTKAttribute *attribute;
int size =
0;
unsigned char *ptr;
SFTKSessionObject *sessObject = sftk_narrowToSessionObject(object);
CK_RV crv = CKR_OK;
if (sessObject != NULL) {
PR_Lock(sessObject->attributeLock);
attribute = sftk_FindAttributeLocked(object, type);
}
else {
attribute = sftk_FindAttribute(object, type);
}
if (!attribute) {
crv = CKR_TEMPLATE_INCOMPLETE;
}
else {
ptr = (
unsigned char *)attribute->attrib.pValue;
if (ptr == NULL) {
crv = CKR_ATTRIBUTE_VALUE_INVALID;
}
else {
size = sftk_GetLengthInBits(ptr, attribute->attrib.ulValueLen);
}
}
if (sessObject != NULL) {
PR_Unlock(sessObject->attributeLock);
}
else {
sftk_FreeAttribute(attribute);
}
if (crv != CKR_OK) {
return crv;
}
if ((minLength !=
0) && (size < minLength)) {
return CKR_ATTRIBUTE_VALUE_INVALID;
}
if ((maxLength !=
0) && (size > maxLength)) {
return CKR_ATTRIBUTE_VALUE_INVALID;
}
if ((minMultiple !=
0) && ((size % minMultiple) !=
0)) {
return CKR_ATTRIBUTE_VALUE_INVALID;
}
return CKR_OK;
}
PRBool
sftk_hasAttributeToken(SFTKTokenObject *object, CK_ATTRIBUTE_TYPE type)
{
CK_ATTRIBUTE
template;
CK_RV crv;
SFTKDBHandle *dbHandle;
if (object == NULL) {
return PR_FALSE;
}
dbHandle = sftk_getDBForTokenObject(object->obj.slot, object->obj.handle);
template.type = type;
template.pValue = NULL;
template.ulValueLen =
0;
crv = sftkdb_GetAttributeValue(dbHandle, object->obj.handle, &
template,
1);
sftk_freeDB(dbHandle);
/* attribute is bigger than our attribute space buffer, malloc it */
return (crv == CKR_OK) ? PR_TRUE : PR_FALSE;
}
/*
* return true if object has attribute
*/
PRBool
sftk_hasAttribute(SFTKObject *object, CK_ATTRIBUTE_TYPE type)
{
SFTKAttribute *attribute;
SFTKSessionObject *sessObject = sftk_narrowToSessionObject(object);
if (sessObject == NULL) {
return sftk_hasAttributeToken(sftk_narrowToTokenObject(object), type);
}
PR_Lock(sessObject->attributeLock);
sftkqueue_find(attribute, type, sessObject->head, sessObject->hashSize);
PR_Unlock(sessObject->attributeLock);
return (PRBool)(attribute != NULL);
}
/*
* add an attribute to an object
*/
static void
sftk_AddAttribute(SFTKObject *object, SFTKAttribute *attribute)
{
SFTKSessionObject *sessObject = sftk_narrowToSessionObject(object);
if (sessObject == NULL)
return;
PR_Lock(sessObject->attributeLock);
sftkqueue_add(attribute, attribute->handle,
sessObject->head, sessObject->hashSize);
PR_Unlock(sessObject->attributeLock);
}
/*
* copy an unsigned attribute into a SECItem. Secitem is allocated in
* the specified arena.
*/
CK_RV
sftk_Attribute2SSecItem(PLArenaPool *arena, SECItem *item, SFTKObject *object,
CK_ATTRIBUTE_TYPE type)
{
SFTKSessionObject *sessObject = sftk_narrowToSessionObject(object);
SFTKAttribute *attribute;
CK_RV crv = CKR_OK;
item->data = NULL;
if (sessObject != NULL) {
PR_Lock(sessObject->attributeLock);
attribute = sftk_FindAttributeLocked(object, type);
}
else {
attribute = sftk_FindAttribute(object, type);
}
if (attribute == NULL) {
crv = CKR_TEMPLATE_INCOMPLETE;
}
else {
(
void)SECITEM_AllocItem(arena, item, attribute->attrib.ulValueLen);
if (item->data == NULL) {
crv = CKR_HOST_MEMORY;
}
else {
PORT_Memcpy(item->data, attribute->attrib.pValue, item->len);
}
}
if (sessObject != NULL) {
PR_Unlock(sessObject->attributeLock);
}
else {
sftk_FreeAttribute(attribute);
}
return crv;
}
/*
* fetch multiple attributes into SECItems. Secitem data is allocated in
* the specified arena.
*/
CK_RV
sftk_MultipleAttribute2SecItem(PLArenaPool *arena, SFTKObject *object,
SFTKItemTemplate *itemTemplate,
int itemTemplateCount)
{
CK_RV crv = CKR_OK;
CK_ATTRIBUTE templateSpace[SFTK_MAX_ITEM_TEMPLATE];
CK_ATTRIBUTE *
template;
SFTKTokenObject *tokObject;
SFTKDBHandle *dbHandle = NULL;
int i;
tokObject = sftk_narrowToTokenObject(object);
/* session objects, just loop through the list */
if (tokObject == NULL) {
for (i =
0; i < itemTemplateCount; i++) {
crv = sftk_Attribute2SecItem(arena, itemTemplate[i].item, object,
itemTemplate[i].type);
if (crv != CKR_OK) {
return crv;
}
}
return CKR_OK;
}
/* don't do any work if none is required */
if (itemTemplateCount ==
0) {
return CKR_OK;
}
/* don't allocate the template unless we need it */
if (itemTemplateCount > SFTK_MAX_ITEM_TEMPLATE) {
template = PORT_NewArray(CK_ATTRIBUTE, itemTemplateCount);
}
else {
template = templateSpace;
}
if (
template == NULL) {
crv = CKR_HOST_MEMORY;
goto loser;
}
dbHandle = sftk_getDBForTokenObject(object->slot, object->handle);
if (dbHandle == NULL) {
crv = CKR_OBJECT_HANDLE_INVALID;
goto loser;
}
/* set up the PKCS #11 template */
for (i =
0; i < itemTemplateCount; i++) {
template[i].type = itemTemplate[i].type;
template[i].pValue = NULL;
template[i].ulValueLen =
0;
}
/* fetch the attribute lengths */
crv = sftkdb_GetAttributeValue(dbHandle, object->handle,
template, itemTemplateCount);
if (crv != CKR_OK) {
goto loser;
}
/* allocate space for the attributes */
for (i =
0; i < itemTemplateCount; i++) {
template[i].pValue = PORT_ArenaAlloc(arena,
template[i].ulValueLen);
if (
template[i].pValue == NULL) {
crv = CKR_HOST_MEMORY;
goto loser;
}
}
/* fetch the attributes */
crv = sftkdb_GetAttributeValue(dbHandle, object->handle,
template, itemTemplateCount);
if (crv != CKR_OK) {
goto loser;
}
/* Fill in the items */
for (i =
0; i < itemTemplateCount; i++) {
itemTemplate[i].item->data =
template[i].pValue;
itemTemplate[i].item->len =
template[i].ulValueLen;
}
loser:
if (
template != templateSpace) {
PORT_Free(
template);
}
if (dbHandle) {
sftk_freeDB(dbHandle);
}
return crv;
}
/*
* this is only valid for CK_BBOOL type attributes. Return the state
* of that attribute.
*/
PRBool
sftk_isTrue(SFTKObject *object, CK_ATTRIBUTE_TYPE type)
{
SFTKSessionObject *sessObject = sftk_narrowToSessionObject(object);
SFTKAttribute *attribute;
PRBool tok = PR_FALSE;
/* For a session object read the live single-byte value under the lock
* rather than copying it out (this is a very hot path); for a token
* object fall back to a freed copy. */
if (sessObject != NULL) {
PR_Lock(sessObject->attributeLock);
attribute = sftk_FindAttributeLocked(object, type);
}
else {
attribute = sftk_FindAttribute(object, type);
}
if (attribute != NULL && attribute->attrib.pValue != NULL) {
tok = (PRBool)(*(CK_BBOOL *)attribute->attrib.pValue);
}
if (sessObject != NULL) {
PR_Unlock(sessObject->attributeLock);
}
else {
sftk_FreeAttribute(attribute);
}
return tok;
}
static CK_RV
sftk_forceTokenAttribute(SFTKObject *object, CK_ATTRIBUTE_TYPE type,
const void *value,
unsigned int len)
{
CK_ATTRIBUTE attribute;
SFTKDBHandle *dbHandle = NULL;
SFTKTokenObject *to = sftk_narrowToTokenObject(object);
CK_RV crv;
PORT_Assert(to);
if (to == NULL) {
return CKR_DEVICE_ERROR;
}
dbHandle = sftk_getDBForTokenObject(object->slot, object->handle);
attribute.type = type;
attribute.pValue = (
void *)value;
attribute.ulValueLen = len;
crv = sftkdb_SetAttributeValue(dbHandle, object, &attribute,
1);
sftk_freeDB(dbHandle);
return crv;
}
/*
* force an attribute to a specifc value.
*/
CK_RV
sftk_forceAttribute(SFTKObject *object, CK_ATTRIBUTE_TYPE type,
const void *value,
unsigned int len)
{
SFTKAttribute *attribute;
void *att_val = NULL;
PRBool freeData = PR_FALSE;
PORT_Assert(object);
PORT_Assert(object->refCount);
PORT_Assert(object->slot);
if (!object ||
!object->refCount ||
!object->slot) {
return CKR_DEVICE_ERROR;
}
/* validation flags are stored as FIPS indicators,
* don't send them through the general attribute
* parsing */
if (type == CKA_OBJECT_VALIDATION_FLAGS) {
CK_FLAGS validation;
if (len !=
sizeof(CK_FLAGS)) {
return CKR_ATTRIBUTE_VALUE_INVALID;
}
validation = *(CK_FLAGS *)value;
/* we only understand FIPS currently, don't allow setting
* other flags */
if ((validation & ~SFTK_VALIDATION_FIPS_FLAG) !=
0) {
return CKR_ATTRIBUTE_VALUE_INVALID;
}
object->validation_value = validation;
return CKR_OK;
}
if (sftk_isToken(object->handle)) {
return sftk_forceTokenAttribute(object, type, value, len);
}
/* After the token/validation dispatch above, this is a session
* object. Look up and mutate the live node under attributeLock so the
* (pValue, ulValueLen) pair stays consistent for concurrent readers,
* which snapshot it under the same lock in sftk_FindAttribute(). */
SFTKSessionObject *sessObject = sftk_narrowToSessionObject(object);
PORT_Assert(sessObject);
if (sessObject == NULL) {
return CKR_DEVICE_ERROR;
}
PR_Lock(sessObject->attributeLock);
sftkqueue_find(attribute, type, sessObject->head, sessObject->hashSize);
if (attribute == NULL) {
PR_Unlock(sessObject->attributeLock);
return sftk_AddAttributeType(object, type, value, len);
}
if (value) {
if (len <= ATTR_SPACE) {
att_val = attribute->space;
}
else {
att_val = PORT_Alloc(len);
freeData = PR_TRUE;
}
if (att_val == NULL) {
PR_Unlock(sessObject->attributeLock);
return CKR_HOST_MEMORY;
}
if (attribute->attrib.pValue == att_val) {
PORT_Memset(attribute->attrib.pValue,
0,
attribute->attrib.ulValueLen);
}
PORT_Memcpy(att_val, value, len);
}
if (attribute->attrib.pValue != NULL) {
if (attribute->attrib.pValue != att_val) {
PORT_Memset(attribute->attrib.pValue,
0,
attribute->attrib.ulValueLen);
}
if (attribute->freeData) {
PORT_Assert(attribute->attrib.pValue != att_val);
PORT_Free(attribute->attrib.pValue);
}
attribute->freeData = PR_FALSE;
attribute->attrib.pValue = NULL;
attribute->attrib.ulValueLen =
0;
}
if (att_val) {
attribute->attrib.pValue = att_val;
attribute->attrib.ulValueLen = len;
attribute->freeData = freeData;
}
PR_Unlock(sessObject->attributeLock);
return CKR_OK;
}
/*
* decode when a particular attribute may be modified
* SFTK_NEVER: This attribute must be set at object creation time and
* can never be modified.
* SFTK_ONCOPY: This attribute may be modified only when you copy the
* object.
* SFTK_SENSITIVE: The CKA_SENSITIVE attribute can only be changed from
* CK_FALSE to CK_TRUE.
* SFTK_ALWAYS: This attribute can always be modified.
* Some attributes vary their modification type based on the class of the
* object.
*/
SFTKModifyType
sftk_modifyType(CK_ATTRIBUTE_TYPE type, CK_OBJECT_CLASS inClass)
{
/* if we don't know about it, user user defined, always allow modify */
SFTKModifyType mtype = SFTK_ALWAYS;
switch (type) {
/* NEVER */
case CKA_CLASS:
case CKA_CERTIFICATE_TYPE:
case CKA_KEY_TYPE:
case CKA_MODULUS:
case CKA_MODULUS_BITS:
case CKA_PUBLIC_EXPONENT:
case CKA_PRIVATE_EXPONENT:
case CKA_PRIME:
case CKA_BASE:
case CKA_PRIME_1:
case CKA_PRIME_2:
case CKA_EXPONENT_1:
case CKA_EXPONENT_2:
case CKA_COEFFICIENT:
case CKA_SEED:
case CKA_PARAMETER_SET:
case CKA_VALUE_LEN:
case CKA_ALWAYS_SENSITIVE:
case CKA_NEVER_EXTRACTABLE:
case CKA_NSS_DB:
mtype = SFTK_NEVER;
break;
/* ONCOPY */
case CKA_TOKEN:
case CKA_PRIVATE:
case CKA_MODIFIABLE:
mtype = SFTK_ONCOPY;
break;
/* SENSITIVE */
case CKA_SENSITIVE:
case CKA_EXTRACTABLE:
mtype = SFTK_SENSITIVE;
break;
/* ALWAYS */
case CKA_LABEL:
case CKA_APPLICATION:
case CKA_ID:
case CKA_SERIAL_NUMBER:
case CKA_START_DATE:
case CKA_END_DATE:
case CKA_DERIVE:
case CKA_ENCRYPT:
case CKA_DECRYPT:
case CKA_SIGN:
case CKA_VERIFY:
case CKA_SIGN_RECOVER:
case CKA_VERIFY_RECOVER:
case CKA_WRAP:
case CKA_UNWRAP:
mtype = SFTK_ALWAYS;
break;
/* DEPENDS ON CLASS */
case CKA_VALUE:
mtype = (inClass == CKO_DATA) ? SFTK_ALWAYS : SFTK_NEVER;
break;
case CKA_SUBPRIME:
/* allow the CKA_SUBPRIME to be added to dh private keys */
mtype = (inClass == CKO_PRIVATE_KEY) ? SFTK_ALWAYS : SFTK_NEVER;
break;
case CKA_SUBJECT:
mtype = (inClass == CKO_CERTIFICATE) ? SFTK_NEVER : SFTK_ALWAYS;
break;
default:
break;
}
return mtype;
}
/* decode if a particular attribute is sensitive (cannot be read
* back to the user of if the object is set to SENSITIVE) */
PRBool
sftk_isSensitive(CK_ATTRIBUTE_TYPE type, CK_OBJECT_CLASS inClass)
{
switch (type) {
/* ALWAYS */
case CKA_PRIVATE_EXPONENT:
case CKA_PRIME_1:
case CKA_PRIME_2:
case CKA_EXPONENT_1:
case CKA_EXPONENT_2:
case CKA_COEFFICIENT:
case CKA_SEED:
return PR_TRUE;
/* DEPENDS ON CLASS */
case CKA_VALUE:
/* PRIVATE and SECRET KEYS have SENSITIVE values */
return (PRBool)((inClass == CKO_PRIVATE_KEY) || (inClass == CKO_SECRET_KEY));
default:
break;
}
return PR_FALSE;
}
/*
* copy an attribute into a SECItem. Secitem is allocated in the specified
* arena.
*/
CK_RV
sftk_Attribute2SecItem(PLArenaPool *arena, SECItem *item, SFTKObject *object,
CK_ATTRIBUTE_TYPE type)
{
SFTKSessionObject *sessObject = sftk_narrowToSessionObject(object);
SFTKAttribute *attribute;
CK_RV crv = CKR_OK;
int len;
if (sessObject != NULL) {
PR_Lock(sessObject->attributeLock);
attribute = sftk_FindAttributeLocked(object, type);
}
else {
attribute = sftk_FindAttribute(object, type);
}
if (attribute == NULL) {
crv = CKR_TEMPLATE_INCOMPLETE;
}
else {
len = attribute->attrib.ulValueLen;
if (arena) {
item->data = (
unsigned char *)PORT_ArenaAlloc(arena, len);
}
else {
item->data = (
unsigned char *)PORT_Alloc(len);
}
if (item->data == NULL) {
crv = CKR_HOST_MEMORY;
}
else {
item->len = len;
PORT_Memcpy(item->data, attribute->attrib.pValue, len);
}
}
if (sessObject != NULL) {
PR_Unlock(sessObject->attributeLock);
}
else {
sftk_FreeAttribute(attribute);
}
return crv;
}
CK_RV
sftk_GetULongAttribute(SFTKObject *object, CK_ATTRIBUTE_TYPE type,
CK_ULONG *longData)
{
SFTKSessionObject *sessObject = sftk_narrowToSessionObject(object);
SFTKAttribute *attribute;
CK_RV crv = CKR_OK;
/* For a session object read the live value under the lock instead of
* copying it out; for a token object fall back to a freed copy. */
if (sessObject != NULL) {
PR_Lock(sessObject->attributeLock);
attribute = sftk_FindAttributeLocked(object, type);
}
else {
attribute = sftk_FindAttribute(object, type);
}
if (attribute == NULL) {
crv = CKR_TEMPLATE_INCOMPLETE;
}
else if (attribute->attrib.ulValueLen !=
sizeof(CK_ULONG)) {
crv = CKR_ATTRIBUTE_VALUE_INVALID;
}
else {
*longData = *(CK_ULONG *)attribute->attrib.pValue;
}
if (sessObject != NULL) {
PR_Unlock(sessObject->attributeLock);
}
else {
sftk_FreeAttribute(attribute);
}
return crv;
}
CK_RV
sftk_ReadAttribute(SFTKObject *object, CK_ATTRIBUTE_TYPE type,
unsigned char *data,
unsigned int maxLen,
unsigned int *lenp)
{
SFTKSessionObject *sessObject = sftk_narrowToSessionObject(object);
SFTKAttribute *attribute;
CK_RV crv = CKR_OK;
/* For a session object read the live value under the lock instead of
* copying it out; for a token object fall back to a freed copy. */
if (sessObject != NULL) {
PR_Lock(sessObject->attributeLock);
attribute = sftk_FindAttributeLocked(object, type);
}
else {
attribute = sftk_FindAttribute(object, type);
}
if (attribute == NULL) {
crv = CKR_TEMPLATE_INCOMPLETE;
}
else {
*lenp = attribute->attrib.ulValueLen;
if (*lenp > maxLen) {
/* normally would be CKR_BUFFER_TOO_SMALL, but
* it used with internal buffers, so if the value is
* to long, the original attribute was invalid */
crv = CKR_ATTRIBUTE_VALUE_INVALID;
}
else {
PORT_Memcpy(data, attribute->attrib.pValue, *lenp);
}
}
if (sessObject != NULL) {
PR_Unlock(sessObject->attributeLock);
}
else {
sftk_FreeAttribute(attribute);
}
return crv;
}
void
sftk_DeleteAttributeType(SFTKObject *object, CK_ATTRIBUTE_TYPE type)
{
SFTKAttribute *attribute;
SFTKSessionObject *sessObject = sftk_narrowToSessionObject(object);
if (sessObject == NULL) {
return;
}
/* Find, unlink, and destroy the live node atomically under the lock.
* Once unlinked from head[] the node is unreachable by any other
* thread (readers snapshot copies under the same lock), so destroying
* it here cannot race a concurrent reader or a second deleter. */
PR_Lock(sessObject->attributeLock);
sftkqueue_find(attribute, type, sessObject->head, sessObject->hashSize);
if (attribute != NULL) {
if (sftkqueue_is_queued(attribute, attribute->handle,
sessObject->head, sessObject->hashSize)) {
sftkqueue_delete(attribute, attribute->handle,
sessObject->head, sessObject->hashSize);
}
sftk_DestroyAttribute(attribute);
}
PR_Unlock(sessObject->attributeLock);
}
CK_RV
sftk_AddAttributeType(SFTKObject *object, CK_ATTRIBUTE_TYPE type,
const void *valPtr, CK_ULONG length)
{
SFTKAttribute *attribute;
attribute = sftk_NewAttribute(object, type, valPtr, length);
if (attribute == NULL) {
return CKR_HOST_MEMORY;
}
sftk_AddAttribute(object, attribute);
return CKR_OK;
}
/*
* ******************** Object Utilities *******************************
*/
/* must be called holding sftk_tokenKeyLock(slot) */
static SECItem *
sftk_lookupTokenKeyByHandle(SFTKSlot *slot, CK_OBJECT_HANDLE handle)
{
return (SECItem *)PL_HashTableLookup(slot->tokObjHashTable, (
void *)(uintptr_t)handle
);
}
/*
* use the refLock. This operations should be very rare, so the added
* contention on the ref lock should be lower than the overhead of adding
* a new lock. We use separate functions for this just in case I'm wrong.
*/
static void
sftk_tokenKeyLock(SFTKSlot *slot)
{
SKIP_AFTER_FORK(PR_Lock(slot->objectLock));
}
static void
sftk_tokenKeyUnlock(SFTKSlot *slot)
{
SKIP_AFTER_FORK(PR_Unlock(slot->objectLock));
}
static PRIntn
sftk_freeHashItem(PLHashEntry *entry, PRIntn index, void *arg)
{
SECItem *item = (SECItem *)entry->value;
SECITEM_FreeItem(item, PR_TRUE);
return HT_ENUMERATE_NEXT;
}
CK_RV
SFTK_ClearTokenKeyHashTable(SFTKSlot *slot)
{
sftk_tokenKeyLock(slot);
PORT_Assert(!slot->present);
PL_HashTableEnumerateEntries(slot->tokObjHashTable, sftk_freeHashItem, NULL);
sftk_tokenKeyUnlock(slot);
return CKR_OK;
}
/* allocation hooks that allow us to recycle old object structures */
static SFTKObjectFreeList sessionObjectList = { NULL, NULL, 0 };
static SFTKObjectFreeList tokenObjectList = { NULL, NULL, 0 };
SFTKObject *
sftk_GetObjectFromList(PRBool *hasLocks, PRBool optimizeSpace,
SFTKObjectFreeList *list, unsigned int hashSize, PRBool isSessionObject)
{
SFTKObject *object;
int size = 0;
if (!optimizeSpace) {
PR_Lock(list->lock);
object = list->head;
if (object) {
list->head = object->next;
list->count--;
}
PR_Unlock(list->lock);
if (object) {
// As a safeguard against misuse of the library, ensure we don't
// hand out live objects that somehow land in the free list.
PORT_Assert(object->refCount == 0);
if (object->refCount == 0) {
object->next = object->prev = NULL;
*hasLocks = PR_TRUE;
return object;
}
}
}
size = isSessionObject ? sizeof(SFTKSessionObject) + hashSize * sizeof(SFTKAttribute *) : sizeof(SFTKTokenObject);
object = (SFTKObject *)PORT_ZAlloc(size);
if (isSessionObject && object) {
((SFTKSessionObject *)object)->hashSize = hashSize;
}
*hasLocks = PR_FALSE;
return object;
}
static void
sftk_PutObjectToList(SFTKObject *object, SFTKObjectFreeList *list,
PRBool isSessionObject)
{
/* the code below is equivalent to :
* optimizeSpace = isSessionObject ? object->optimizeSpace : PR_FALSE;
* just faster.
*/
PRBool optimizeSpace = isSessionObject &&
((SFTKSessionObject *)object)->optimizeSpace;
if (object->refLock && !optimizeSpace) {
PR_Lock(list->lock);
if (list->count < MAX_OBJECT_LIST_SIZE) {
object->next = list->head;
list->head = object;
list->count++;
PR_Unlock(list->lock);
return;
}
PR_Unlock(list->lock);
}
if (isSessionObject) {
SFTKSessionObject *so = (SFTKSessionObject *)object;
PR_DestroyLock(so->attributeLock);
so->attributeLock = NULL;
}
if (object->refLock) {
PR_DestroyLock(object->refLock);
object->refLock = NULL;
}
PORT_Free(object);
}
static SFTKObject *
sftk_freeObjectData(SFTKObject *object)
{
SFTKObject *next = object->next;
PORT_Free(object);
return next;
}
static void
sftk_InitFreeList(SFTKObjectFreeList *list)
{
if (!list->lock) {
list->lock = PR_NewLock();
}
}
void
sftk_InitFreeLists(void)
{
sftk_InitFreeList(&sessionObjectList);
sftk_InitFreeList(&tokenObjectList);
}
static void
sftk_CleanupFreeList(SFTKObjectFreeList *list, PRBool isSessionList)
{
SFTKObject *object;
if (!list->lock) {
return;
}
SKIP_AFTER_FORK(PR_Lock(list->lock));
for (object = list->head; object != NULL;
object = sftk_freeObjectData(object)) {
PR_DestroyLock(object->refLock);
if (isSessionList) {
PR_DestroyLock(((SFTKSessionObject *)object)->attributeLock);
}
}
list->count = 0;
list->head = NULL;
SKIP_AFTER_FORK(PR_Unlock(list->lock));
SKIP_AFTER_FORK(PR_DestroyLock(list->lock));
list->lock = NULL;
}
void
sftk_CleanupFreeLists(void)
{
sftk_CleanupFreeList(&sessionObjectList, PR_TRUE);
sftk_CleanupFreeList(&tokenObjectList, PR_FALSE);
}
/*
* Create a new object
*/
SFTKObject *
sftk_NewObject(SFTKSlot *slot)
{
SFTKObject *object;
SFTKSessionObject *sessObject;
PRBool hasLocks = PR_FALSE;
unsigned int i;
unsigned int hashSize = 0;
hashSize = (slot->optimizeSpace) ? SPACE_ATTRIBUTE_HASH_SIZE : TIME_ATTRIBUTE_HASH_SIZE;
object = sftk_GetObjectFromList(&hasLocks, slot->optimizeSpace,
&sessionObjectList, hashSize, PR_TRUE);
if (object == NULL) {
return NULL;
}
sessObject = (SFTKSessionObject *)object;
sessObject->nextAttr = 0;
for (i = 0; i < MAX_OBJS_ATTRS; i++) {
sessObject->attrList[i].attrib.pValue = NULL;
sessObject->attrList[i].freeData = PR_FALSE;
}
sessObject->optimizeSpace = slot->optimizeSpace;
object->handle = 0;
object->next = object->prev = NULL;
object->slot = slot;
/* set up the validation flags */
object->validation_value = 0;
object->validation_attribute.next = NULL;
object->validation_attribute.prev = NULL;
object->validation_attribute.freeAttr = PR_FALSE;
object->validation_attribute.freeData = PR_FALSE;
object->validation_attribute.handle = CKA_OBJECT_VALIDATION_FLAGS;
object->validation_attribute.attrib.type = CKA_OBJECT_VALIDATION_FLAGS;
object->validation_attribute.attrib.pValue = &object->validation_value;
object->validation_attribute.attrib.ulValueLen = sizeof(object->validation_value);
/* initialize the FIPS flag properly */
sftk_setFIPS(object, sftk_isFIPS(slot->slotID));
object->source = SFTK_SOURCE_DEFAULT;
object->refCount = 1;
object->type = SFTK_SESSION_OBJECT_TYPE;
sessObject->sessionList.next = NULL;
sessObject->sessionList.prev = NULL;
sessObject->sessionList.parent = object;
sessObject->session = NULL;
sessObject->wasDerived = PR_FALSE;
if (!hasLocks)
object->refLock = PR_NewLock();
if (object->refLock == NULL) {
PORT_Free(object);
return NULL;
}
if (!hasLocks)
sessObject->attributeLock = PR_NewLock();
if (sessObject->attributeLock == NULL) {
PR_DestroyLock(object->refLock);
PORT_Free(object);
return NULL;
}
for (i = 0; i < sessObject->hashSize; i++) {
sessObject->head[i] = NULL;
}
object->objectInfo = NULL;
object->infoFree = NULL;
return object;
}
static CK_RV
sftk_DestroySessionObjectData(SFTKSessionObject *so)
{
int i;
for (i = 0; i < MAX_OBJS_ATTRS; i++) {
unsigned char *value = so->attrList[i].attrib.pValue;
if (value) {
PORT_Memset(value, 0, so->attrList[i].attrib.ulValueLen);
if (so->attrList[i].freeData) {
PORT_Free(value);
}
so->attrList[i].attrib.pValue = NULL;
so->attrList[i].freeData = PR_FALSE;
}
}
/* PR_DestroyLock(so->attributeLock);*/
return CKR_OK;
}
/*
* free all the data associated with an object. Object reference count must
* be 'zero'.
*/
static CK_RV
sftk_DestroyObject(SFTKObject *object)
{
CK_RV crv = CKR_OK;
SFTKSessionObject *so = sftk_narrowToSessionObject(object);
SFTKTokenObject *to = sftk_narrowToTokenObject(object);
PORT_Assert(object->refCount == 0);
/* delete the database value */
if (to) {
if (to->dbKey.data) {
PORT_Free(to->dbKey.data);
to->dbKey.data = NULL;
}
}
if (so) {
sftk_DestroySessionObjectData(so);
}
if (object->objectInfo) {
(*object->infoFree)(object->objectInfo);
object->objectInfo = NULL;
object->infoFree = NULL;
}
if (so) {
sftk_PutObjectToList(object, &sessionObjectList, PR_TRUE);
} else {
sftk_PutObjectToList(object, &tokenObjectList, PR_FALSE);
}
return crv;
}
void
sftk_ReferenceObject(SFTKObject *object)
{
PR_Lock(object->refLock);
PORT_Assert(object->refCount > 0);
object->refCount++;
PR_Unlock(object->refLock);
}
static SFTKObject *
sftk_ObjectFromHandleOnSlot(CK_OBJECT_HANDLE handle, SFTKSlot *slot)
{
SFTKObject *object;
PRUint32 index = sftk_hash(handle, slot->sessObjHashSize);
if (sftk_isToken(handle)) {
return sftk_NewTokenObject(slot, NULL, handle);
}
PR_Lock(slot->objectLock);
sftkqueue_find2(object, handle, index, slot->sessObjHashTable);
if (object) {
sftk_ReferenceObject(object);
}
PR_Unlock(slot->objectLock);
return (object);
}
/*
* look up and object structure from a handle. OBJECT_Handles only make
* sense in terms of a given session. make a reference to that object
* structure returned.
*/
SFTKObject *
sftk_ObjectFromHandle(CK_OBJECT_HANDLE handle, SFTKSession *session)
{
SFTKSlot *slot = sftk_SlotFromSession(session);
return sftk_ObjectFromHandleOnSlot(handle, slot);
}
/*
* release a reference to an object handle
*/
SFTKFreeStatus
sftk_FreeObject(SFTKObject *object)
{
PRBool destroy = PR_FALSE;
CK_RV crv;
PR_Lock(object->refLock);
if (object->refCount == 1)
destroy = PR_TRUE;
object->refCount--;
PR_Unlock(object->refLock);
if (destroy) {
crv = sftk_DestroyObject(object);
if (crv != CKR_OK) {
return SFTK_DestroyFailure;
}
return SFTK_Destroyed;
}
return SFTK_Busy;
}
/* find the next available object handle that isn't currently in use */
/* NOTE: This function could loop forever if we've exhausted all
* 3^31-1 handles. This is highly unlikely (NSS has been running for
* decades with this code) uless we start increasing the size of the
* SFTK_TOKEN_MASK (which is just the high bit currently). */
CK_OBJECT_HANDLE
sftk_getNextHandle(SFTKSlot *slot)
{
CK_OBJECT_HANDLE handle;
SFTKObject *duplicateObject = NULL;
do {
PRUint32 wrappedAround;
duplicateObject = NULL;
PR_Lock(slot->objectLock);
wrappedAround = slot->sessionObjectHandleCount & SFTK_TOKEN_MASK;
handle = slot->sessionObjectHandleCount & ~SFTK_TOKEN_MASK;
if (!handle) /* don't allow zero handle */
handle = NSC_MIN_SESSION_OBJECT_HANDLE;
slot->sessionObjectHandleCount = (handle + 1U) | wrappedAround;
/* Is there already a session object with this handle? */
if (wrappedAround) {
sftkqueue_find(duplicateObject, handle, slot->sessObjHashTable,
slot->sessObjHashSize);
}
PR_Unlock(slot->objectLock);
} while (duplicateObject != NULL);
return handle;
}
/*
* add an object to a slot and session queue. These two functions
* adopt the object.
*/
void
sftk_AddSlotObject(SFTKSlot *slot, SFTKObject *object)
{
PRUint32 index = sftk_hash(object->handle, slot->sessObjHashSize);
sftkqueue_init_element(object);
PR_Lock(slot->objectLock);
sftkqueue_add2(object, object->handle, index, slot->sessObjHashTable);
PR_Unlock(slot->objectLock);
}
void
sftk_AddObject(SFTKSession *session, SFTKObject *object)
{
SFTKSlot *slot = sftk_SlotFromSession(session);
SFTKSessionObject *so = sftk_narrowToSessionObject(object);
if (so) {
PR_Lock(session->objectLock);
sftkqueue_add(&so->sessionList, 0, session->objects, 0);
so->session = session;
PR_Unlock(session->objectLock);
}
sftk_AddSlotObject(slot, object);
sftk_ReferenceObject(object);
}
/*
* delete an object from a slot and session queue
*/
CK_RV
sftk_DeleteObject(SFTKSession *session, SFTKObject *object)
{
SFTKSlot *slot = sftk_SlotFromSession(session);
SFTKSessionObject *so = sftk_narrowToSessionObject(object);
CK_RV crv = CKR_OK;
PRUint32 index = sftk_hash(object->handle, slot->sessObjHashSize);
/* Handle Token case */
if (so && so->session) {
/* Atomically claim the right to remove this object. Two threads
* can race here via NSC_DestroyObject after both succeed in
* sftk_ObjectFromHandle; without the claim each would unlink
* the queue entry and drop the queue's reference, leading to a
* double sftk_FreeObject (and on the second pass, a use-after-
* free when sftk_FreeObject reads object->refLock). */
PRBool ownsRemove = PR_FALSE;
PR_Lock(slot->objectLock);
if (object->next || object->prev ||
slot->sessObjHashTable[index] == object) {
sftkqueue_delete2(object, object->handle, index,
slot->sessObjHashTable);
/* sftkqueue_delete2 patches the neighbour pointers but
* leaves object->next/prev pointing at their old neighbours.
* Clear them inside the slot lock so a racing thread that
* acquires the lock next sees an empty-looking object and
* doesn't re-claim ownership, which would lead to a double
* sftk_FreeObject of the queue's reference. */
sftkqueue_clear_deleted_element(object);
ownsRemove = PR_TRUE;
}
PR_Unlock(slot->objectLock);
if (ownsRemove) {
session = so->session;
PR_Lock(session->objectLock);
sftkqueue_delete(&so->sessionList, 0, session->objects, 0);
PR_Unlock(session->objectLock);
sftk_FreeObject(object); /* drop the queue's reference */
}
} else {
SFTKDBHandle *handle = sftk_getDBForTokenObject(slot, object->handle);
#ifdef DEBUG
SFTKTokenObject *to = sftk_narrowToTokenObject(object);
PORT_Assert(to);
#endif
crv = sftkdb_DestroyObject(handle, object->handle, object->objclass);
sftk_freeDB(handle);
}
return crv;
}
/*
* Token objects don't explicitly store their attributes, so we need to know
* what attributes make up a particular token object before we can copy it.
* below are the tables by object type.
*/
static const CK_ATTRIBUTE_TYPE commonAttrs[] = {
CKA_CLASS, CKA_TOKEN, CKA_PRIVATE, CKA_LABEL, CKA_MODIFIABLE
};
static const CK_ULONG commonAttrsCount =
sizeof(commonAttrs) / sizeof(commonAttrs[0]);
static const CK_ATTRIBUTE_TYPE commonKeyAttrs[] = {
CKA_ID, CKA_START_DATE, CKA_END_DATE, CKA_DERIVE, CKA_LOCAL, CKA_KEY_TYPE
};
static const CK_ULONG commonKeyAttrsCount =
sizeof(commonKeyAttrs) / sizeof(commonKeyAttrs[0]);
static const CK_ATTRIBUTE_TYPE secretKeyAttrs[] = {
CKA_SENSITIVE, CKA_EXTRACTABLE, CKA_ENCRYPT, CKA_DECRYPT, CKA_SIGN,
CKA_VERIFY, CKA_WRAP, CKA_UNWRAP, CKA_VALUE
};
static const CK_ULONG secretKeyAttrsCount =
sizeof(secretKeyAttrs) / sizeof(secretKeyAttrs[0]);
static const CK_ATTRIBUTE_TYPE commonPubKeyAttrs[] = {
CKA_ENCRYPT, CKA_VERIFY, CKA_VERIFY_RECOVER, CKA_WRAP, CKA_SUBJECT
};
static const CK_ULONG commonPubKeyAttrsCount =
sizeof(commonPubKeyAttrs) / sizeof(commonPubKeyAttrs[0]);
static const CK_ATTRIBUTE_TYPE rsaPubKeyAttrs[] = {
CKA_MODULUS, CKA_PUBLIC_EXPONENT
};
static const CK_ULONG rsaPubKeyAttrsCount =
sizeof(rsaPubKeyAttrs) / sizeof(rsaPubKeyAttrs[0]);
static const CK_ATTRIBUTE_TYPE dsaPubKeyAttrs[] = {
CKA_SUBPRIME, CKA_PRIME, CKA_BASE, CKA_VALUE
};
static const CK_ULONG dsaPubKeyAttrsCount =
sizeof(dsaPubKeyAttrs) / sizeof(dsaPubKeyAttrs[0]);
static const CK_ATTRIBUTE_TYPE dhPubKeyAttrs[] = {
CKA_PRIME, CKA_BASE, CKA_VALUE
};
static const CK_ULONG dhPubKeyAttrsCount =
sizeof(dhPubKeyAttrs) / sizeof(dhPubKeyAttrs[0]);
static const CK_ATTRIBUTE_TYPE ecPubKeyAttrs[] = {
CKA_EC_PARAMS, CKA_EC_POINT
};
static const CK_ULONG ecPubKeyAttrsCount =
sizeof(ecPubKeyAttrs) / sizeof(ecPubKeyAttrs[0]);
static const CK_ATTRIBUTE_TYPE mldsaPubKeyAttrs[] = {
CKA_PARAMETER_SET, CKA_VALUE
};
static const CK_ULONG mldsaPubKeyAttrsCount = PR_ARRAY_SIZE(mldsaPubKeyAttrs);
static const CK_ATTRIBUTE_TYPE commonPrivKeyAttrs[] = {
CKA_DECRYPT, CKA_SIGN, CKA_SIGN_RECOVER, CKA_UNWRAP, CKA_SUBJECT,
CKA_SENSITIVE, CKA_EXTRACTABLE, CKA_NSS_DB, CKA_PUBLIC_KEY_INFO
};
static const CK_ULONG commonPrivKeyAttrsCount =
sizeof(commonPrivKeyAttrs) / sizeof(commonPrivKeyAttrs[0]);
static const CK_ATTRIBUTE_TYPE rsaPrivKeyAttrs[] = {
CKA_MODULUS, CKA_PUBLIC_EXPONENT, CKA_PRIVATE_EXPONENT,
CKA_PRIME_1, CKA_PRIME_2, CKA_EXPONENT_1, CKA_EXPONENT_2, CKA_COEFFICIENT
};
static const CK_ULONG rsaPrivKeyAttrsCount =
sizeof(rsaPrivKeyAttrs) / sizeof(rsaPrivKeyAttrs[0]);
static const CK_ATTRIBUTE_TYPE dsaPrivKeyAttrs[] = {
CKA_SUBPRIME, CKA_PRIME, CKA_BASE, CKA_VALUE
};
static const CK_ULONG dsaPrivKeyAttrsCount =
sizeof(dsaPrivKeyAttrs) / sizeof(dsaPrivKeyAttrs[0]);
static const CK_ATTRIBUTE_TYPE dhPrivKeyAttrs[] = {
CKA_PRIME, CKA_BASE, CKA_VALUE
};
static const CK_ULONG dhPrivKeyAttrsCount =
sizeof(dhPrivKeyAttrs) / sizeof(dhPrivKeyAttrs[0]);
static const CK_ATTRIBUTE_TYPE ecPrivKeyAttrs[] = {
CKA_EC_PARAMS, CKA_VALUE
};
static const CK_ULONG ecPrivKeyAttrsCount =
sizeof(ecPrivKeyAttrs) / sizeof(ecPrivKeyAttrs[0]);
static const CK_ATTRIBUTE_TYPE mldsaPrivKeyAttrs[] = {
CKA_PARAMETER_SET, CKA_VALUE, CKA_SEED
};
static const CK_ULONG mldsaPrivKeyAttrsCount = PR_ARRAY_SIZE(mldsaPrivKeyAttrs);
static const CK_ATTRIBUTE_TYPE certAttrs[] = {
CKA_CERTIFICATE_TYPE, CKA_VALUE, CKA_SUBJECT, CKA_ISSUER, CKA_SERIAL_NUMBER
};
static const CK_ULONG certAttrsCount =
sizeof(certAttrs) / sizeof(certAttrs[0]);
static const CK_ATTRIBUTE_TYPE nssTrustAttrs[] = {
CKA_ISSUER, CKA_SERIAL_NUMBER, CKA_NSS_CERT_SHA1_HASH,
CKA_NSS_CERT_MD5_HASH, CKA_NSS_TRUST_SERVER_AUTH, CKA_NSS_TRUST_CLIENT_AUTH,
CKA_NSS_TRUST_EMAIL_PROTECTION, CKA_NSS_TRUST_CODE_SIGNING,
CKA_NSS_TRUST_STEP_UP_APPROVED
};
static const CK_ULONG nssTrustAttrsCount =
sizeof(nssTrustAttrs) / sizeof(nssTrustAttrs[0]);
static const CK_ATTRIBUTE_TYPE trustAttrs[] = {
CKA_ISSUER, CKA_SERIAL_NUMBER, CKA_HASH_OF_CERTIFICATE,
CKA_NAME_HASH_ALGORITHM, CKA_PKCS_TRUST_SERVER_AUTH,
CKA_PKCS_TRUST_CLIENT_AUTH, CKA_PKCS_TRUST_EMAIL_PROTECTION,
CKA_PKCS_TRUST_CODE_SIGNING
};
static const CK_ULONG trustAttrsCount =
sizeof(trustAttrs) / sizeof(trustAttrs[0]);
static const CK_ATTRIBUTE_TYPE smimeAttrs[] = {
CKA_SUBJECT, CKA_NSS_EMAIL, CKA_NSS_SMIME_TIMESTAMP, CKA_VALUE
};
static const CK_ULONG smimeAttrsCount =
sizeof(smimeAttrs) / sizeof(smimeAttrs[0]);
static const CK_ATTRIBUTE_TYPE crlAttrs[] = {
CKA_SUBJECT, CKA_VALUE, CKA_NSS_URL, CKA_NSS_KRL
};
static const CK_ULONG crlAttrsCount =
sizeof(crlAttrs) / sizeof(crlAttrs[0]);
/* copy an object based on it's table */
CK_RV
stfk_CopyTokenAttributes(SFTKObject *destObject, SFTKTokenObject *src_to,
const CK_ATTRIBUTE_TYPE *attrArray, CK_ULONG attrCount)
{
SFTKAttribute *attribute;
SFTKAttribute *newAttribute;
CK_RV crv = CKR_OK;
unsigned int i;
for (i = 0; i < attrCount; i++) {
if (!sftk_hasAttribute(destObject, attrArray[i])) {
attribute = sftk_FindAttribute(&src_to->obj, attrArray[i]);
if (!attribute) {
continue; /* return CKR_ATTRIBUTE_VALUE_INVALID; */
}
/* we need to copy the attribute since each attribute
* only has one set of link list pointers */
newAttribute = sftk_NewAttribute(destObject,
sftk_attr_expand(&attribute->attrib));
sftk_FreeAttribute(attribute); /* free the old attribute */
if (!newAttribute) {
return CKR_HOST_MEMORY;
}
sftk_AddAttribute(destObject, newAttribute);
}
}
return crv;
}
CK_RV
stfk_CopyTokenPrivateKey(SFTKObject *destObject, SFTKTokenObject *src_to)
{
CK_RV crv;
CK_KEY_TYPE key_type;
SFTKAttribute *attribute;
/* copy the common attributes for all keys first */
crv = stfk_CopyTokenAttributes(destObject, src_to, commonKeyAttrs,
commonKeyAttrsCount);
if (crv != CKR_OK) {
goto fail;
}
/* copy the common attributes for all private keys next */
crv = stfk_CopyTokenAttributes(destObject, src_to, commonPrivKeyAttrs,
commonPrivKeyAttrsCount);
if (crv != CKR_OK) {
goto fail;
}
attribute = sftk_FindAttribute(&src_to->obj, CKA_KEY_TYPE);
PORT_Assert(attribute); /* if it wasn't here, ww should have failed
* copying the common attributes */
if (!attribute) {
/* OK, so CKR_ATTRIBUTE_VALUE_INVALID is the immediate error, but
* the fact is, the only reason we couldn't get the attribute would
* be a memory error or database error (an error in the 'device').
* if we have a database error code, we could return it here */
crv = CKR_DEVICE_ERROR;
goto fail;
}
key_type = *(CK_KEY_TYPE *)attribute->attrib.pValue;
sftk_FreeAttribute(attribute);
/* finally copy the attributes for various private key types */
switch (key_type) {
case CKK_RSA:
crv = stfk_CopyTokenAttributes(destObject, src_to, rsaPrivKeyAttrs,
rsaPrivKeyAttrsCount);
break;
case CKK_DSA:
crv = stfk_CopyTokenAttributes(destObject, src_to, dsaPrivKeyAttrs,
dsaPrivKeyAttrsCount);
break;
case CKK_ML_DSA:
crv = stfk_CopyTokenAttributes(destObject, src_to, mldsaPrivKeyAttrs,
mldsaPrivKeyAttrsCount);
break;
case CKK_DH:
crv = stfk_CopyTokenAttributes(destObject, src_to, dhPrivKeyAttrs,
dhPrivKeyAttrsCount);
break;
case CKK_EC:
crv = stfk_CopyTokenAttributes(destObject, src_to, ecPrivKeyAttrs,
ecPrivKeyAttrsCount);
break;
default:
crv = CKR_DEVICE_ERROR; /* shouldn't happen unless we store more types
* of token keys into our database. */
}
fail:
return crv;
}
CK_RV
stfk_CopyTokenPublicKey(SFTKObject *destObject, SFTKTokenObject *src_to)
{
CK_RV crv;
CK_KEY_TYPE key_type;
SFTKAttribute *attribute;
/* copy the common attributes for all keys first */
crv = stfk_CopyTokenAttributes(destObject, src_to, commonKeyAttrs,
commonKeyAttrsCount);
if (crv != CKR_OK) {
goto fail;
}
/* copy the common attributes for all public keys next */
crv = stfk_CopyTokenAttributes(destObject, src_to, commonPubKeyAttrs,
commonPubKeyAttrsCount);
if (crv != CKR_OK) {
goto fail;
}
attribute = sftk_FindAttribute(&src_to->obj, CKA_KEY_TYPE);
PORT_Assert(attribute); /* if it wasn't here, ww should have failed
* copying the common attributes */
if (!attribute) {
/* OK, so CKR_ATTRIBUTE_VALUE_INVALID is the immediate error, but
* the fact is, the only reason we couldn't get the attribute would
* be a memory error or database error (an error in the 'device').
* if we have a database error code, we could return it here */
crv = CKR_DEVICE_ERROR;
goto fail;
}
key_type = *(CK_KEY_TYPE *)attribute->attrib.pValue;
sftk_FreeAttribute(attribute);
/* finally copy the attributes for various public key types */
switch (key_type) {
case CKK_RSA:
crv = stfk_CopyTokenAttributes(destObject, src_to, rsaPubKeyAttrs,
rsaPubKeyAttrsCount);
break;
case CKK_DSA:
crv = stfk_CopyTokenAttributes(destObject, src_to, dsaPubKeyAttrs,
dsaPubKeyAttrsCount);
break;
case CKK_ML_DSA:
crv = stfk_CopyTokenAttributes(destObject, src_to, mldsaPubKeyAttrs,
mldsaPubKeyAttrsCount);
break;
case CKK_DH:
crv = stfk_CopyTokenAttributes(destObject, src_to, dhPubKeyAttrs,
dhPubKeyAttrsCount);
break;
case CKK_EC:
crv = stfk_CopyTokenAttributes(destObject, src_to, ecPubKeyAttrs,
ecPubKeyAttrsCount);
break;
default:
crv = CKR_DEVICE_ERROR; /* shouldn't happen unless we store more types
* of token keys into our database. */
}
fail:
return crv;
}
CK_RV
stfk_CopyTokenSecretKey(SFTKObject *destObject, SFTKTokenObject *src_to)
{
CK_RV crv;
crv = stfk_CopyTokenAttributes(destObject, src_to, commonKeyAttrs,
commonKeyAttrsCount);
if (crv != CKR_OK) {
goto fail;
}
crv = stfk_CopyTokenAttributes(destObject, src_to, secretKeyAttrs,
secretKeyAttrsCount);
fail:
return crv;
}
/*
* Copy a token object. We need to explicitly copy the relevant
* attributes since token objects don't store those attributes in
* the token itself.
*/
CK_RV
sftk_CopyTokenObject(SFTKObject *destObject, SFTKObject *srcObject)
{
SFTKTokenObject *src_to = sftk_narrowToTokenObject(srcObject);
CK_RV crv;
PORT_Assert(src_to);
if (src_to == NULL) {
return CKR_DEVICE_ERROR; /* internal state inconsistant */
}
crv = stfk_CopyTokenAttributes(destObject, src_to, commonAttrs,
commonAttrsCount);
if (crv != CKR_OK) {
goto fail;
}
switch (src_to->obj.objclass) {
case CKO_CERTIFICATE:
crv = stfk_CopyTokenAttributes(destObject, src_to, certAttrs,
certAttrsCount);
break;
case CKO_NSS_TRUST:
crv = stfk_CopyTokenAttributes(destObject, src_to, nssTrustAttrs,
nssTrustAttrsCount);
break;
case CKO_TRUST:
crv = stfk_CopyTokenAttributes(destObject, src_to, trustAttrs,
trustAttrsCount);
break;
case CKO_NSS_SMIME:
crv = stfk_CopyTokenAttributes(destObject, src_to, smimeAttrs,
smimeAttrsCount);
break;
case CKO_NSS_CRL:
crv = stfk_CopyTokenAttributes(destObject, src_to, crlAttrs,
crlAttrsCount);
break;
case CKO_PRIVATE_KEY:
crv = stfk_CopyTokenPrivateKey(destObject, src_to);
break;
case CKO_PUBLIC_KEY:
crv = stfk_CopyTokenPublicKey(destObject, src_to);
break;
case CKO_SECRET_KEY:
crv = stfk_CopyTokenSecretKey(destObject, src_to);
break;
default:
crv = CKR_DEVICE_ERROR; /* shouldn't happen unless we store more types
* of token keys into our database. */
}
fail:
return crv;
}
/*
* copy the attributes from one object to another. Don't overwrite existing
* attributes. NOTE: This is a pretty expensive operation since it
* grabs the attribute locks for the src object for a *long* time.
*/
CK_RV
sftk_CopyObject(SFTKObject *destObject, SFTKObject *srcObject)
{
SFTKAttribute *attribute;
SFTKSessionObject *src_so = sftk_narrowToSessionObject(srcObject);
SFTKSessionObject *dest_so = sftk_narrowToSessionObject(destObject);
unsigned int i;
destObject->validation_value = srcObject->validation_value;
destObject->source = srcObject->source;
if (src_so == NULL) {
return sftk_CopyTokenObject(destObject, srcObject);
}
PORT_Assert(dest_so != NULL);
if (dest_so == NULL) {
return CKR_ARGUMENTS_BAD;
}
PR_Lock(src_so->attributeLock);
for (i = 0; i < src_so->hashSize; i++) {
attribute = src_so->head[i];
do {
if (attribute) {
SFTKAttribute *existing;
sftkqueue_find(existing, attribute->handle,
dest_so->head, dest_so->hashSize);
if (!existing) {
/* we need to copy the attribute since each attribute
* only has one set of link list pointers */
SFTKAttribute *newAttribute = sftk_InitAttribute(
dest_so, dest_so->nextAttr++,
sftk_attr_expand(&attribute->attrib));
if (newAttribute == NULL) {
PR_Unlock(src_so->attributeLock);
return CKR_HOST_MEMORY;
}
sftkqueue_add(newAttribute, newAttribute->handle,
dest_so->head, dest_so->hashSize);
}
attribute = attribute->next;
}
} while (attribute != NULL);
}
PR_Unlock(src_so->attributeLock);
return CKR_OK;
}
/*
* ******************** Search Utilities *******************************
*/
/* add an object to a search list */
CK_RV
AddToList(SFTKObjectListElement **list, SFTKObject *object)
{
SFTKObjectListElement *newElem =
(SFTKObjectListElement *)PORT_Alloc(sizeof(SFTKObjectListElement));
if (newElem == NULL)
return CKR_HOST_MEMORY;
newElem->next = *list;
newElem->object = object;
sftk_ReferenceObject(object);
*list = newElem;
return CKR_OK;
}
/* return true if the object matches the template */
PRBool
sftk_objectMatch(SFTKObject *object, CK_ATTRIBUTE_PTR theTemplate, int count)
{
int i;
for (i = 0; i < count; i++) {
SFTKAttribute *attribute = sftk_FindAttribute(object, theTemplate[i].type);
if (attribute == NULL) {
return PR_FALSE;
}
if (attribute->attrib.ulValueLen == theTemplate[i].ulValueLen) {
if (PORT_Memcmp(attribute->attrib.pValue, theTemplate[i].pValue,
theTemplate[i].ulValueLen) == 0) {
sftk_FreeAttribute(attribute);
continue;
}
}
sftk_FreeAttribute(attribute);
return PR_FALSE;
}
return PR_TRUE;
}
/* search through all the objects in the queue and return the template matches
* in the object list.
*/
CK_RV
sftk_searchObjectList(SFTKSearchResults *search, SFTKObject **head,
unsigned int size, PRLock *lock, CK_ATTRIBUTE_PTR theTemplate,
int count, PRBool isLoggedIn)
{
unsigned int i;
SFTKObject *object;
CK_RV crv = CKR_OK;
PR_Lock(lock);
for (i = 0; i < size; i++) {
for (object = head[i]; object != NULL; object = object->next) {
if (sftk_objectMatch(object, theTemplate, count)) {
/* don't return objects that aren't yet visible */
if ((!isLoggedIn) && sftk_isTrue(object, CKA_PRIVATE))
continue;
sftk_addHandle(search, object->handle);
}
}
}
PR_Unlock(lock);
return crv;
}
/*
* free a single list element. Return the Next object in the list.
*/
SFTKObjectListElement *
sftk_FreeObjectListElement(SFTKObjectListElement *objectList)
{
SFTKObjectListElement *ol = objectList->next;
sftk_FreeObject(objectList->object);
PORT_Free(objectList);
return ol;
}
/* free an entire object list */
void
sftk_FreeObjectList(SFTKObjectListElement *objectList)
{
SFTKObjectListElement *ol;
for (ol = objectList; ol != NULL; ol = sftk_FreeObjectListElement(ol)) {
}
}
/*
* free a search structure
*/
void
sftk_FreeSearch(SFTKSearchResults *search)
{
if (search->handles) {
PORT_Free(search->handles);
}
PORT_Free(search);
}
/*
* ******************** Session Utilities *******************************
*/
/* update the sessions state based in it's flags and wether or not it's
* logged in */
void
sftk_update_state(SFTKSlot *slot, SFTKSession *session)
{
PR_Lock(slot->slotLock);
if (slot->isLoggedIn) {
if (slot->ssoLoggedIn) {
session->info.state = CKS_RW_SO_FUNCTIONS;
} else if (session->info.flags & CKF_RW_SESSION) {
session->info.state = CKS_RW_USER_FUNCTIONS;
} else {
session->info.state = CKS_RO_USER_FUNCTIONS;
}
} else {
if (session->info.flags & CKF_RW_SESSION) {
session->info.state = CKS_RW_PUBLIC_SESSION;
} else {
session->info.state = CKS_RO_PUBLIC_SESSION;
}
}
PR_Unlock(slot->slotLock);
}
/* update the state of all the sessions on a slot */
void
sftk_update_all_states(SFTKSlot *slot)
{
unsigned int i;
SFTKSession *session;
for (i = 0; i < slot->sessHashSize; i++) {
PRLock *lock = SFTK_HEAD_BUCKET_LOCK(slot, i);
PR_Lock(lock);
for (session = slot->head[i]; session; session = session->next) {
sftk_update_state(slot, session);
}
PR_Unlock(lock);
}
}
/*
* context are cipher and digest contexts that are associated with a session
*/
void
sftk_FreeContext(SFTKSessionContext *context)
{
if (context->cipherInfo) {
(*context->destroy)(context->cipherInfo, PR_TRUE);
}
if (context->hashInfo) {
(*context->hashdestroy)(context->hashInfo, PR_TRUE);
}
if (context->key) {
sftk_FreeObject(context->key);
context->key = NULL;
}
if (context->signature) {
SECITEM_FreeItem(context->signature, PR_TRUE);
context->signature = NULL;
}
PORT_Free(context);
}
/*
* Init a new session. NOTE: The session handle is not set, and the
* session is not added to the slot's session queue.
*/
CK_RV
sftk_InitSession(SFTKSession *session, SFTKSlot *slot, CK_SLOT_ID slotID,
CK_NOTIFY notify, CK_VOID_PTR pApplication, CK_FLAGS flags)
{
session->next = session->prev = NULL;
session->refCount = 1;
session->enc_context = NULL;
session->hash_context = NULL;
session->search = NULL;
session->objectIDCount = 1;
session->objectLock = PR_NewLock();
if (session->objectLock == NULL) {
return CKR_HOST_MEMORY;
}
session->objects[0] = NULL;
session->slot = slot;
session->notify = notify;
session->appData = pApplication;
session->info.flags = flags;
session->info.slotID = slotID;
session->info.ulDeviceError = 0;
sftk_update_state(slot, session);
/* no ops completed yet, so the last one couldn't be a FIPS op */
session->lastOpWasFIPS = PR_FALSE;
return CKR_OK;
}
/*
* Create a new session and init it.
*/
SFTKSession *
sftk_NewSession(CK_SLOT_ID slotID, CK_NOTIFY notify, CK_VOID_PTR pApplication,
CK_FLAGS flags)
{
SFTKSession *session;
SFTKSlot *slot = sftk_SlotFromID(slotID, PR_FALSE);
CK_RV crv;
if (slot == NULL)
return NULL;
session = (SFTKSession *)PORT_Alloc(sizeof(SFTKSession));
if (session == NULL)
return NULL;
crv = sftk_InitSession(session, slot, slotID, notify, pApplication, flags);
if (crv != CKR_OK) {
PORT_Free(session);
return NULL;
}
return session;
}
/* free all the data associated with a session. */
void
sftk_ClearSession(SFTKSession *session)
{
SFTKObjectList *op, *next;
/* clean out the attributes */
/* since no one is referencing us, it's safe to walk the chain
* without a lock */
for (op = session->objects[0]; op != NULL; op = next) {
next = op->next;
/* paranoia */
op->next = op->prev = NULL;
sftk_DeleteObject(session, op->parent);
}
PR_DestroyLock(session->objectLock);
if (session->enc_context) {
sftk_FreeContext(session->enc_context);
}
if (session->hash_context) {
sftk_FreeContext(session->hash_context);
}
if (session->search) {
sftk_FreeSearch(session->search);
}
}
/* free the data associated with the session, and the session.
* Caller must have driven refCount to 0; reachable only via sftk_FreeSession. */
static void
sftk_DestroySession(SFTKSession *session)
{
PORT_Assert(session->refCount == 0);
sftk_ClearSession(session);
PORT_Free(session);
}
/*
* look up a session structure from a session handle
* generate a reference to it.
*/
SFTKSession *
sftk_SessionFromHandle(CK_SESSION_HANDLE handle)
{
SFTKSlot *slot = sftk_SlotFromSessionHandle(handle);
SFTKSession *session;
PRLock *lock;
if (!slot)
return NULL;
lock = SFTK_SESSION_LOCK(slot, handle);
PR_Lock(lock);
sftkqueue_find(session, handle, slot->head, slot->sessHashSize);
if (session)
session->refCount++;
PR_Unlock(lock);
return (session);
}
/*
* release a reference to a session. The slot's session bucket holds the
* initial reference (created by sftk_InitSession); sftk_SessionFromHandle
* adds another for the duration of the caller's use. NSC_CloseSession and
* sftk_CloseAllSessions drop the bucket's reference once the session has
* been removed from the queue. The thread that drives refCount to 0
* destroys the session.
*/
void
sftk_FreeSession(SFTKSession *session)
{
PRBool destroy = PR_FALSE;
SFTKSlot *slot = sftk_SlotFromSession(session);
PRLock *lock = SFTK_SESSION_LOCK(slot, session->handle);
PR_Lock(lock);
PORT_Assert(session->refCount > 0);
if (session->refCount == 1)
destroy = PR_TRUE;
session->refCount--;
PR_Unlock(lock);
if (destroy)
sftk_DestroySession(session);
}
void
sftk_addHandle(SFTKSearchResults *search, CK_OBJECT_HANDLE handle)
{
if (search->handles == NULL) {
return;
}
if (search->size >= search->array_size) {
search->array_size += NSC_SEARCH_BLOCK_SIZE;
search->handles = (CK_OBJECT_HANDLE *)PORT_Realloc(search->handles,
sizeof(CK_OBJECT_HANDLE) * search->array_size);
if (search->handles == NULL) {
return;
}
}
search->handles[search->size] = handle;
search->size++;
}
static CK_RV
handleToClass(SFTKSlot *slot, CK_OBJECT_HANDLE handle,
CK_OBJECT_CLASS *objClass)
{
SFTKDBHandle *dbHandle = sftk_getDBForTokenObject(slot, handle);
CK_ATTRIBUTE objClassTemplate;
CK_RV crv;
*objClass = CKO_DATA;
objClassTemplate.type = CKA_CLASS;
objClassTemplate.pValue = objClass;
objClassTemplate.ulValueLen = sizeof(*objClass);
crv = sftkdb_GetAttributeValue(dbHandle, handle, &objClassTemplate, 1);
sftk_freeDB(dbHandle);
return crv;
}
SFTKObject *
sftk_NewTokenObject(SFTKSlot *slot, SECItem *dbKey, CK_OBJECT_HANDLE handle)
{
SFTKObject *object = NULL;
PRBool hasLocks = PR_FALSE;
CK_RV crv;
object = sftk_GetObjectFromList(&hasLocks, PR_FALSE, &tokenObjectList, 0,
PR_FALSE);
if (object == NULL) {
return NULL;
}
object->handle = handle;
/* every object must have a class, if we can't get it, the object
* doesn't exist */
crv = handleToClass(slot, handle, &object->objclass);
if (crv != CKR_OK) {
goto loser;
}
object->slot = slot;
/* set up the validation flags */
object->validation_value = 0;
object->validation_attribute.next = NULL;
object->validation_attribute.prev = NULL;
object->validation_attribute.freeAttr = PR_FALSE;
object->validation_attribute.freeData = PR_FALSE;
object->validation_attribute.handle = CKA_OBJECT_VALIDATION_FLAGS;
object->validation_attribute.attrib.type = CKA_OBJECT_VALIDATION_FLAGS;
object->validation_attribute.attrib.pValue = &object->validation_value;
object->validation_attribute.attrib.ulValueLen = sizeof(object->validation_value);
/* initialize the FIPS flag properly */
sftk_setFIPS(object, sftk_isFIPS(slot->slotID));
object->source = SFTK_SOURCE_DEFAULT;
object->objectInfo = NULL;
object->infoFree = NULL;
if (!hasLocks) {
object->refLock = PR_NewLock();
}
if (object->refLock == NULL) {
goto loser;
}
object->refCount = 1;
object->type = SFTK_TOKEN_OBJECT_TYPE;
return object;
loser:
(void)sftk_DestroyObject(object);
return NULL;
}
CK_RV
sftk_convertSessionToToken(SFTKObject *obj)
{
SECItem *dbKey;
SFTKSessionObject *so = (SFTKSessionObject *)obj;
SFTKTokenObject *to = sftk_narrowToTokenObject(obj);
CK_RV crv;
sftk_DestroySessionObjectData(so);
PR_DestroyLock(so->attributeLock);
sftk_tokenKeyLock(so->obj.slot);
dbKey = sftk_lookupTokenKeyByHandle(so->obj.slot, so->obj.handle);
if (dbKey && SECFailure == SECITEM_CopyItem(NULL, &to->dbKey, dbKey)) {
crv = CKR_HOST_MEMORY;
} else {
crv = CKR_OK;
}
sftk_tokenKeyUnlock(so->obj.slot);
return crv;
}
SFTKSessionObject *
sftk_narrowToSessionObject(SFTKObject *obj)
{
PRBool handleSaysSession = !sftk_isToken(obj->handle);
PRBool typeSaysSession = obj->type == SFTK_SESSION_OBJECT_TYPE;
if (handleSaysSession != typeSaysSession) {
PORT_Assert(0);
return NULL;
}
return handleSaysSession ? (SFTKSessionObject *)obj : NULL;
}
SFTKTokenObject *
sftk_narrowToTokenObject(SFTKObject *obj)
{
PRBool handleSaysToken = sftk_isToken(obj->handle);
PRBool typeSaysToken = obj->type == SFTK_TOKEN_OBJECT_TYPE;
if (handleSaysToken != typeSaysToken) {
PORT_Assert(0);
return NULL;
}
return handleSaysToken ? (SFTKTokenObject *)obj : NULL;
}
/* Constant time helper functions */
/* sftk_CKRVToMask returns, in constant time, a mask value of
* all ones if rv == CKR_OK. Otherwise it returns zero. */
unsigned int
sftk_CKRVToMask(CK_RV rv)
{
PR_STATIC_ASSERT(CKR_OK == 0);
return ~PORT_CT_NOT_ZERO(rv);
}
/* sftk_CheckCBCPadding checks, in constant time, the padding validity and
* accordingly sets the pad length. */
CK_RV
sftk_CheckCBCPadding(CK_BYTE_PTR pBuf, unsigned int bufLen,
unsigned int blockSize, unsigned int *outPadSize)
{
PORT_Assert(outPadSize);
/* CBC-padded plaintext is always at least one full block */
if (bufLen < blockSize || blockSize == 0) {
*outPadSize = 0;
return CKR_ENCRYPTED_DATA_INVALID;
}
unsigned int padSize = (unsigned int)pBuf[bufLen - 1];
/* If padSize <= blockSize, set goodPad to all-1s and all-0s otherwise.*/
unsigned int goodPad = PORT_CT_DUPLICATE_MSB_TO_ALL(~(blockSize - padSize));
/* padSize should not be 0 */
goodPad &= PORT_CT_NOT_ZERO(padSize);
unsigned int i;
for (i = 0; i < blockSize; i++) {
/* If i < padSize, set loopMask to all-1s and all-0s otherwise.*/
unsigned int loopMask = PORT_CT_DUPLICATE_MSB_TO_ALL(~(padSize - 1 - i));
/* Get the padding value (should be padSize) from buffer */
unsigned int padVal = pBuf[bufLen - 1 - i];
/* Update goodPad only if i < padSize */
goodPad &= PORT_CT_SEL(loopMask, ~(padVal ^ padSize), goodPad);
}
/* If any of the final padding bytes had the wrong value, one or more
* of the lower eight bits of |goodPad| will be cleared. We AND the
* bottom 8 bits together and duplicate the result to all the bits. */
goodPad &= goodPad >> 4;
goodPad &= goodPad >> 2;
goodPad &= goodPad >> 1;
goodPad <<= sizeof(goodPad) * 8 - 1;
goodPad = PORT_CT_DUPLICATE_MSB_TO_ALL(goodPad);
/* Set outPadSize to padSize or 0 */
*outPadSize = PORT_CT_SEL(goodPad, padSize, 0);
/* Return OK if the pad is valid */
return PORT_CT_SEL(goodPad, CKR_OK, CKR_ENCRYPTED_DATA_INVALID);
}
void
sftk_EncodeInteger(PRUint64 integer, CK_ULONG num_bits, CK_BBOOL littleEndian,
CK_BYTE_PTR output, CK_ULONG_PTR output_len)
{
if (output_len) {
*output_len = (num_bits / 8);
}
PR_ASSERT(num_bits > 0 && num_bits <= 64 && (num_bits % 8) == 0);
if (littleEndian == CK_TRUE) {
for (size_t offset = 0; offset < num_bits / 8; offset++) {
output[offset] = (unsigned char)((integer >> (offset * 8)) & 0xFF);
}
} else {
for (size_t offset = 0; offset < num_bits / 8; offset++) {
PRUint64 shift = num_bits - (offset + 1) * 8;
output[offset] = (unsigned char)((integer >> shift) & 0xFF);
}
}
}
CK_FLAGS
sftk_AttributeToFlags(CK_ATTRIBUTE_TYPE op)
{
CK_FLAGS flags = 0;
switch (op) {
case CKA_ENCRYPT:
flags = CKF_ENCRYPT;
break;
case CKA_DECRYPT:
flags = CKF_DECRYPT;
break;
case CKA_WRAP:
flags = CKF_WRAP;
break;
case CKA_UNWRAP:
flags = CKF_UNWRAP;
break;
case CKA_SIGN:
flags = CKF_SIGN;
break;
case CKA_SIGN_RECOVER:
flags = CKF_SIGN_RECOVER;
break;
case CKA_VERIFY:
flags = CKF_VERIFY;
break;
case CKA_VERIFY_RECOVER:
flags = CKF_VERIFY_RECOVER;
break;
case CKA_DERIVE:
flags = CKF_DERIVE;
break;
/* fake attribute to select digesting */
case CKA_DIGEST:
flags = CKF_DIGEST;
break;
/* fake attribute to select key gen */
case CKA_NSS_GENERATE:
flags = CKF_GENERATE;
break;
/* fake attribute to select key pair gen */
case CKA_NSS_GENERATE_KEY_PAIR:
flags = CKF_GENERATE_KEY_PAIR;
break;
/* fake attributes to to handle MESSAGE* flags */
case CKA_NSS_MESSAGE | CKA_ENCRYPT:
flags = CKF_MESSAGE_ENCRYPT;
break;
case CKA_NSS_MESSAGE | CKA_DECRYPT:
flags = CKF_MESSAGE_DECRYPT;
break;
case CKA_NSS_MESSAGE | CKA_SIGN:
flags = CKF_MESSAGE_SIGN;
break;
case CKA_NSS_MESSAGE | CKA_VERIFY:
flags = CKF_MESSAGE_VERIFY;
break;
default:
break;
}
return flags;
}
/*
* ******************** Hash Utilities **************************
*/
/*
* Utility function for converting PSS/OAEP parameter types into
* HASH_HashTypes. Note: Only SHA family functions are defined in RFC 3447.
*/
HASH_HashType
sftk_GetHashTypeFromMechanism(CK_MECHANISM_TYPE mech)
{
switch (mech) {
case CKM_SHA_1:
case CKG_MGF1_SHA1:
return HASH_AlgSHA1;
case CKM_SHA224:
case CKG_MGF1_SHA224:
return HASH_AlgSHA224;
case CKM_SHA256:
case CKG_MGF1_SHA256:
return HASH_AlgSHA256;
case CKM_SHA384:
case CKG_MGF1_SHA384:
return HASH_AlgSHA384;
case CKM_SHA512:
case CKG_MGF1_SHA512:
return HASH_AlgSHA512;
default:
return HASH_AlgNULL;
}
}
#ifdef NSS_HAS_FIPS_INDICATORS
/**************** FIPS Indicator Utilities *************************/
/* sigh, we probably need a version of this in secutil so that both
* softoken and NSS can use it */
static SECOidTag
sftk_quickGetECCCurveOid(SFTKObject *source)
{
SFTKAttribute *attribute = sftk_FindAttribute(source, CKA_EC_PARAMS);
unsigned char *encoded;
int len;
SECItem oid;
SECOidTag tag;
if (attribute == NULL) {
return SEC_OID_UNKNOWN;
}
encoded = attribute->attrib.pValue;
len = attribute->attrib.ulValueLen;
if ((len < 2) || (encoded[0] != SEC_ASN1_OBJECT_ID) ||
(len != encoded[1] + 2)) {
sftk_FreeAttribute(attribute);
return SEC_OID_UNKNOWN;
}
oid.data = encoded + 2;
oid.len = len - 2;
tag = SECOID_FindOIDTag(&oid);
sftk_FreeAttribute(attribute);
return tag;
}
/* This function currently only returns valid lengths for
* FIPS approved ECC curves. If we want to make this generic
* in the future, that Curve determination can be done in
* the sftk_handleSpecial. Since it's currently only used
* in FIPS indicators, it's currently only compiled with
* the FIPS indicator code */
static CK_ULONG
sftk_getKeyLength(SFTKObject *source)
{
CK_KEY_TYPE keyType = CKK_INVALID_KEY_TYPE;
CK_ATTRIBUTE_TYPE keyAttribute;
CK_ULONG keyLength = 0;
SFTKAttribute *attribute;
CK_RV crv;
/* If we don't have a key, then it doesn't have a length.
* this may be OK (say we are hashing). The mech info will
* sort this out because algorithms which expect no keys
* will accept zero length for the keys */
if (source == NULL) {
return 0;
}
crv = sftk_GetULongAttribute(source, CKA_KEY_TYPE, &keyType);
if (crv != CKR_OK) {
/* sometimes we're passed a data object, in that case the
* key length is CKA_VALUE, which is the default */
keyType = CKK_INVALID_KEY_TYPE;
}
if ((keyType == CKK_EC) || (keyType == CKK_EC_EDWARDS) ||
(keyType == CKK_EC_MONTGOMERY)) {
SECOidTag curve = sftk_quickGetECCCurveOid(source);
switch (curve) {
case SEC_OID_CURVE25519:
/* change when we start algorithm testing on curve25519 */
return 0;
case SEC_OID_SECG_EC_SECP256R1:
return 256;
case SEC_OID_SECG_EC_SECP384R1:
return 384;
case SEC_OID_SECG_EC_SECP521R1:
/* this is a lie, but it makes the table easier. We don't
* have to have a double entry for every ECC mechanism */
return 512;
default:
break;
}
/* other curves aren't NIST approved, returning 0 will cause these
* curves to fail FIPS length criteria */
return 0;
}
switch (keyType) {
case CKK_RSA:
keyAttribute = CKA_MODULUS;
break;
case CKK_DSA:
case CKK_DH:
keyAttribute = CKA_PRIME;
break;
default:
keyAttribute = CKA_VALUE;
break;
}
attribute = sftk_FindAttribute(source, keyAttribute);
if (attribute) {
keyLength = attribute->attrib.ulValueLen * 8;
sftk_FreeAttribute(attribute);
}
return keyLength;
}
static PRBool
sftk_checkKeyLength(CK_ULONG keyLength, CK_ULONG min,
CK_ULONG max, CK_ULONG step)
{
if (keyLength > max) {
return PR_FALSE;
}
if (keyLength < min) {
return PR_FALSE;
}
if (step == 0) {
return PR_TRUE;
}
if (((keyLength - min) % step) != 0) {
return PR_FALSE;
}
return PR_TRUE;
}
/*
* handle specialized FIPS semantics that are too complicated to
* handle with just a table. NOTE: this means any additional semantics
* would have to be coded here before they can be added to the table */
static PRBool
sftk_handleSpecial(SFTKSlot *slot, CK_MECHANISM *mech,
SFTKFIPSAlgorithmList *mechInfo, SFTKObject *source,
CK_ULONG keyLength, CK_ULONG targetKeyLength)
{
switch (mechInfo->special) {
case SFTKFIPSDH: {
SECItem dhPrime;
SECItem dhBase;
SECItem dhGenerator;
PRBool fipsOk = PR_FALSE;
const SECItem *dhSubPrime;
CK_RV crv = sftk_Attribute2SecItem(NULL, &dhPrime,
source, CKA_PRIME);
if (crv != CKR_OK) {
return PR_FALSE;
}
crv = sftk_Attribute2SecItem(NULL, &dhBase, source, CKA_BASE);
if (crv != CKR_OK) {
return PR_FALSE;
}
dhSubPrime = sftk_VerifyDH_Prime(&dhPrime, &dhGenerator, PR_TRUE);
fipsOk = (dhSubPrime) ? PR_TRUE : PR_FALSE;
if (fipsOk && (SECITEM_CompareItem(&dhBase, &dhGenerator) != 0)) {
fipsOk = PR_FALSE;
}
SECITEM_ZfreeItem(&dhPrime, PR_FALSE);
SECITEM_ZfreeItem(&dhBase, PR_FALSE);
return fipsOk;
}
case SFTKFIPSNone:
return PR_FALSE;
case SFTKFIPSECC:
/* we've already handled the curve selection in the 'getlength'
* function */
return PR_TRUE;
case SFTKFIPSAEAD: {
if (mech->ulParameterLen == 0) {
/* AEAD ciphers are only in FIPS mode if we are using the
* MESSAGE interface. This takes an empty parameter
* in the init function */
return PR_TRUE;
}
return PR_FALSE;
}
case SFTKFIPSRSAPSS: {
/* PSS salt must not be longer than the underlying hash.
* We verify that the underlying hash of the
* parameters matches Hash of the combined hash mechanisms, so
* we don't need to look at the specific PSS mechanism */
CK_RSA_PKCS_PSS_PARAMS *pss = (CK_RSA_PKCS_PSS_PARAMS *)
mech->pParameter;
const SECHashObject *hashObj = NULL;
if (mech->ulParameterLen != sizeof(*pss)) {
return PR_FALSE;
}
/* we use the existing hash utilities to find the length of
* the hash */
hashObj = HASH_GetRawHashObject(sftk_GetHashTypeFromMechanism(
pss->hashAlg));
if (hashObj == NULL) {
return PR_FALSE;
}
/* cap the salt for legacy keys */
if ((keyLength <= 1024) && (pss->sLen > 63)) {
return PR_FALSE;
}
/* cap the salt based on the hash */
if (pss->sLen > hashObj->length) {
return PR_FALSE;
}
return PR_TRUE;
}
case SFTKFIPSTlsKeyCheck:
return sftk_checkKeyLength(targetKeyLength, 112, 512, 1);
default:
break;
}
/* if we didn't understand the special processing, mark it non-fips */
return PR_FALSE;
}
#endif
PRBool
sftk_operationIsFIPS(SFTKSlot *slot, CK_MECHANISM *mech, CK_ATTRIBUTE_TYPE op,
SFTKObject *source, CK_ULONG targetKeyLength)
{
#ifndef NSS_HAS_FIPS_INDICATORS
return PR_FALSE;
#else
int i;
CK_FLAGS opFlags;
CK_ULONG keyLength;
/* handle all the quick stuff first */
if (!sftk_isFIPS(slot->slotID)) {
return PR_FALSE;
}
if (source && !sftk_hasFIPS(source)) {
return PR_FALSE;
}
if (mech == NULL) {
return PR_FALSE;
}
/* now get the calculated values */
opFlags = sftk_AttributeToFlags(op);
if (opFlags == 0) {
return PR_FALSE;
}
keyLength = sftk_getKeyLength(source);
/* check against our algorithm array */
for (i = 0; i < SFTK_NUMBER_FIPS_ALGORITHMS; i++) {
SFTKFIPSAlgorithmList *mechs = &sftk_fips_mechs[i];
/* if we match the number of records exactly, then we are an
* approved algorithm in the approved mode with an approved key */
if ((mech->mechanism == mechs->type) &&
(opFlags == (mechs->info.flags & opFlags)) &&
sftk_checkKeyLength(keyLength, mechs->info.ulMinKeySize,
mechs->info.ulMaxKeySize, mechs->step) &&
((targetKeyLength == 0) || (mechs->special == SFTKFIPSTlsKeyCheck) || sftk_checkKeyLength(targetKeyLength, mechs->info.ulMinKeySize, mechs->info.ulMaxKeySize, mechs->step)) &&
((mechs->special == SFTKFIPSNone) ||
sftk_handleSpecial(slot, mech, mechs, source, keyLength, targetKeyLength))) {
return PR_TRUE;
}
}
return PR_FALSE;
#endif
}
void
sftk_setFIPS(SFTKObject *obj, PRBool isFIPS)
{
if (isFIPS) {
obj->validation_value |= SFTK_VALIDATION_FIPS_FLAG;
} else {
obj->validation_value &= ~SFTK_VALIDATION_FIPS_FLAG;
}
}
PRBool
sftk_hasFIPS(SFTKObject *obj)
{
return (obj->validation_value & SFTK_VALIDATION_FIPS_FLAG) ? PR_TRUE : PR_FALSE;
}
/*
* create the FIPS Validation objects. If the vendor
* doesn't supply an NSS_FIPS_MODULE_ID, at compile time,
* then we assumethis is an unvalidated module.
*/
CK_RV
sftk_CreateValidationObjects(SFTKSlot *slot)
{
const char *module_id;
int module_id_len;
CK_RV crv = CKR_OK;
/* we currently use both vendor specific values and PKCS #11 v3.2
* values for compatibility for a couple more ESR releases. Then we can
* drop the vendor specific ones */
CK_OBJECT_CLASS cko_nss_validation = CKO_NSS_VALIDATION;
CK_OBJECT_CLASS cko_validation = CKO_VALIDATION;
CK_NSS_VALIDATION_TYPE ckv_fips = CKV_NSS_FIPS_140;
CK_FLAGS fipsFlag = SFTK_VALIDATION_FIPS_FLAG;
CK_VALIDATION_TYPE swValidationType = CKV_TYPE_SOFTWARE;
CK_VALIDATION_AUTHORITY_TYPE nistValidationAuthority =
CKV_AUTHORITY_TYPE_NIST_CMVP;
CK_UTF8CHAR us[] = { 'U', 'S' };
CK_VERSION fips_version = { 3, 0 }; /* FIPS-140-3 */
CK_ULONG fips_level = 1; /* or 2 if you validated at level 2 */
#ifndef NSS_FIPS_MODULE_ID
#define NSS_FIPS_MODULE_ID "Generic NSS " SOFTOKEN_VERSION " Unvalidated"
#endif
module_id = NSS_FIPS_MODULE_ID;
module_id_len = sizeof(NSS_FIPS_MODULE_ID) - 1;
SFTKObject *object;
object = sftk_NewObject(slot); /* fill in the handle later */
if (object == NULL) {
return CKR_HOST_MEMORY;
}
sftk_setFIPS(object, PR_FALSE);
crv = sftk_AddAttributeType(object, CKA_CLASS, &cko_nss_validation,
sizeof(cko_nss_validation));
if (crv != CKR_OK) {
goto loser;
}
crv = sftk_AddAttributeType(object, CKA_NSS_VALIDATION_TYPE,
&ckv_fips, sizeof(ckv_fips));
if (crv != CKR_OK) {
goto loser;
}
crv = sftk_AddAttributeType(object, CKA_NSS_VALIDATION_VERSION,
&fips_version, sizeof(fips_version));
if (crv != CKR_OK) {
goto loser;
}
crv = sftk_AddAttributeType(object, CKA_NSS_VALIDATION_LEVEL,
&fips_level, sizeof(fips_level));
if (crv != CKR_OK) {
goto loser;
}
crv = sftk_AddAttributeType(object, CKA_NSS_VALIDATION_MODULE_ID,
module_id, module_id_len);
if (crv != CKR_OK) {
goto loser;
}
object->handle = sftk_getNextHandle(slot);
object->slot = slot;
sftk_AddObject(&slot->moduleObjects, object);
sftk_FreeObject(object);
object = sftk_NewObject(slot); /* fill in the handle later */
if (object == NULL) {
return CKR_HOST_MEMORY;
}
sftk_setFIPS(object, PR_FALSE);
crv = sftk_AddAttributeType(object, CKA_CLASS, &cko_validation,
sizeof(cko_validation));
if (crv != CKR_OK) {
goto loser;
}
crv = sftk_AddAttributeType(object, CKA_VALIDATION_TYPE,
&swValidationType, sizeof(swValidationType));
if (crv != CKR_OK) {
goto loser;
}
crv = sftk_AddAttributeType(object, CKA_VALIDATION_VERSION,
&fips_version, sizeof(fips_version));
if (crv != CKR_OK) {
goto loser;
}
crv = sftk_AddAttributeType(object, CKA_VALIDATION_LEVEL,
&fips_level, sizeof(fips_level));
if (crv != CKR_OK) {
goto loser;
}
crv = sftk_AddAttributeType(object, CKA_VALIDATION_MODULE_ID,
module_id, module_id_len);
if (crv != CKR_OK) {
goto loser;
}
crv = sftk_AddAttributeType(object, CKA_VALIDATION_FLAG,
&fipsFlag, sizeof(fipsFlag));
if (crv != CKR_OK) {
goto loser;
}
crv = sftk_AddAttributeType(object, CKA_VALIDATION_AUTHORITY_TYPE,
&nistValidationAuthority,
sizeof(nistValidationAuthority));
if (crv != CKR_OK) {
goto loser;
}
crv = sftk_AddAttributeType(object, CKA_VALIDATION_COUNTRY, us, sizeof(us));
if (crv != CKR_OK) {
goto loser;
}
crv = sftk_AddAttributeType(object, CKA_VALIDATION_CERTIFICATE_IDENTIFIER,
NULL, 0);
if (crv != CKR_OK) {
goto loser;
}
crv = sftk_AddAttributeType(object, CKA_VALIDATION_CERTIFICATE_URI,
NULL, 0);
if (crv != CKR_OK) {
goto loser;
}
crv = sftk_AddAttributeType(object, CKA_VALIDATION_PROFILE,
NULL, 0);
if (crv != CKR_OK) {
goto loser;
}
crv = sftk_AddAttributeType(object, CKA_VALIDATION_VENDOR_URI,
NULL, 0);
if (crv != CKR_OK) {
goto loser;
}
/* future, fill in validation certificate information from a supplied
* pointer to a config file */
object->handle = sftk_getNextHandle(slot);
object->slot = slot;
sftk_AddObject(&slot->moduleObjects, object);
loser:
sftk_FreeObject(object);
return crv;
}
