trustbridge/nss-cmake-static: nss/lib/pk11wrap/pk11skey.c comparison

comparison nss/lib/pk11wrap/pk11skey.c @ 0:1e5118fa0cb1

This is NSS with a Cmake Buildsyste To compile a static NSS library for Windows we've used the Chromium-NSS fork and added a Cmake buildsystem to compile it statically for Windows. See README.chromium for chromium changes and README.trustbridge for our modifications.

author	Andre Heinecke <andre.heinecke@intevation.de>
date	Mon, 28 Jul 2014 10:47:06 +0200
parents
children

comparison

equal deleted inserted replaced

--1:000000000000
+:1e5118fa0cb1
+/* 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/. */
+/*
+* This file implements the Symkey wrapper and the PKCS context
+* Interfaces.
+*/
+#include "seccomon.h"
+#include "secmod.h"
+#include "nssilock.h"
+#include "secmodi.h"
+#include "secmodti.h"
+#include "pkcs11.h"
+#include "pk11func.h"
+#include "secitem.h"
+#include "secoid.h"
+#include "secerr.h"
+#include "hasht.h"
+static void
+pk11_EnterKeyMonitor(PK11SymKey *symKey) {
+if (!symKey->sessionOwner || !(symKey->slot->isThreadSafe))
+	PK11_EnterSlotMonitor(symKey->slot);
+}
+static void
+pk11_ExitKeyMonitor(PK11SymKey *symKey) {
+if (!symKey->sessionOwner || !(symKey->slot->isThreadSafe))
+	PK11_ExitSlotMonitor(symKey->slot);
+}
+/*
+* pk11_getKeyFromList returns a symKey that has a session (if needSession
+* was specified), or explicitly does not have a session (if needSession
+* was not specified).
+*/
+static PK11SymKey *
+pk11_getKeyFromList(PK11SlotInfo *slot, PRBool needSession) {
+PK11SymKey *symKey = NULL;
+PZ_Lock(slot->freeListLock);
+/* own session list are symkeys with sessions that the symkey owns.
+* 'most' symkeys will own their own session. */
+if (needSession) {
+	if (slot->freeSymKeysWithSessionHead) {
+	    symKey = slot->freeSymKeysWithSessionHead;
+	    slot->freeSymKeysWithSessionHead = symKey->next;
+	    slot->keyCount--;
+	}
+}
+/* if we don't need a symkey with its own session, or we couldn't find
+* one on the owner list, get one from the non-owner free list. */
+if (!symKey) {
+	if (slot->freeSymKeysHead) {
+	    symKey = slot->freeSymKeysHead;
+	    slot->freeSymKeysHead = symKey->next;
+	    slot->keyCount--;
+	}
+}
+PZ_Unlock(slot->freeListLock);
+if (symKey) {
+	symKey->next = NULL;
+	if (!needSession) {
+	    return symKey;
+	}
+	/* if we are getting an owner key, make sure we have a valid session.
+* session could be invalid if the token has been removed or because
+* we got it from the non-owner free list */
+	if ((symKey->series != slot->series) ||
+			 (symKey->session == CK_INVALID_SESSION)) {
+	    symKey->session = pk11_GetNewSession(slot, &symKey->sessionOwner);
+	}
+	PORT_Assert(symKey->session != CK_INVALID_SESSION);
+	if (symKey->session != CK_INVALID_SESSION)
+	    return symKey;
+	PK11_FreeSymKey(symKey);
+	/* if we are here, we need a session, but couldn't get one, it's
+	 * unlikely we pk11_GetNewSession will succeed if we call it a second
+	 * time. */
+	return NULL;
+}
+symKey = PORT_New(PK11SymKey);
+if (symKey == NULL) {
+	return NULL;
+}
+symKey->next = NULL;
+if (needSession) {
+	symKey->session = pk11_GetNewSession(slot,&symKey->sessionOwner);
+	PORT_Assert(symKey->session != CK_INVALID_SESSION);
+if (symKey->session == CK_INVALID_SESSION) {
+	    PK11_FreeSymKey(symKey);
+	    symKey = NULL;
+	}
+} else {
+	symKey->session = CK_INVALID_SESSION;
+}
+return symKey;
+}
+/* Caller MUST hold slot->freeListLock (or ref count == 0?) !! */
+void
+PK11_CleanKeyList(PK11SlotInfo *slot)
+{
+PK11SymKey *symKey = NULL;
+while (slot->freeSymKeysWithSessionHead) {
+	symKey = slot->freeSymKeysWithSessionHead;
+	slot->freeSymKeysWithSessionHead = symKey->next;
+	pk11_CloseSession(slot, symKey->session, symKey->sessionOwner);
+	PORT_Free(symKey);
+}
+while (slot->freeSymKeysHead) {
+	symKey = slot->freeSymKeysHead;
+	slot->freeSymKeysHead = symKey->next;
+	pk11_CloseSession(slot, symKey->session, symKey->sessionOwner);
+	PORT_Free(symKey);
+}
+return;
+}
+/*
+* create a symetric key:
+*      Slot is the slot to create the key in.
+*      type is the mechanism type
+*      owner is does this symKey structure own it's object handle (rare
+*        that this is false).
+*      needSession means the returned symKey will return with a valid session
+*        allocated already.
+*/
+static PK11SymKey *
+pk11_CreateSymKey(PK11SlotInfo *slot, CK_MECHANISM_TYPE type,
+		  PRBool owner, PRBool needSession, void *wincx)
+{
+PK11SymKey *symKey = pk11_getKeyFromList(slot, needSession);
+if (symKey == NULL) {
+	return NULL;
+}
+/* if needSession was specified, make sure we have a valid session.
+* callers which specify needSession as false should do their own
+* check of the session before returning the symKey */
+if (needSession && symKey->session == CK_INVALID_SESSION) {
+	PK11_FreeSymKey(symKey);
+	PORT_SetError(SEC_ERROR_LIBRARY_FAILURE);
+	return NULL;
+}
+symKey->type = type;
+symKey->data.type = siBuffer;
+symKey->data.data = NULL;
+symKey->data.len = 0;
+symKey->owner = owner;
+symKey->objectID = CK_INVALID_HANDLE;
+symKey->slot = slot;
+symKey->series = slot->series;
+symKey->cx = wincx;
+symKey->size = 0;
+symKey->refCount = 1;
+symKey->origin = PK11_OriginNULL;
+symKey->parent = NULL;
+symKey->freeFunc = NULL;
+symKey->userData = NULL;
+PK11_ReferenceSlot(slot);
+return symKey;
+}
+/*
+* destroy a symetric key
+*/
+void
+PK11_FreeSymKey(PK11SymKey *symKey)
+{
+PK11SlotInfo *slot;
+PRBool freeit = PR_TRUE;
+if (PR_ATOMIC_DECREMENT(&symKey->refCount) == 0) {
+	PK11SymKey *parent = symKey->parent;
+	symKey->parent = NULL;
+	if ((symKey->owner) && symKey->objectID != CK_INVALID_HANDLE) {
+	    pk11_EnterKeyMonitor(symKey);
+	    (void) PK11_GETTAB(symKey->slot)->
+		C_DestroyObject(symKey->session, symKey->objectID);
+	    pk11_ExitKeyMonitor(symKey);
+	}
+	if (symKey->data.data) {
+	    PORT_Memset(symKey->data.data, 0, symKey->data.len);
+	    PORT_Free(symKey->data.data);
+	}
+	/* free any existing data */
+	if (symKey->userData && symKey->freeFunc) {
+	    (*symKey->freeFunc)(symKey->userData);
+	}
+slot = symKey->slot;
+PZ_Lock(slot->freeListLock);
+	if (slot->keyCount < slot->maxKeyCount) {
+	    /*
+* freeSymkeysWithSessionHead contain a list of reusable
+	     *  SymKey structures with valid sessions.
+	     *    sessionOwner must be true.
+*    session must be valid.
+* freeSymKeysHead contain a list of SymKey structures without
+*  valid session.
+*    session must be CK_INVALID_SESSION.
+	     *    though sessionOwner is false, callers should not depend on
+	     *    this fact.
+	     */
+	    if (symKey->sessionOwner) {
+		PORT_Assert (symKey->session != CK_INVALID_SESSION);
+		symKey->next = slot->freeSymKeysWithSessionHead;
+		slot->freeSymKeysWithSessionHead = symKey;
+	    } else {
+		symKey->session = CK_INVALID_SESSION;
+		symKey->next = slot->freeSymKeysHead;
+		slot->freeSymKeysHead = symKey;
+	    }
+	    slot->keyCount++;
+	    symKey->slot = NULL;
+	    freeit = PR_FALSE;
+}
+	PZ_Unlock(slot->freeListLock);
+if (freeit) {
+	    pk11_CloseSession(symKey->slot, symKey->session,
+							symKey->sessionOwner);
+	    PORT_Free(symKey);
+	}
+	PK11_FreeSlot(slot);
+	if (parent) {
+	    PK11_FreeSymKey(parent);
+	}
+}
+}
+PK11SymKey *
+PK11_ReferenceSymKey(PK11SymKey *symKey)
+{
+PR_ATOMIC_INCREMENT(&symKey->refCount);
+return symKey;
+}
+/*
+* Accessors
+*/
+CK_MECHANISM_TYPE
+PK11_GetMechanism(PK11SymKey *symKey)
+{
+return symKey->type;
+}
+/*
+* return the slot associated with a symetric key
+*/
+PK11SlotInfo *
+PK11_GetSlotFromKey(PK11SymKey *symKey)
+{
+return PK11_ReferenceSlot(symKey->slot);
+}
+CK_KEY_TYPE PK11_GetSymKeyType(PK11SymKey *symKey)
+{
+return PK11_GetKeyType(symKey->type,symKey->size);
+}
+PK11SymKey *
+PK11_GetNextSymKey(PK11SymKey *symKey)
+{
+return symKey ? symKey->next : NULL;
+}
+char *
+PK11_GetSymKeyNickname(PK11SymKey *symKey)
+{
+return PK11_GetObjectNickname(symKey->slot,symKey->objectID);
+}
+SECStatus
+PK11_SetSymKeyNickname(PK11SymKey *symKey, const char *nickname)
+{
+return PK11_SetObjectNickname(symKey->slot,symKey->objectID,nickname);
+}
+void *
+PK11_GetSymKeyUserData(PK11SymKey *symKey)
+{
+return symKey->userData;
+}
+void
+PK11_SetSymKeyUserData(PK11SymKey *symKey, void *userData,
+PK11FreeDataFunc freeFunc)
+{
+/* free any existing data */
+if (symKey->userData && symKey->freeFunc) {
+	(*symKey->freeFunc)(symKey->userData);
+}
+symKey->userData = userData;
+symKey->freeFunc = freeFunc;
+return;
+}
+/*
+* turn key handle into an appropriate key object
+*/
+PK11SymKey *
+PK11_SymKeyFromHandle(PK11SlotInfo *slot, PK11SymKey *parent, PK11Origin origin,
+CK_MECHANISM_TYPE type, CK_OBJECT_HANDLE keyID, PRBool owner, void *wincx)
+{
+PK11SymKey *symKey;
+PRBool needSession = !(owner && parent);
+if (keyID == CK_INVALID_HANDLE) {
+	return NULL;
+}
+symKey = pk11_CreateSymKey(slot, type, owner, needSession, wincx);
+if (symKey == NULL) {
+	return NULL;
+}
+symKey->objectID = keyID;
+symKey->origin = origin;
+/* adopt the parent's session */
+/* This is only used by SSL. What we really want here is a session
+* structure with a ref count so  the session goes away only after all the
+* keys do. */
+if (!needSession) {
+	symKey->sessionOwner = PR_FALSE;
+	symKey->session = parent->session;
+	symKey->parent = PK11_ReferenceSymKey(parent);
+/* This is the only case where pk11_CreateSymKey does not explicitly
+	 * check symKey->session. We need to assert here to make sure.
+	 * the session isn't invalid. */
+	PORT_Assert(parent->session != CK_INVALID_SESSION);
+	if (parent->session == CK_INVALID_SESSION) {
+	    PK11_FreeSymKey(symKey);
+	    PORT_SetError(SEC_ERROR_LIBRARY_FAILURE);
+	    return NULL;
+	}
+}
+return symKey;
+}
+/*
+* turn key handle into an appropriate key object
+*/
+PK11SymKey *
+PK11_GetWrapKey(PK11SlotInfo *slot, int wrap, CK_MECHANISM_TYPE type,
+						    int series, void *wincx)
+{
+PK11SymKey *symKey = NULL;
+if (slot->series != series) return NULL;
+if (slot->refKeys[wrap] == CK_INVALID_HANDLE) return NULL;
+if (type == CKM_INVALID_MECHANISM) type = slot->wrapMechanism;
+symKey = PK11_SymKeyFromHandle(slot, NULL, PK11_OriginDerive,
+		 slot->wrapMechanism, slot->refKeys[wrap], PR_FALSE, wincx);
+return symKey;
+}
+/*
+* This function is not thread-safe because it sets wrapKey->sessionOwner
+* without using a lock or atomic routine.  It can only be called when
+* only one thread has a reference to wrapKey.
+*/
+void
+PK11_SetWrapKey(PK11SlotInfo *slot, int wrap, PK11SymKey *wrapKey)
+{
+/* save the handle and mechanism for the wrapping key */
+/* mark the key and session as not owned by us to they don't get freed
+* when the key goes way... that lets us reuse the key later */
+slot->refKeys[wrap] = wrapKey->objectID;
+wrapKey->owner = PR_FALSE;
+wrapKey->sessionOwner = PR_FALSE;
+slot->wrapMechanism = wrapKey->type;
+}
+/*
+* figure out if a key is still valid or if it is stale.
+*/
+PRBool
+PK11_VerifyKeyOK(PK11SymKey *key) {
+if (!PK11_IsPresent(key->slot)) {
+	return PR_FALSE;
+}
+return (PRBool)(key->series == key->slot->series);
+}
+static PK11SymKey *
+pk11_ImportSymKeyWithTempl(PK11SlotInfo *slot, CK_MECHANISM_TYPE type,
+PK11Origin origin, PRBool isToken, CK_ATTRIBUTE *keyTemplate,
+		  unsigned int templateCount, SECItem *key, void *wincx)
+{
+PK11SymKey *    symKey;
+SECStatus	    rv;
+symKey = pk11_CreateSymKey(slot, type, !isToken, PR_TRUE, wincx);
+if (symKey == NULL) {
+	return NULL;
+}
+symKey->size = key->len;
+PK11_SETATTRS(&keyTemplate[templateCount], CKA_VALUE, key->data, key->len);
+templateCount++;
+if (SECITEM_CopyItem(NULL,&symKey->data,key) != SECSuccess) {
+	PK11_FreeSymKey(symKey);
+	return NULL;
+}
+symKey->origin = origin;
+/* import the keys */
+rv = PK11_CreateNewObject(slot, symKey->session, keyTemplate,
+		 	templateCount, isToken, &symKey->objectID);
+if ( rv != SECSuccess) {
+	PK11_FreeSymKey(symKey);
+	return NULL;
+}
+return symKey;
+}
+/*
+* turn key bits into an appropriate key object
+*/
+PK11SymKey *
+PK11_ImportSymKey(PK11SlotInfo *slot, CK_MECHANISM_TYPE type,
+PK11Origin origin, CK_ATTRIBUTE_TYPE operation, SECItem *key,void *wincx)
+{
+PK11SymKey *    symKey;
+unsigned int    templateCount = 0;
+CK_OBJECT_CLASS keyClass 	= CKO_SECRET_KEY;
+CK_KEY_TYPE     keyType 	= CKK_GENERIC_SECRET;
+CK_BBOOL        cktrue 	= CK_TRUE; /* sigh */
+CK_ATTRIBUTE    keyTemplate[5];
+CK_ATTRIBUTE *  attrs 	= keyTemplate;
+PK11_SETATTRS(attrs, CKA_CLASS, &keyClass, sizeof(keyClass) ); attrs++;
+PK11_SETATTRS(attrs, CKA_KEY_TYPE, &keyType, sizeof(keyType) ); attrs++;
+PK11_SETATTRS(attrs, operation, &cktrue, 1); attrs++;
+templateCount = attrs - keyTemplate;
+PR_ASSERT(templateCount+1 <= sizeof(keyTemplate)/sizeof(CK_ATTRIBUTE));
+keyType = PK11_GetKeyType(type,key->len);
+symKey = pk11_ImportSymKeyWithTempl(slot, type, origin, PR_FALSE,
+				keyTemplate, templateCount, key, wincx);
+return symKey;
+}
+/*
+* turn key bits into an appropriate key object
+*/
+PK11SymKey *
+PK11_ImportSymKeyWithFlags(PK11SlotInfo *slot, CK_MECHANISM_TYPE type,
+PK11Origin origin, CK_ATTRIBUTE_TYPE operation, SECItem *key,
+CK_FLAGS flags, PRBool isPerm, void *wincx)
+{
+PK11SymKey *    symKey;
+unsigned int    templateCount = 0;
+CK_OBJECT_CLASS keyClass 	= CKO_SECRET_KEY;
+CK_KEY_TYPE     keyType 	= CKK_GENERIC_SECRET;
+CK_BBOOL        cktrue 	= CK_TRUE; /* sigh */
+CK_ATTRIBUTE    keyTemplate[MAX_TEMPL_ATTRS];
+CK_ATTRIBUTE *  attrs 	= keyTemplate;
+PK11_SETATTRS(attrs, CKA_CLASS, &keyClass, sizeof(keyClass) ); attrs++;
+PK11_SETATTRS(attrs, CKA_KEY_TYPE, &keyType, sizeof(keyType) ); attrs++;
+if (isPerm) {
+	PK11_SETATTRS(attrs, CKA_TOKEN, &cktrue, sizeof(cktrue) ); attrs++;
+	/* sigh some tokens think CKA_PRIVATE = false is a reasonable
+	 * default for secret keys */
+	PK11_SETATTRS(attrs, CKA_PRIVATE, &cktrue, sizeof(cktrue) ); attrs++;
+}
+attrs += pk11_OpFlagsToAttributes(flags, attrs, &cktrue);
+if ((operation != CKA_FLAGS_ONLY) &&
+	 !pk11_FindAttrInTemplate(keyTemplate, attrs-keyTemplate, operation)) {
+PK11_SETATTRS(attrs, operation, &cktrue, sizeof(cktrue)); attrs++;
+}
+templateCount = attrs - keyTemplate;
+PR_ASSERT(templateCount+1 <= sizeof(keyTemplate)/sizeof(CK_ATTRIBUTE));
+keyType = PK11_GetKeyType(type,key->len);
+symKey = pk11_ImportSymKeyWithTempl(slot, type, origin, isPerm,
+				 keyTemplate, templateCount, key, wincx);
+if (symKey && isPerm) {
+	symKey->owner = PR_FALSE;
+}
+return symKey;
+}
+PK11SymKey *
+PK11_FindFixedKey(PK11SlotInfo *slot, CK_MECHANISM_TYPE type, SECItem *keyID,
+								void *wincx)
+{
+CK_ATTRIBUTE findTemp[4];
+CK_ATTRIBUTE *attrs;
+CK_BBOOL ckTrue = CK_TRUE;
+CK_OBJECT_CLASS keyclass = CKO_SECRET_KEY;
+int tsize = 0;
+CK_OBJECT_HANDLE key_id;
+attrs = findTemp;
+PK11_SETATTRS(attrs, CKA_CLASS, &keyclass, sizeof(keyclass)); attrs++;
+PK11_SETATTRS(attrs, CKA_TOKEN, &ckTrue, sizeof(ckTrue)); attrs++;
+if (keyID) {
+PK11_SETATTRS(attrs, CKA_ID, keyID->data, keyID->len); attrs++;
+}
+tsize = attrs - findTemp;
+PORT_Assert(tsize <= sizeof(findTemp)/sizeof(CK_ATTRIBUTE));
+key_id = pk11_FindObjectByTemplate(slot,findTemp,tsize);
+if (key_id == CK_INVALID_HANDLE) {
+	return NULL;
+}
+return PK11_SymKeyFromHandle(slot, NULL, PK11_OriginDerive, type, key_id,
+		 				PR_FALSE, wincx);
+}
+PK11SymKey *
+PK11_ListFixedKeysInSlot(PK11SlotInfo *slot, char *nickname, void *wincx)
+{
+CK_ATTRIBUTE findTemp[4];
+CK_ATTRIBUTE *attrs;
+CK_BBOOL ckTrue = CK_TRUE;
+CK_OBJECT_CLASS keyclass = CKO_SECRET_KEY;
+int tsize = 0;
+int objCount = 0;
+CK_OBJECT_HANDLE *key_ids;
+PK11SymKey *nextKey = NULL;
+PK11SymKey *topKey = NULL;
+int i,len;
+attrs = findTemp;
+PK11_SETATTRS(attrs, CKA_CLASS, &keyclass, sizeof(keyclass)); attrs++;
+PK11_SETATTRS(attrs, CKA_TOKEN, &ckTrue, sizeof(ckTrue)); attrs++;
+if (nickname) {
+	len = PORT_Strlen(nickname);
+	PK11_SETATTRS(attrs, CKA_LABEL, nickname, len); attrs++;
+}
+tsize = attrs - findTemp;
+PORT_Assert(tsize <= sizeof(findTemp)/sizeof(CK_ATTRIBUTE));
+key_ids = pk11_FindObjectsByTemplate(slot,findTemp,tsize,&objCount);
+if (key_ids == NULL) {
+	return NULL;
+}
+for (i=0; i < objCount ; i++) {
+	SECItem typeData;
+	CK_KEY_TYPE type = CKK_GENERIC_SECRET;
+SECStatus rv = PK11_ReadAttribute(slot, key_ids[i],
+						CKA_KEY_TYPE, NULL, &typeData);
+	if (rv == SECSuccess) {
+	    if (typeData.len == sizeof(CK_KEY_TYPE)) {
+	    	type = *(CK_KEY_TYPE *)typeData.data;
+	    }
+	    PORT_Free(typeData.data);
+	}
+	nextKey = PK11_SymKeyFromHandle(slot, NULL, PK11_OriginDerive,
+		PK11_GetKeyMechanism(type), key_ids[i], PR_FALSE, wincx);
+	if (nextKey) {
+	    nextKey->next = topKey;
+	    topKey = nextKey;
+	}
+}
+PORT_Free(key_ids);
+return topKey;
+}
+void *
+PK11_GetWindow(PK11SymKey *key)
+{
+return key->cx;
+}
+/*
+* extract a symetric key value. NOTE: if the key is sensitive, we will
+* not be able to do this operation. This function is used to move
+* keys from one token to another */
+SECStatus
+PK11_ExtractKeyValue(PK11SymKey *symKey)
+{
+SECStatus rv;
+if (symKey->data.data != NULL) {
+	if (symKey->size == 0) {
+	   symKey->size = symKey->data.len;
+	}
+	return SECSuccess;
+}
+if (symKey->slot == NULL) {
+	PORT_SetError( SEC_ERROR_INVALID_KEY );
+	return SECFailure;
+}
+rv = PK11_ReadAttribute(symKey->slot,symKey->objectID,CKA_VALUE,NULL,
+				&symKey->data);
+if (rv == SECSuccess) {
+	symKey->size = symKey->data.len;
+}
+return rv;
+}
+SECStatus
+PK11_DeleteTokenSymKey(PK11SymKey *symKey)
+{
+if (!PK11_IsPermObject(symKey->slot, symKey->objectID)) {
+	return SECFailure;
+}
+PK11_DestroyTokenObject(symKey->slot,symKey->objectID);
+symKey->objectID = CK_INVALID_HANDLE;
+return SECSuccess;
+}
+SECItem *
+PK11_GetKeyData(PK11SymKey *symKey)
+{
+return &symKey->data;
+}
+/* This symbol is exported for backward compatibility. */
+SECItem *
+__PK11_GetKeyData(PK11SymKey *symKey)
+{
+return PK11_GetKeyData(symKey);
+}
+/*
+* PKCS #11 key Types with predefined length
+*/
+unsigned int
+pk11_GetPredefinedKeyLength(CK_KEY_TYPE keyType)
+{
+int length = 0;
+switch (keyType) {
+case CKK_DES: length = 8; break;
+case CKK_DES2: length = 16; break;
+case CKK_DES3: length = 24; break;
+case CKK_SKIPJACK: length = 10; break;
+case CKK_BATON: length = 20; break;
+case CKK_JUNIPER: length = 20; break;
+default: break;
+}
+return length;
+}
+/* return the keylength if possible.  '0' if not */
+unsigned int
+PK11_GetKeyLength(PK11SymKey *key)
+{
+CK_KEY_TYPE keyType;
+if (key->size != 0) return key->size;
+/* First try to figure out the key length from its type */
+keyType = PK11_ReadULongAttribute(key->slot,key->objectID,CKA_KEY_TYPE);
+key->size = pk11_GetPredefinedKeyLength(keyType);
+if ((keyType == CKK_GENERIC_SECRET) &&
+	(key->type == CKM_SSL3_PRE_MASTER_KEY_GEN))  {
+	key->size=48;
+}
+if( key->size != 0 ) return key->size;
+if (key->data.data == NULL) {
+	PK11_ExtractKeyValue(key);
+}
+/* key is probably secret. Look up its length */
+/*  this is new PKCS #11 version 2.0 functionality. */
+if (key->size == 0) {
+	CK_ULONG keyLength;
+	keyLength = PK11_ReadULongAttribute(key->slot,key->objectID,CKA_VALUE_LEN);
+	if (keyLength != CK_UNAVAILABLE_INFORMATION) {
+	    key->size = (unsigned int)keyLength;
+	}
+}
+return key->size;
+}
+/* return the strength of a key. This is different from length in that
+* 1) it returns the size in bits, and 2) it returns only the secret portions
+* of the key minus any checksums or parity.
+*/
+unsigned int
+PK11_GetKeyStrength(PK11SymKey *key, SECAlgorithmID *algid)
+{
+int size=0;
+CK_MECHANISM_TYPE mechanism= CKM_INVALID_MECHANISM; /* RC2 only */
+SECItem *param = NULL; /* RC2 only */
+CK_RC2_CBC_PARAMS *rc2_params = NULL; /* RC2 ONLY */
+unsigned int effectiveBits = 0; /* RC2 ONLY */
+switch (PK11_GetKeyType(key->type,0)) {
+case CKK_CDMF:
+	return 40;
+case CKK_DES:
+	return 56;
+case CKK_DES3:
+case CKK_DES2:
+	size = PK11_GetKeyLength(key);
+	if (size == 16) {
+	   /* double des */
+	   return 112; /* 16*7 */
+	}
+	return 168;
+/*
+* RC2 has is different than other ciphers in that it allows the user
+* to deprecating keysize while still requiring all the bits for the
+* original key. The info
+* on what the effective key strength is in the parameter for the key.
+* In S/MIME this parameter is stored in the DER encoded algid. In Our
+* other uses of RC2, effectiveBits == keyBits, so this code functions
+* correctly without an algid.
+*/
+case CKK_RC2:
+	/* if no algid was provided, fall through to default */
+if (!algid) {
+	    break;
+	}
+	/* verify that the algid is for RC2 */
+	mechanism = PK11_AlgtagToMechanism(SECOID_GetAlgorithmTag(algid));
+	if ((mechanism != CKM_RC2_CBC) && (mechanism != CKM_RC2_ECB)) {
+	    break;
+	}
+	/* now get effective bits from the algorithm ID. */
+	param = PK11_ParamFromAlgid(algid);
+	/* if we couldn't get memory just use key length */
+	if (param == NULL) {
+	    break;
+	}
+	rc2_params = (CK_RC2_CBC_PARAMS *) param->data;
+	/* paranoia... shouldn't happen */
+	PORT_Assert(param->data != NULL);
+	if (param->data == NULL) {
+	    SECITEM_FreeItem(param,PR_TRUE);
+	    break;
+	}
+	effectiveBits = (unsigned int)rc2_params->ulEffectiveBits;
+	SECITEM_FreeItem(param,PR_TRUE);
+	param = NULL; rc2_params=NULL; /* paranoia */
+	/* we have effective bits, is and allocated memory is free, now
+	 * we need to return the smaller of effective bits and keysize */
+	size = PK11_GetKeyLength(key);
+	if ((unsigned int)size*8 > effectiveBits) {
+	    return effectiveBits;
+	}
+	return size*8; /* the actual key is smaller, the strength can't be
+			* greater than the actual key size */
+default:
+	break;
+}
+return PK11_GetKeyLength(key) * 8;
+}
+/*
+* The next three utilities are to deal with the fact that a given operation
+* may be a multi-slot affair. This creates a new key object that is copied
+* into the new slot.
+*/
+PK11SymKey *
+pk11_CopyToSlotPerm(PK11SlotInfo *slot,CK_MECHANISM_TYPE type,
+	 	CK_ATTRIBUTE_TYPE operation, CK_FLAGS flags,
+		PRBool isPerm, PK11SymKey *symKey)
+{
+SECStatus rv;
+PK11SymKey *newKey = NULL;
+/* Extract the raw key data if possible */
+if (symKey->data.data == NULL) {
+	rv = PK11_ExtractKeyValue(symKey);
+	/* KEY is sensitive, we're try key exchanging it. */
+	if (rv != SECSuccess) {
+	    return pk11_KeyExchange(slot, type, operation,
+						flags, isPerm, symKey);
+	}
+}
+newKey = PK11_ImportSymKeyWithFlags(slot,  type, symKey->origin,
+	operation, &symKey->data, flags, isPerm, symKey->cx);
+if (newKey == NULL) {
+	newKey = pk11_KeyExchange(slot, type, operation, flags, isPerm, symKey);
+}
+return newKey;
+}
+PK11SymKey *
+pk11_CopyToSlot(PK11SlotInfo *slot,CK_MECHANISM_TYPE type,
+	CK_ATTRIBUTE_TYPE operation, PK11SymKey *symKey)
+{
+return pk11_CopyToSlotPerm(slot, type, operation, 0, PR_FALSE, symKey);
+}
+/*
+* Make sure the slot we are in is the correct slot for the operation
+* by verifying that it supports all of the specified mechanism types.
+*/
+PK11SymKey *
+pk11_ForceSlotMultiple(PK11SymKey *symKey, CK_MECHANISM_TYPE *type,
+			int mechCount, CK_ATTRIBUTE_TYPE operation)
+{
+PK11SlotInfo *slot = symKey->slot;
+PK11SymKey *newKey = NULL;
+PRBool needToCopy = PR_FALSE;
+int i;
+if (slot == NULL) {
+	needToCopy = PR_TRUE;
+} else {
+	i = 0;
+	while ((i < mechCount) && (needToCopy == PR_FALSE)) {
+	    if (!PK11_DoesMechanism(slot,type[i])) {
+		needToCopy = PR_TRUE;
+	    }
+	    i++;
+	}
+}
+if (needToCopy == PR_TRUE) {
+	slot = PK11_GetBestSlotMultiple(type,mechCount,symKey->cx);
+	if (slot == NULL) {
+	    PORT_SetError( SEC_ERROR_NO_MODULE );
+	    return NULL;
+	}
+	newKey = pk11_CopyToSlot(slot, type[0], operation, symKey);
+	PK11_FreeSlot(slot);
+}
+return newKey;
+}
+/*
+* Make sure the slot we are in is the correct slot for the operation
+*/
+PK11SymKey *
+pk11_ForceSlot(PK11SymKey *symKey,CK_MECHANISM_TYPE type,
+						CK_ATTRIBUTE_TYPE operation)
+{
+return pk11_ForceSlotMultiple(symKey, &type, 1, operation);
+}
+PK11SymKey *
+PK11_MoveSymKey(PK11SlotInfo *slot, CK_ATTRIBUTE_TYPE operation,
+			CK_FLAGS flags, PRBool  perm, PK11SymKey *symKey)
+{
+if (symKey->slot == slot) {
+	if (perm) {
+	   return PK11_ConvertSessionSymKeyToTokenSymKey(symKey,symKey->cx);
+	} else {
+	   return PK11_ReferenceSymKey(symKey);
+	}
+}
+return pk11_CopyToSlotPerm(slot, symKey->type,
+					operation, flags, perm, symKey);
+}
+/*
+* Use the token to generate a key.
+*
+* keySize must be 'zero' for fixed key length algorithms. A nonzero
+*  keySize causes the CKA_VALUE_LEN attribute to be added to the template
+*  for the key. Most PKCS #11 modules fail if you specify the CKA_VALUE_LEN
+*  attribute for keys with fixed length. The exception is DES2. If you
+*  select a CKM_DES3_CBC mechanism, this code will not add the CKA_VALUE_LEN
+*  parameter and use the key size to determine which underlying DES keygen
+*  function to use (CKM_DES2_KEY_GEN or CKM_DES3_KEY_GEN).
+*
+* keyType must be -1 for most algorithms. Some PBE algorthims cannot
+*  determine the correct key type from the mechanism or the parameters,
+*  so key type must be specified. Other PKCS #11 mechanisms may do so in
+*  the future. Currently there is no need to export this publically.
+*  Keep it private until there is a need in case we need to expand the
+*  keygen parameters again...
+*
+* CK_FLAGS flags: key operation flags
+* PK11AttrFlags attrFlags: PK11_ATTR_XXX key attribute flags
+*/
+PK11SymKey *
+pk11_TokenKeyGenWithFlagsAndKeyType(PK11SlotInfo *slot, CK_MECHANISM_TYPE type,
+SECItem *param, CK_KEY_TYPE keyType, int keySize, SECItem *keyid,
+CK_FLAGS opFlags, PK11AttrFlags attrFlags, void *wincx)
+{
+PK11SymKey *symKey;
+CK_ATTRIBUTE genTemplate[MAX_TEMPL_ATTRS];
+CK_ATTRIBUTE *attrs = genTemplate;
+int count = sizeof(genTemplate)/sizeof(genTemplate[0]);
+CK_MECHANISM_TYPE keyGenType;
+CK_BBOOL cktrue = CK_TRUE;
+CK_BBOOL ckfalse = CK_FALSE;
+CK_ULONG ck_key_size;       /* only used for variable-length keys */
+if (pk11_BadAttrFlags(attrFlags)) {
+	PORT_SetError( SEC_ERROR_INVALID_ARGS );
+	return NULL;
+}
+if ((keySize != 0) && (type != CKM_DES3_CBC) &&
+		(type !=CKM_DES3_CBC_PAD) && (type != CKM_DES3_ECB)) {
+ck_key_size = keySize; /* Convert to PK11 type */
+PK11_SETATTRS(attrs, CKA_VALUE_LEN, &ck_key_size, sizeof(ck_key_size));
+							attrs++;
+}
+if (keyType != -1) {
+PK11_SETATTRS(attrs, CKA_KEY_TYPE, &keyType, sizeof(CK_KEY_TYPE));
+							attrs++;
+}
+/* Include key id value if provided */
+if (keyid) {
+PK11_SETATTRS(attrs, CKA_ID, keyid->data, keyid->len); attrs++;
+}
+attrs += pk11_AttrFlagsToAttributes(attrFlags, attrs, &cktrue, &ckfalse);
+attrs += pk11_OpFlagsToAttributes(opFlags, attrs, &cktrue);
+count = attrs - genTemplate;
+PR_ASSERT(count <= sizeof(genTemplate)/sizeof(CK_ATTRIBUTE));
+keyGenType = PK11_GetKeyGenWithSize(type, keySize);
+if (keyGenType == CKM_FAKE_RANDOM) {
+PORT_SetError( SEC_ERROR_NO_MODULE );
+return NULL;
+}
+symKey = PK11_KeyGenWithTemplate(slot, type, keyGenType,
+param, genTemplate, count, wincx);
+if (symKey != NULL) {
+symKey->size = keySize;
+}
+return symKey;
+}
+/*
+* Use the token to generate a key.  - Public
+*
+* keySize must be 'zero' for fixed key length algorithms. A nonzero
+*  keySize causes the CKA_VALUE_LEN attribute to be added to the template
+*  for the key. Most PKCS #11 modules fail if you specify the CKA_VALUE_LEN
+*  attribute for keys with fixed length. The exception is DES2. If you
+*  select a CKM_DES3_CBC mechanism, this code will not add the CKA_VALUE_LEN
+*  parameter and use the key size to determine which underlying DES keygen
+*  function to use (CKM_DES2_KEY_GEN or CKM_DES3_KEY_GEN).
+*
+* CK_FLAGS flags: key operation flags
+* PK11AttrFlags attrFlags: PK11_ATTR_XXX key attribute flags
+*/
+PK11SymKey *
+PK11_TokenKeyGenWithFlags(PK11SlotInfo *slot, CK_MECHANISM_TYPE type,
+SECItem *param, int keySize, SECItem *keyid, CK_FLAGS opFlags,
+PK11AttrFlags attrFlags, void *wincx)
+{
+return pk11_TokenKeyGenWithFlagsAndKeyType(slot, type, param, -1, keySize,
+	keyid, opFlags, attrFlags, wincx);
+}
+/*
+* Use the token to generate a key. keySize must be 'zero' for fixed key
+* length algorithms. A nonzero keySize causes the CKA_VALUE_LEN attribute
+* to be added to the template for the key. PKCS #11 modules fail if you
+* specify the CKA_VALUE_LEN attribute for keys with fixed length.
+* NOTE: this means to generate a DES2 key from this interface you must
+* specify CKM_DES2_KEY_GEN as the mechanism directly; specifying
+* CKM_DES3_CBC as the mechanism and 16 as keySize currently doesn't work.
+*/
+PK11SymKey *
+PK11_TokenKeyGen(PK11SlotInfo *slot, CK_MECHANISM_TYPE type, SECItem *param,
+int keySize, SECItem *keyid, PRBool isToken, void *wincx)
+{
+PK11SymKey *symKey;
+PRBool weird = PR_FALSE;   /* hack for fortezza */
+CK_FLAGS opFlags = CKF_SIGN;
+PK11AttrFlags attrFlags = 0;
+if ((keySize == -1) && (type == CKM_SKIPJACK_CBC64)) {
+	weird = PR_TRUE;
+	keySize = 0;
+}
+opFlags |= weird ? CKF_DECRYPT : CKF_ENCRYPT;
+if (isToken) {
+	attrFlags |= (PK11_ATTR_TOKEN | PK11_ATTR_PRIVATE);
+}
+symKey = pk11_TokenKeyGenWithFlagsAndKeyType(slot, type, param,
+			-1, keySize, keyid, opFlags, attrFlags, wincx);
+if (symKey && weird) {
+	PK11_SetFortezzaHack(symKey);
+}
+return symKey;
+}
+PK11SymKey *
+PK11_KeyGen(PK11SlotInfo *slot, CK_MECHANISM_TYPE type, SECItem *param,
+						int keySize, void *wincx)
+{
+return PK11_TokenKeyGen(slot, type, param, keySize, 0, PR_FALSE, wincx);
+}
+PK11SymKey *
+PK11_KeyGenWithTemplate(PK11SlotInfo *slot, CK_MECHANISM_TYPE type,
+CK_MECHANISM_TYPE keyGenType,
+SECItem *param, CK_ATTRIBUTE * attrs,
+unsigned int attrsCount, void *wincx)
+{
+PK11SymKey *symKey;
+CK_SESSION_HANDLE session;
+CK_MECHANISM mechanism;
+CK_RV crv;
+PRBool isToken = CK_FALSE;
+CK_ULONG keySize = 0;
+unsigned i;
+/* Extract the template's CKA_VALUE_LEN into keySize and CKA_TOKEN into
+isToken. */
+for (i = 0; i < attrsCount; ++i) {
+switch (attrs[i].type) {
+case CKA_VALUE_LEN:
+if (attrs[i].pValue == NULL ||
+attrs[i].ulValueLen != sizeof(CK_ULONG)) {
+PORT_SetError(PK11_MapError(CKR_TEMPLATE_INCONSISTENT));
+return NULL;
+}
+keySize = * (CK_ULONG *) attrs[i].pValue;
+break;
+case CKA_TOKEN:
+if (attrs[i].pValue == NULL ||
+attrs[i].ulValueLen != sizeof(CK_BBOOL)) {
+PORT_SetError(PK11_MapError(CKR_TEMPLATE_INCONSISTENT));
+return NULL;
+}
+isToken = (*(CK_BBOOL*)attrs[i].pValue) ? PR_TRUE : PR_FALSE;
+break;
+}
+}
+/* find a slot to generate the key into */
+/* Only do slot management if this is not a token key */
+if (!isToken && (slot == NULL || !PK11_DoesMechanism(slot,type))) {
+PK11SlotInfo *bestSlot = PK11_GetBestSlot(type,wincx);
+if (bestSlot == NULL) {
+PORT_SetError( SEC_ERROR_NO_MODULE );
+return NULL;
+}
+symKey = pk11_CreateSymKey(bestSlot, type, !isToken, PR_TRUE, wincx);
+PK11_FreeSlot(bestSlot);
+} else {
+symKey = pk11_CreateSymKey(slot, type, !isToken, PR_TRUE, wincx);
+}
+if (symKey == NULL) return NULL;
+symKey->size = keySize;
+symKey->origin = PK11_OriginGenerated;
+/* Set the parameters for the key gen if provided */
+mechanism.mechanism = keyGenType;
+mechanism.pParameter = NULL;
+mechanism.ulParameterLen = 0;
+if (param) {
+mechanism.pParameter = param->data;
+mechanism.ulParameterLen = param->len;
+}
+/* Get session and perform locking */
+if (isToken) {
+PK11_Authenticate(symKey->slot,PR_TRUE,wincx);
+/* Should always be original slot */
+session = PK11_GetRWSession(symKey->slot);
+symKey->owner = PR_FALSE;
+} else {
+session = symKey->session;
+if (session != CK_INVALID_SESSION)
+pk11_EnterKeyMonitor(symKey);
+}
+if (session == CK_INVALID_SESSION) {
+PK11_FreeSymKey(symKey);
+PORT_SetError(SEC_ERROR_BAD_DATA);
+return NULL;
+}
+crv = PK11_GETTAB(symKey->slot)->C_GenerateKey(session,
+			 &mechanism, attrs, attrsCount, &symKey->objectID);
+/* Release lock and session */
+if (isToken) {
+PK11_RestoreROSession(symKey->slot, session);
+} else {
+pk11_ExitKeyMonitor(symKey);
+}
+if (crv != CKR_OK) {
+PK11_FreeSymKey(symKey);
+PORT_SetError( PK11_MapError(crv) );
+return NULL;
+}
+return symKey;
+}
+/* --- */
+PK11SymKey *
+PK11_GenDES3TokenKey(PK11SlotInfo *slot, SECItem *keyid, void *cx)
+{
+return PK11_TokenKeyGen(slot, CKM_DES3_CBC, 0, 0, keyid, PR_TRUE, cx);
+}
+PK11SymKey*
+PK11_ConvertSessionSymKeyToTokenSymKey(PK11SymKey *symk, void *wincx)
+{
+PK11SlotInfo* slot = symk->slot;
+CK_ATTRIBUTE template[1];
+CK_ATTRIBUTE *attrs = template;
+CK_BBOOL cktrue = CK_TRUE;
+CK_RV crv;
+CK_OBJECT_HANDLE newKeyID;
+CK_SESSION_HANDLE rwsession;
+PK11_SETATTRS(attrs, CKA_TOKEN, &cktrue, sizeof(cktrue)); attrs++;
+PK11_Authenticate(slot, PR_TRUE, wincx);
+rwsession = PK11_GetRWSession(slot);
+if (rwsession == CK_INVALID_SESSION) {
+	PORT_SetError(SEC_ERROR_BAD_DATA);
+	return NULL;
+}
+crv = PK11_GETTAB(slot)->C_CopyObject(rwsession, symk->objectID,
+template, 1, &newKeyID);
+PK11_RestoreROSession(slot, rwsession);
+if (crv != CKR_OK) {
+PORT_SetError( PK11_MapError(crv) );
+return NULL;
+}
+return PK11_SymKeyFromHandle(slot, NULL /*parent*/, symk->origin,
+symk->type, newKeyID, PR_FALSE /*owner*/, NULL /*wincx*/);
+}
+/*
+* This function does a straight public key wrap (which only RSA can do).
+* Use PK11_PubGenKey and PK11_WrapSymKey to implement the FORTEZZA and
+* Diffie-Hellman Ciphers. */
+SECStatus
+PK11_PubWrapSymKey(CK_MECHANISM_TYPE type, SECKEYPublicKey *pubKey,
+				PK11SymKey *symKey, SECItem *wrappedKey)
+{
+PK11SlotInfo *slot;
+CK_ULONG len =  wrappedKey->len;
+PK11SymKey *newKey = NULL;
+CK_OBJECT_HANDLE id;
+CK_MECHANISM mechanism;
+PRBool owner = PR_TRUE;
+CK_SESSION_HANDLE session;
+CK_RV crv;
+if (symKey == NULL) {
+	PORT_SetError( SEC_ERROR_INVALID_ARGS );
+	return SECFailure;
+}
+/* if this slot doesn't support the mechanism, go to a slot that does */
+newKey = pk11_ForceSlot(symKey,type,CKA_ENCRYPT);
+if (newKey != NULL) {
+	symKey = newKey;
+}
+if (symKey->slot == NULL) {
+	PORT_SetError( SEC_ERROR_NO_MODULE );
+	return SECFailure;
+}
+slot = symKey->slot;
+mechanism.mechanism = pk11_mapWrapKeyType(pubKey->keyType);
+mechanism.pParameter = NULL;
+mechanism.ulParameterLen = 0;
+id = PK11_ImportPublicKey(slot,pubKey,PR_FALSE);
+if (id == CK_INVALID_HANDLE) {
+	if (newKey) {
+	    PK11_FreeSymKey(newKey);
+	}
+	return SECFailure;   /* Error code has been set. */
+}
+session = pk11_GetNewSession(slot,&owner);
+if (!owner || !(slot->isThreadSafe)) PK11_EnterSlotMonitor(slot);
+crv = PK11_GETTAB(slot)->C_WrapKey(session,&mechanism,
+		id,symKey->objectID,wrappedKey->data,&len);
+if (!owner || !(slot->isThreadSafe)) PK11_ExitSlotMonitor(slot);
+pk11_CloseSession(slot,session,owner);
+if (newKey) {
+	PK11_FreeSymKey(newKey);
+}
+if (crv != CKR_OK) {
+	PORT_SetError( PK11_MapError(crv) );
+	return SECFailure;
+}
+wrappedKey->len = len;
+return SECSuccess;
+}
+/*
+* this little function uses the Encrypt function to wrap a key, just in
+* case we have problems with the wrap implementation for a token.
+*/
+static SECStatus
+pk11_HandWrap(PK11SymKey *wrappingKey, SECItem *param, CK_MECHANISM_TYPE type,
+			 SECItem *inKey, SECItem *outKey)
+{
+PK11SlotInfo *slot;
+CK_ULONG len;
+SECItem *data;
+CK_MECHANISM mech;
+PRBool owner = PR_TRUE;
+CK_SESSION_HANDLE session;
+CK_RV crv;
+slot = wrappingKey->slot;
+/* use NULL IV's for wrapping */
+mech.mechanism = type;
+if (param) {
+	mech.pParameter = param->data;
+	mech.ulParameterLen = param->len;
+} else {
+	mech.pParameter = NULL;
+	mech.ulParameterLen = 0;
+}
+session = pk11_GetNewSession(slot,&owner);
+if (!owner || !(slot->isThreadSafe)) PK11_EnterSlotMonitor(slot);
+crv = PK11_GETTAB(slot)->C_EncryptInit(session,&mech,
+							wrappingKey->objectID);
+if (crv != CKR_OK) {
+if (!owner || !(slot->isThreadSafe)) PK11_ExitSlotMonitor(slot);
+pk11_CloseSession(slot,session,owner);
+	PORT_SetError( PK11_MapError(crv) );
+	return SECFailure;
+}
+/* keys are almost always aligned, but if we get this far,
+* we've gone above and beyond anyway... */
+data = PK11_BlockData(inKey,PK11_GetBlockSize(type,param));
+if (data == NULL) {
+if (!owner || !(slot->isThreadSafe)) PK11_ExitSlotMonitor(slot);
+pk11_CloseSession(slot,session,owner);
+	PORT_SetError(SEC_ERROR_NO_MEMORY);
+	return SECFailure;
+}
+len = outKey->len;
+crv = PK11_GETTAB(slot)->C_Encrypt(session,data->data,data->len,
+							   outKey->data, &len);
+if (!owner || !(slot->isThreadSafe)) PK11_ExitSlotMonitor(slot);
+pk11_CloseSession(slot,session,owner);
+SECITEM_FreeItem(data,PR_TRUE);
+outKey->len = len;
+if (crv != CKR_OK) {
+	PORT_SetError( PK11_MapError(crv) );
+	return SECFailure;
+}
+return SECSuccess;
+}
+/*
+* This function does a symetric based wrap.
+*/
+SECStatus
+PK11_WrapSymKey(CK_MECHANISM_TYPE type, SECItem *param,
+	PK11SymKey *wrappingKey, PK11SymKey *symKey, SECItem *wrappedKey)
+{
+PK11SlotInfo *slot;
+CK_ULONG len = wrappedKey->len;
+PK11SymKey *newKey = NULL;
+SECItem *param_save = NULL;
+CK_MECHANISM mechanism;
+PRBool owner = PR_TRUE;
+CK_SESSION_HANDLE session;
+CK_RV crv;
+SECStatus rv;
+/* if this slot doesn't support the mechanism, go to a slot that does */
+/* Force symKey and wrappingKey into the same slot */
+if ((wrappingKey->slot == NULL) || (symKey->slot != wrappingKey->slot)) {
+	/* first try copying the wrapping Key to the symKey slot */
+	if (symKey->slot && PK11_DoesMechanism(symKey->slot,type)) {
+	    newKey = pk11_CopyToSlot(symKey->slot,type,CKA_WRAP,wrappingKey);
+	}
+	/* Nope, try it the other way */
+	if (newKey == NULL) {
+	    if (wrappingKey->slot) {
+	        newKey = pk11_CopyToSlot(wrappingKey->slot,
+					symKey->type, CKA_ENCRYPT, symKey);
+	    }
+	    /* just not playing... one last thing, can we get symKey's data?
+	     * If it's possible, we it should already be in the
+	     * symKey->data.data pointer because pk11_CopyToSlot would have
+	     * tried to put it there. */
+	    if (newKey == NULL) {
+		/* Can't get symKey's data: Game Over */
+		if (symKey->data.data == NULL) {
+		    PORT_SetError( SEC_ERROR_NO_MODULE );
+		    return SECFailure;
+		}
+		if (param == NULL) {
+		    param_save = param = PK11_ParamFromIV(type,NULL);
+		}
+		rv = pk11_HandWrap(wrappingKey, param, type,
+						&symKey->data,wrappedKey);
+		if (param_save) SECITEM_FreeItem(param_save,PR_TRUE);
+		return rv;
+	    }
+	    /* we successfully moved the sym Key */
+	    symKey = newKey;
+	} else {
+	    /* we successfully moved the wrapping Key */
+	    wrappingKey = newKey;
+	}
+}
+/* at this point both keys are in the same token */
+slot = wrappingKey->slot;
+mechanism.mechanism = type;
+/* use NULL IV's for wrapping */
+if (param == NULL) {
+	param_save = param = PK11_ParamFromIV(type,NULL);
+}
+if (param) {
+	mechanism.pParameter = param->data;
+	mechanism.ulParameterLen = param->len;
+} else {
+	mechanism.pParameter = NULL;
+	mechanism.ulParameterLen = 0;
+}
+len = wrappedKey->len;
+session = pk11_GetNewSession(slot,&owner);
+if (!owner || !(slot->isThreadSafe)) PK11_EnterSlotMonitor(slot);
+crv = PK11_GETTAB(slot)->C_WrapKey(session, &mechanism,
+		 wrappingKey->objectID, symKey->objectID,
+						wrappedKey->data, &len);
+if (!owner || !(slot->isThreadSafe)) PK11_ExitSlotMonitor(slot);
+pk11_CloseSession(slot,session,owner);
+rv = SECSuccess;
+if (crv != CKR_OK) {
+	/* can't wrap it? try hand wrapping it... */
+	do {
+	    if (symKey->data.data == NULL) {
+		rv = PK11_ExtractKeyValue(symKey);
+		if (rv != SECSuccess) break;
+	    }
+	    rv = pk11_HandWrap(wrappingKey, param, type, &symKey->data,
+								 wrappedKey);
+	} while (PR_FALSE);
+} else {
+wrappedKey->len = len;
+}
+if (newKey) PK11_FreeSymKey(newKey);
+if (param_save) SECITEM_FreeItem(param_save,PR_TRUE);
+return rv;
+}
+/*
+* This Generates a new key based on a symetricKey
+*/
+PK11SymKey *
+PK11_Derive( PK11SymKey *baseKey, CK_MECHANISM_TYPE derive, SECItem *param,
+CK_MECHANISM_TYPE target, CK_ATTRIBUTE_TYPE operation,
+	     int keySize)
+{
+return PK11_DeriveWithTemplate(baseKey, derive, param, target, operation,
+				   keySize, NULL, 0, PR_FALSE);
+}
+PK11SymKey *
+PK11_DeriveWithFlags( PK11SymKey *baseKey, CK_MECHANISM_TYPE derive,
+	SECItem *param, CK_MECHANISM_TYPE target, CK_ATTRIBUTE_TYPE operation,
+	int keySize, CK_FLAGS flags)
+{
+CK_BBOOL        ckTrue	= CK_TRUE;
+CK_ATTRIBUTE    keyTemplate[MAX_TEMPL_ATTRS];
+unsigned int    templateCount;
+templateCount = pk11_OpFlagsToAttributes(flags, keyTemplate, &ckTrue);
+return PK11_DeriveWithTemplate(baseKey, derive, param, target, operation,
+		  keySize, keyTemplate, templateCount, PR_FALSE);
+}
+PK11SymKey *
+PK11_DeriveWithFlagsPerm( PK11SymKey *baseKey, CK_MECHANISM_TYPE derive,
+	SECItem *param, CK_MECHANISM_TYPE target, CK_ATTRIBUTE_TYPE operation,
+	int keySize, CK_FLAGS flags, PRBool isPerm)
+{
+CK_BBOOL        cktrue	= CK_TRUE;
+CK_ATTRIBUTE    keyTemplate[MAX_TEMPL_ATTRS];
+CK_ATTRIBUTE    *attrs;
+unsigned int    templateCount = 0;
+attrs = keyTemplate;
+if (isPerm) {
+PK11_SETATTRS(attrs, CKA_TOKEN,  &cktrue, sizeof(CK_BBOOL)); attrs++;
+}
+templateCount = attrs - keyTemplate;
+templateCount += pk11_OpFlagsToAttributes(flags, attrs, &cktrue);
+return PK11_DeriveWithTemplate(baseKey, derive, param, target, operation,
+				   keySize, keyTemplate, templateCount, isPerm);
+}
+PK11SymKey *
+PK11_DeriveWithTemplate( PK11SymKey *baseKey, CK_MECHANISM_TYPE derive,
+	SECItem *param, CK_MECHANISM_TYPE target, CK_ATTRIBUTE_TYPE operation,
+	int keySize, CK_ATTRIBUTE *userAttr, unsigned int numAttrs,
+							 PRBool isPerm)
+{
+PK11SlotInfo *  slot	= baseKey->slot;
+PK11SymKey *    symKey;
+PK11SymKey *    newBaseKey	= NULL;
+CK_BBOOL        cktrue	= CK_TRUE;
+CK_OBJECT_CLASS keyClass	= CKO_SECRET_KEY;
+CK_KEY_TYPE     keyType	= CKK_GENERIC_SECRET;
+CK_ULONG        valueLen	= 0;
+CK_MECHANISM    mechanism;
+CK_RV           crv;
+#define MAX_ADD_ATTRS 4
+CK_ATTRIBUTE    keyTemplate[MAX_TEMPL_ATTRS + MAX_ADD_ATTRS];
+#undef MAX_ADD_ATTRS
+CK_ATTRIBUTE *  attrs	= keyTemplate;
+CK_SESSION_HANDLE session;
+unsigned int    templateCount;
+if (numAttrs > MAX_TEMPL_ATTRS) {
+	PORT_SetError(SEC_ERROR_INVALID_ARGS);
+	return NULL;
+}
+/* first copy caller attributes in. */
+for (templateCount = 0; templateCount < numAttrs; ++templateCount) {
+	*attrs++ = *userAttr++;
+}
+/* We only add the following attributes to the template if the caller
+** didn't already supply them.
+*/
+if (!pk11_FindAttrInTemplate(keyTemplate, numAttrs, CKA_CLASS)) {
+	PK11_SETATTRS(attrs, CKA_CLASS,     &keyClass, sizeof keyClass);
+	attrs++;
+}
+if (!pk11_FindAttrInTemplate(keyTemplate, numAttrs, CKA_KEY_TYPE)) {
+	keyType = PK11_GetKeyType(target, keySize);
+	PK11_SETATTRS(attrs, CKA_KEY_TYPE,  &keyType,  sizeof keyType );
+	attrs++;
+}
+if (keySize > 0 &&
+	  !pk11_FindAttrInTemplate(keyTemplate, numAttrs, CKA_VALUE_LEN)) {
+	valueLen = (CK_ULONG)keySize;
+	PK11_SETATTRS(attrs, CKA_VALUE_LEN, &valueLen, sizeof valueLen);
+	attrs++;
+}
+if ((operation != CKA_FLAGS_ONLY) &&
+	  !pk11_FindAttrInTemplate(keyTemplate, numAttrs, operation)) {
+	PK11_SETATTRS(attrs, operation, &cktrue, sizeof cktrue); attrs++;
+}
+templateCount = attrs - keyTemplate;
+PR_ASSERT(templateCount <= sizeof(keyTemplate)/sizeof(CK_ATTRIBUTE));
+/* move the key to a slot that can do the function */
+if (!PK11_DoesMechanism(slot,derive)) {
+	/* get a new base key & slot */
+	PK11SlotInfo *newSlot = PK11_GetBestSlot(derive, baseKey->cx);
+	if (newSlot == NULL) return NULL;
+newBaseKey = pk11_CopyToSlot (newSlot, derive, CKA_DERIVE,
+				     baseKey);
+	PK11_FreeSlot(newSlot);
+	if (newBaseKey == NULL)
+	    return NULL;
+	baseKey = newBaseKey;
+	slot = baseKey->slot;
+}
+/* get our key Structure */
+symKey = pk11_CreateSymKey(slot, target, !isPerm, PR_TRUE, baseKey->cx);
+if (symKey == NULL) {
+	return NULL;
+}
+symKey->size = keySize;
+mechanism.mechanism = derive;
+if (param) {
+	mechanism.pParameter = param->data;
+	mechanism.ulParameterLen = param->len;
+} else {
+	mechanism.pParameter = NULL;
+	mechanism.ulParameterLen = 0;
+}
+symKey->origin=PK11_OriginDerive;
+if (isPerm) {
+	session =  PK11_GetRWSession(slot);
+} else {
+pk11_EnterKeyMonitor(symKey);
+	session = symKey->session;
+}
+if (session == CK_INVALID_SESSION) {
+	if (!isPerm)
+	    pk11_ExitKeyMonitor(symKey);
+	crv = CKR_SESSION_HANDLE_INVALID;
+} else {
+	crv = PK11_GETTAB(slot)->C_DeriveKey(session, &mechanism,
+	     baseKey->objectID, keyTemplate, templateCount, &symKey->objectID);
+	if (isPerm) {
+	    PK11_RestoreROSession(slot, session);
+	} else {
+	    pk11_ExitKeyMonitor(symKey);
+	}
+}
+if (newBaseKey)
+	PK11_FreeSymKey(newBaseKey);
+if (crv != CKR_OK) {
+	PK11_FreeSymKey(symKey);
+	return NULL;
+}
+return symKey;
+}
+/* Create a new key by concatenating base and data
+*/
+static PK11SymKey *pk11_ConcatenateBaseAndData(PK11SymKey *base,
+	CK_BYTE *data, CK_ULONG dataLen, CK_MECHANISM_TYPE target,
+	CK_ATTRIBUTE_TYPE operation)
+{
+CK_KEY_DERIVATION_STRING_DATA mechParams;
+SECItem param;
+if (base == NULL) {
+	PORT_SetError( SEC_ERROR_INVALID_ARGS );
+	return NULL;
+}
+mechParams.pData = data;
+mechParams.ulLen = dataLen;
+param.data = (unsigned char *)&mechParams;
+param.len = sizeof(CK_KEY_DERIVATION_STRING_DATA);
+return PK11_Derive(base, CKM_CONCATENATE_BASE_AND_DATA,
+				&param, target, operation, 0);
+}
+/* Create a new key by concatenating base and key
+*/
+static PK11SymKey *pk11_ConcatenateBaseAndKey(PK11SymKey *base,
+			PK11SymKey *key, CK_MECHANISM_TYPE target,
+			CK_ATTRIBUTE_TYPE operation, CK_ULONG keySize)
+{
+SECItem param;
+if ((base == NULL) || (key == NULL)) {
+	PORT_SetError( SEC_ERROR_INVALID_ARGS );
+	return NULL;
+}
+param.data = (unsigned char *)&(key->objectID);
+param.len = sizeof(CK_OBJECT_HANDLE);
+return PK11_Derive(base, CKM_CONCATENATE_BASE_AND_KEY,
+				&param, target, operation, keySize);
+}
+/* Create a new key whose value is the hash of tobehashed.
+* type is the mechanism for the derived key.
+*/
+static PK11SymKey *pk11_HashKeyDerivation(PK11SymKey *toBeHashed,
+	CK_MECHANISM_TYPE hashMechanism, CK_MECHANISM_TYPE target,
+	CK_ATTRIBUTE_TYPE operation, CK_ULONG keySize)
+{
+return PK11_Derive(toBeHashed, hashMechanism, NULL, target, operation, keySize);
+}
+/* This function implements the ANSI X9.63 key derivation function
+*/
+static PK11SymKey *pk11_ANSIX963Derive(PK11SymKey *sharedSecret,
+		CK_EC_KDF_TYPE kdf, SECItem *sharedData,
+		CK_MECHANISM_TYPE target, CK_ATTRIBUTE_TYPE operation,
+		CK_ULONG keySize)
+{
+CK_KEY_TYPE keyType;
+CK_MECHANISM_TYPE hashMechanism, mechanismArray[4];
+CK_ULONG derivedKeySize, HashLen, counter, maxCounter, bufferLen;
+CK_ULONG SharedInfoLen;
+CK_BYTE *buffer = NULL;
+PK11SymKey *toBeHashed, *hashOutput;
+PK11SymKey *newSharedSecret = NULL;
+PK11SymKey *oldIntermediateResult, *intermediateResult = NULL;
+if (sharedSecret == NULL) {
+	PORT_SetError( SEC_ERROR_INVALID_ARGS );
+	return NULL;
+}
+switch (kdf) {
+case CKD_SHA1_KDF:
+	HashLen = SHA1_LENGTH;
+	hashMechanism = CKM_SHA1_KEY_DERIVATION;
+	break;
+case CKD_SHA224_KDF:
+	HashLen = SHA224_LENGTH;
+	hashMechanism = CKM_SHA224_KEY_DERIVATION;
+	break;
+case CKD_SHA256_KDF:
+	HashLen = SHA256_LENGTH;
+	hashMechanism = CKM_SHA256_KEY_DERIVATION;
+	break;
+case CKD_SHA384_KDF:
+	HashLen = SHA384_LENGTH;
+	hashMechanism = CKM_SHA384_KEY_DERIVATION;
+	break;
+case CKD_SHA512_KDF:
+	HashLen = SHA512_LENGTH;
+	hashMechanism = CKM_SHA512_KEY_DERIVATION;
+	break;
+default:
+	PORT_SetError( SEC_ERROR_INVALID_ARGS );
+	return NULL;
+}
+derivedKeySize = keySize;
+if (derivedKeySize == 0) {
+	keyType = PK11_GetKeyType(target,keySize);
+	derivedKeySize = pk11_GetPredefinedKeyLength(keyType);
+	if (derivedKeySize == 0) {
+	    derivedKeySize = HashLen;
+	}
+}
+/* Check that key_len isn't too long.  The maximum key length could be
+* greatly increased if the code below did not limit the 4-byte counter
+* to a maximum value of 255. */
+if (derivedKeySize > 254 * HashLen) {
+	PORT_SetError( SEC_ERROR_INVALID_ARGS );
+	return NULL;
+}
+maxCounter = derivedKeySize / HashLen;
+if (derivedKeySize > maxCounter * HashLen)
+	maxCounter++;
+if ((sharedData == NULL) || (sharedData->data == NULL))
+	SharedInfoLen = 0;
+else
+	SharedInfoLen = sharedData->len;
+bufferLen = SharedInfoLen + 4;
+/* Populate buffer with Counter || sharedData
+* where Counter is 0x00000001. */
+buffer = (unsigned char *)PORT_Alloc(bufferLen);
+if (buffer == NULL) {
+	PORT_SetError(SEC_ERROR_NO_MEMORY);
+	return NULL;
+}
+buffer[0] = 0;
+buffer[1] = 0;
+buffer[2] = 0;
+buffer[3] = 1;
+if (SharedInfoLen > 0) {
+	PORT_Memcpy(&buffer[4], sharedData->data, SharedInfoLen);
+}
+/* Look for a slot that supports the mechanisms needed
+* to implement the ANSI X9.63 KDF as well as the
+* target mechanism.
+*/
+mechanismArray[0] = CKM_CONCATENATE_BASE_AND_DATA;
+mechanismArray[1] = hashMechanism;
+mechanismArray[2] = CKM_CONCATENATE_BASE_AND_KEY;
+mechanismArray[3] = target;
+newSharedSecret = pk11_ForceSlotMultiple(sharedSecret,
+					 mechanismArray, 4, operation);
+if (newSharedSecret != NULL) {
+	sharedSecret = newSharedSecret;
+}
+for(counter=1; counter <= maxCounter; counter++) {
+	/* Concatenate shared_secret and buffer */
+	toBeHashed = pk11_ConcatenateBaseAndData(sharedSecret, buffer,
+					bufferLen, hashMechanism, operation);
+	if (toBeHashed == NULL) {
+	    goto loser;
+	}
+	/* Hash value */
+	if (maxCounter == 1) {
+	    /* In this case the length of the key to be derived is
+	     * less than or equal to the length of the hash output.
+	     * So, the output of the hash operation will be the
+	     * dervied key. */
+	    hashOutput = pk11_HashKeyDerivation(toBeHashed, hashMechanism,
+						target, operation, keySize);
+	} else {
+	    /* In this case, the output of the hash operation will be
+	     * concatenated with other data to create the derived key. */
+	    hashOutput = pk11_HashKeyDerivation(toBeHashed, hashMechanism,
+				CKM_CONCATENATE_BASE_AND_KEY, operation, 0);
+	}
+	PK11_FreeSymKey(toBeHashed);
+	if (hashOutput == NULL) {
+	    goto loser;
+	}
+	/* Append result to intermediate result, if necessary */
+	oldIntermediateResult = intermediateResult;
+	if (oldIntermediateResult == NULL) {
+	    intermediateResult = hashOutput;
+	} else {
+	    if (counter == maxCounter) {
+		/* This is the final concatenation, and so the output
+		 * will be the derived key. */
+		intermediateResult =
+		    pk11_ConcatenateBaseAndKey(oldIntermediateResult,
+				hashOutput, target, operation, keySize);
+	    } else {
+		/* The output of this concatenation will be concatenated
+		 * with other data to create the derived key. */
+		intermediateResult =
+		    pk11_ConcatenateBaseAndKey(oldIntermediateResult,
+				hashOutput, CKM_CONCATENATE_BASE_AND_KEY,
+				operation, 0);
+	    }
+	    PK11_FreeSymKey(hashOutput);
+	    PK11_FreeSymKey(oldIntermediateResult);
+	    if (intermediateResult == NULL) {
+		goto loser;
+	    }
+	}
+	/* Increment counter (assumes maxCounter < 255) */
+	buffer[3]++;
+}
+PORT_ZFree(buffer, bufferLen);
+if (newSharedSecret != NULL)
+	PK11_FreeSymKey(newSharedSecret);
+return intermediateResult;
+loser:
+if (buffer != NULL)
+	PORT_ZFree(buffer, bufferLen);
+if (newSharedSecret != NULL)
+	PK11_FreeSymKey(newSharedSecret);
+if (intermediateResult != NULL)
+	PK11_FreeSymKey(intermediateResult);
+return NULL;
+}
+/*
+* This Generates a wrapping key based on a privateKey, publicKey, and two
+* random numbers. For Mail usage RandomB should be NULL. In the Sender's
+* case RandomA is generate, outherwize it is passed.
+*/
+static unsigned char *rb_email = NULL;
+PK11SymKey *
+PK11_PubDerive(SECKEYPrivateKey *privKey, SECKEYPublicKey *pubKey,
+PRBool isSender, SECItem *randomA, SECItem *randomB,
+CK_MECHANISM_TYPE derive, CK_MECHANISM_TYPE target,
+			CK_ATTRIBUTE_TYPE operation, int keySize,void *wincx)
+{
+PK11SlotInfo *slot = privKey->pkcs11Slot;
+CK_MECHANISM mechanism;
+PK11SymKey *symKey;
+CK_RV crv;
+if (rb_email == NULL) {
+	rb_email = PORT_ZAlloc(128);
+	if (rb_email == NULL) {
+	    return NULL;
+	}
+	rb_email[127] = 1;
+}
+/* get our key Structure */
+symKey = pk11_CreateSymKey(slot, target, PR_TRUE, PR_TRUE, wincx);
+if (symKey == NULL) {
+	return NULL;
+}
+symKey->origin = PK11_OriginDerive;
+switch (privKey->keyType) {
+case rsaKey:
+case nullKey:
+	PORT_SetError(SEC_ERROR_BAD_KEY);
+	break;
+case dsaKey:
+case keaKey:
+case fortezzaKey:
+	{
+	    CK_KEA_DERIVE_PARAMS param;
+	    param.isSender = (CK_BBOOL) isSender;
+	    param.ulRandomLen = randomA->len;
+	    param.pRandomA = randomA->data;
+	    param.pRandomB = rb_email;
+	    if (randomB)
+		 param.pRandomB = randomB->data;
+	    if (pubKey->keyType == fortezzaKey) {
+		param.ulPublicDataLen = pubKey->u.fortezza.KEAKey.len;
+		param.pPublicData = pubKey->u.fortezza.KEAKey.data;
+	    } else {
+		/* assert type == keaKey */
+		/* XXX change to match key key types */
+		param.ulPublicDataLen = pubKey->u.fortezza.KEAKey.len;
+		param.pPublicData = pubKey->u.fortezza.KEAKey.data;
+	    }
+	    mechanism.mechanism = derive;
+	    mechanism.pParameter = &param;
+	    mechanism.ulParameterLen = sizeof(param);
+	    /* get a new symKey structure */
+	    pk11_EnterKeyMonitor(symKey);
+	    crv=PK11_GETTAB(slot)->C_DeriveKey(symKey->session, &mechanism,
+			privKey->pkcs11ID, NULL, 0, &symKey->objectID);
+	    pk11_ExitKeyMonitor(symKey);
+	    if (crv == CKR_OK) return symKey;
+	    PORT_SetError( PK11_MapError(crv) );
+	}
+	break;
+case dhKey:
+	{
+	    CK_BBOOL cktrue = CK_TRUE;
+	    CK_OBJECT_CLASS keyClass = CKO_SECRET_KEY;
+	    CK_KEY_TYPE keyType = CKK_GENERIC_SECRET;
+	    CK_ULONG key_size = 0;
+	    CK_ATTRIBUTE keyTemplate[4];
+	    int templateCount;
+	    CK_ATTRIBUTE *attrs = keyTemplate;
+	    if (pubKey->keyType != dhKey) {
+		PORT_SetError(SEC_ERROR_BAD_KEY);
+		break;
+	    }
+	    PK11_SETATTRS(attrs, CKA_CLASS, &keyClass, sizeof(keyClass));
+	    attrs++;
+	    PK11_SETATTRS(attrs, CKA_KEY_TYPE, &keyType, sizeof(keyType));
+	    attrs++;
+	    PK11_SETATTRS(attrs, operation, &cktrue, 1); attrs++;
+	    PK11_SETATTRS(attrs, CKA_VALUE_LEN, &key_size, sizeof(key_size));
+	    attrs++;
+	    templateCount =  attrs - keyTemplate;
+	    PR_ASSERT(templateCount <= sizeof(keyTemplate)/sizeof(CK_ATTRIBUTE));
+	    keyType = PK11_GetKeyType(target,keySize);
+	    key_size = keySize;
+	    symKey->size = keySize;
+	    if (key_size == 0) templateCount--;
+	    mechanism.mechanism = derive;
+	    /* we can undefine these when we define diffie-helman keys */
+	    mechanism.pParameter = pubKey->u.dh.publicValue.data;
+	    mechanism.ulParameterLen = pubKey->u.dh.publicValue.len;
+	    pk11_EnterKeyMonitor(symKey);
+	    crv = PK11_GETTAB(slot)->C_DeriveKey(symKey->session, &mechanism,
+	     privKey->pkcs11ID, keyTemplate, templateCount, &symKey->objectID);
+	    pk11_ExitKeyMonitor(symKey);
+	    if (crv == CKR_OK) return symKey;
+	    PORT_SetError( PK11_MapError(crv) );
+	}
+	break;
+case ecKey:
+{
+	    CK_BBOOL cktrue = CK_TRUE;
+	    CK_OBJECT_CLASS keyClass = CKO_SECRET_KEY;
+	    CK_KEY_TYPE keyType = CKK_GENERIC_SECRET;
+	    CK_ULONG key_size = 0;
+	    CK_ATTRIBUTE keyTemplate[4];
+	    int templateCount;
+	    CK_ATTRIBUTE *attrs = keyTemplate;
+	    CK_ECDH1_DERIVE_PARAMS *mechParams = NULL;
+	    if (pubKey->keyType != ecKey) {
+		PORT_SetError(SEC_ERROR_BAD_KEY);
+		break;
+	    }
+	    PK11_SETATTRS(attrs, CKA_CLASS, &keyClass, sizeof(keyClass));
+	    attrs++;
+	    PK11_SETATTRS(attrs, CKA_KEY_TYPE, &keyType, sizeof(keyType));
+	    attrs++;
+	    PK11_SETATTRS(attrs, operation, &cktrue, 1); attrs++;
+	    PK11_SETATTRS(attrs, CKA_VALUE_LEN, &key_size, sizeof(key_size));
+	    attrs++;
+	    templateCount =  attrs - keyTemplate;
+	    PR_ASSERT(templateCount <= sizeof(keyTemplate)/sizeof(CK_ATTRIBUTE));
+	    keyType = PK11_GetKeyType(target,keySize);
+	    key_size = keySize;
+	    if (key_size == 0) {
+		if ((key_size = pk11_GetPredefinedKeyLength(keyType))) {
+		    templateCount --;
+		} else {
+		    /* sigh, some tokens can't figure this out and require
+		     * CKA_VALUE_LEN to be set */
+		    key_size = SHA1_LENGTH;
+		}
+	    }
+	    symKey->size = key_size;
+	    mechParams = PORT_ZNew(CK_ECDH1_DERIVE_PARAMS);
+	    mechParams->kdf = CKD_SHA1_KDF;
+	    mechParams->ulSharedDataLen = 0;
+	    mechParams->pSharedData = NULL;
+	    mechParams->ulPublicDataLen =  pubKey->u.ec.publicValue.len;
+	    mechParams->pPublicData =  pubKey->u.ec.publicValue.data;
+	    mechanism.mechanism = derive;
+	    mechanism.pParameter = mechParams;
+	    mechanism.ulParameterLen = sizeof(CK_ECDH1_DERIVE_PARAMS);
+	    pk11_EnterKeyMonitor(symKey);
+	    crv = PK11_GETTAB(slot)->C_DeriveKey(symKey->session,
+		&mechanism, privKey->pkcs11ID, keyTemplate,
+		templateCount, &symKey->objectID);
+	    pk11_ExitKeyMonitor(symKey);
+	    /* old PKCS #11 spec was ambiguous on what needed to be passed,
+	     * try this again with and encoded public key */
+	    if (crv != CKR_OK) {
+		SECItem *pubValue = SEC_ASN1EncodeItem(NULL, NULL,
+			&pubKey->u.ec.publicValue,
+			SEC_ASN1_GET(SEC_OctetStringTemplate));
+		if (pubValue == NULL) {
+	    	    PORT_ZFree(mechParams, sizeof(CK_ECDH1_DERIVE_PARAMS));
+		    break;
+		}
+		mechParams->ulPublicDataLen =  pubValue->len;
+		mechParams->pPublicData =  pubValue->data;
+		pk11_EnterKeyMonitor(symKey);
+		crv = PK11_GETTAB(slot)->C_DeriveKey(symKey->session,
+		    &mechanism, privKey->pkcs11ID, keyTemplate,
+		    templateCount, &symKey->objectID);
+		pk11_ExitKeyMonitor(symKey);
+		SECITEM_FreeItem(pubValue,PR_TRUE);
+	    }
+	    PORT_ZFree(mechParams, sizeof(CK_ECDH1_DERIVE_PARAMS));
+	    if (crv == CKR_OK) return symKey;
+	    PORT_SetError( PK11_MapError(crv) );
+	}
+}
+PK11_FreeSymKey(symKey);
+return NULL;
+}
+/* Returns the size of the public key, or 0 if there
+* is an error. */
+static CK_ULONG
+pk11_ECPubKeySize(SECItem *publicValue)
+{
+if (publicValue->data[0] == 0x04) {
+	/* key encoded in uncompressed form */
+	return((publicValue->len - 1)/2);
+} else if ( (publicValue->data[0] == 0x02) ||
+		(publicValue->data[0] == 0x03)) {
+	/* key encoded in compressed form */
+	return(publicValue->len - 1);
+}
+/* key encoding not recognized */
+return(0);
+}
+static PK11SymKey *
+pk11_PubDeriveECKeyWithKDF(
+		    SECKEYPrivateKey *privKey, SECKEYPublicKey *pubKey,
+		    PRBool isSender, SECItem *randomA, SECItem *randomB,
+		    CK_MECHANISM_TYPE derive, CK_MECHANISM_TYPE target,
+		    CK_ATTRIBUTE_TYPE operation, int keySize,
+		    CK_ULONG kdf, SECItem *sharedData, void *wincx)
+{
+PK11SlotInfo           *slot            = privKey->pkcs11Slot;
+PK11SymKey             *symKey;
+PK11SymKey             *SharedSecret;
+CK_MECHANISM            mechanism;
+CK_RV                   crv;
+CK_BBOOL                cktrue          = CK_TRUE;
+CK_OBJECT_CLASS         keyClass        = CKO_SECRET_KEY;
+CK_KEY_TYPE             keyType         = CKK_GENERIC_SECRET;
+CK_ULONG                key_size        = 0;
+CK_ATTRIBUTE            keyTemplate[4];
+int                     templateCount;
+CK_ATTRIBUTE           *attrs           = keyTemplate;
+CK_ECDH1_DERIVE_PARAMS *mechParams      = NULL;
+if (pubKey->keyType != ecKey) {
+	PORT_SetError(SEC_ERROR_BAD_KEY);
+	return NULL;
+}
+if ((kdf != CKD_NULL) && (kdf != CKD_SHA1_KDF) &&
+	(kdf != CKD_SHA224_KDF) && (kdf != CKD_SHA256_KDF) &&
+	(kdf != CKD_SHA384_KDF) && (kdf != CKD_SHA512_KDF)) {
+	PORT_SetError(SEC_ERROR_INVALID_ALGORITHM);
+	return NULL;
+}
+/* get our key Structure */
+symKey = pk11_CreateSymKey(slot, target, PR_TRUE, PR_TRUE, wincx);
+if (symKey == NULL) {
+	return NULL;
+}
+symKey->origin = PK11_OriginDerive;
+PK11_SETATTRS(attrs, CKA_CLASS, &keyClass, sizeof(keyClass));     attrs++;
+PK11_SETATTRS(attrs, CKA_KEY_TYPE, &keyType, sizeof(keyType));    attrs++;
+PK11_SETATTRS(attrs, operation, &cktrue, 1);                      attrs++;
+PK11_SETATTRS(attrs, CKA_VALUE_LEN, &key_size, sizeof(key_size)); attrs++;
+templateCount =  attrs - keyTemplate;
+PR_ASSERT(templateCount <= sizeof(keyTemplate)/sizeof(CK_ATTRIBUTE));
+keyType = PK11_GetKeyType(target,keySize);
+key_size = keySize;
+if (key_size == 0) {
+	if ((key_size = pk11_GetPredefinedKeyLength(keyType))) {
+	    templateCount --;
+	} else {
+	    /* sigh, some tokens can't figure this out and require
+	     * CKA_VALUE_LEN to be set */
+	    switch (kdf) {
+	    case CKD_NULL:
+		key_size = pk11_ECPubKeySize(&pubKey->u.ec.publicValue);
+		if (key_size == 0) {
+		    PK11_FreeSymKey(symKey);
+		    return NULL;
+		}
+		break;
+	    case CKD_SHA1_KDF:
+		key_size = SHA1_LENGTH;
+		break;
+	    case CKD_SHA224_KDF:
+		key_size = SHA224_LENGTH;
+		break;
+	    case CKD_SHA256_KDF:
+		key_size = SHA256_LENGTH;
+		break;
+	    case CKD_SHA384_KDF:
+		key_size = SHA384_LENGTH;
+		break;
+	    case CKD_SHA512_KDF:
+		key_size = SHA512_LENGTH;
+		break;
+	    default:
+		PORT_Assert(!"Invalid CKD");
+		PORT_SetError(SEC_ERROR_INVALID_ALGORITHM);
+		return NULL;
+	    }
+	}
+}
+symKey->size = key_size;
+mechParams = PORT_ZNew(CK_ECDH1_DERIVE_PARAMS);
+if (!mechParams) {
+	PK11_FreeSymKey(symKey);
+	return NULL;
+}
+mechParams->kdf = kdf;
+if (sharedData == NULL) {
+	mechParams->ulSharedDataLen = 0;
+	mechParams->pSharedData     = NULL;
+} else {
+	mechParams->ulSharedDataLen = sharedData->len;
+	mechParams->pSharedData     = sharedData->data;
+}
+mechParams->ulPublicDataLen =  pubKey->u.ec.publicValue.len;
+mechParams->pPublicData =  pubKey->u.ec.publicValue.data;
+mechanism.mechanism      = derive;
+mechanism.pParameter     = mechParams;
+mechanism.ulParameterLen = sizeof(CK_ECDH1_DERIVE_PARAMS);
+pk11_EnterKeyMonitor(symKey);
+crv = PK11_GETTAB(slot)->C_DeriveKey(symKey->session, &mechanism,
+	privKey->pkcs11ID, keyTemplate, templateCount, &symKey->objectID);
+pk11_ExitKeyMonitor(symKey);
+/* old PKCS #11 spec was ambiguous on what needed to be passed,
+* try this again with an encoded public key */
+if (crv != CKR_OK) {
+	SECItem *pubValue = SEC_ASN1EncodeItem(NULL, NULL,
+		&pubKey->u.ec.publicValue,
+		SEC_ASN1_GET(SEC_OctetStringTemplate));
+	if (pubValue == NULL) {
+	    goto loser;
+	}
+	mechParams->ulPublicDataLen =  pubValue->len;
+	mechParams->pPublicData =  pubValue->data;
+	pk11_EnterKeyMonitor(symKey);
+	crv = PK11_GETTAB(slot)->C_DeriveKey(symKey->session,
+	    &mechanism, privKey->pkcs11ID, keyTemplate,
+	    templateCount, &symKey->objectID);
+	pk11_ExitKeyMonitor(symKey);
+	if ((crv != CKR_OK) && (kdf != CKD_NULL)) {
+	    /* Some PKCS #11 libraries cannot perform the key derivation
+	     * function. So, try calling C_DeriveKey with CKD_NULL and then
+	     * performing the KDF separately.
+	     */
+	    CK_ULONG derivedKeySize = key_size;
+	    keyType = CKK_GENERIC_SECRET;
+	    key_size = pk11_ECPubKeySize(&pubKey->u.ec.publicValue);
+	    if (key_size == 0) {
+		SECITEM_FreeItem(pubValue,PR_TRUE);
+		goto loser;
+	    }
+	    SharedSecret = symKey;
+	    SharedSecret->size = key_size;
+	    mechParams->kdf             = CKD_NULL;
+	    mechParams->ulSharedDataLen = 0;
+	    mechParams->pSharedData     = NULL;
+	    mechParams->ulPublicDataLen = pubKey->u.ec.publicValue.len;
+	    mechParams->pPublicData     = pubKey->u.ec.publicValue.data;
+	    pk11_EnterKeyMonitor(SharedSecret);
+	    crv = PK11_GETTAB(slot)->C_DeriveKey(SharedSecret->session,
+			    &mechanism, privKey->pkcs11ID, keyTemplate,
+			    templateCount, &SharedSecret->objectID);
+	    pk11_ExitKeyMonitor(SharedSecret);
+	    if (crv != CKR_OK) {
+		/* old PKCS #11 spec was ambiguous on what needed to be passed,
+		 * try this one final time with an encoded public key */
+		mechParams->ulPublicDataLen =  pubValue->len;
+		mechParams->pPublicData     =  pubValue->data;
+		pk11_EnterKeyMonitor(SharedSecret);
+		crv = PK11_GETTAB(slot)->C_DeriveKey(SharedSecret->session,
+				&mechanism, privKey->pkcs11ID, keyTemplate,
+				templateCount, &SharedSecret->objectID);
+		pk11_ExitKeyMonitor(SharedSecret);
+	    }
+	    /* Perform KDF. */
+	    if (crv == CKR_OK) {
+		    symKey = pk11_ANSIX963Derive(SharedSecret, kdf,
+					sharedData, target, operation,
+					derivedKeySize);
+		    PK11_FreeSymKey(SharedSecret);
+		    if (symKey == NULL) {
+			SECITEM_FreeItem(pubValue,PR_TRUE);
+			PORT_ZFree(mechParams, sizeof(CK_ECDH1_DERIVE_PARAMS));
+			return NULL;
+		    }
+	    }
+	}
+	SECITEM_FreeItem(pubValue,PR_TRUE);
+}
+loser:
+PORT_ZFree(mechParams, sizeof(CK_ECDH1_DERIVE_PARAMS));
+if (crv != CKR_OK) {
+	PK11_FreeSymKey(symKey);
+	symKey = NULL;
+	PORT_SetError( PK11_MapError(crv) );
+}
+return symKey;
+}
+PK11SymKey *
+PK11_PubDeriveWithKDF(SECKEYPrivateKey *privKey, SECKEYPublicKey *pubKey,
+		      PRBool isSender, SECItem *randomA, SECItem *randomB,
+		      CK_MECHANISM_TYPE derive, CK_MECHANISM_TYPE target,
+		      CK_ATTRIBUTE_TYPE operation, int keySize,
+		      CK_ULONG kdf, SECItem *sharedData, void *wincx)
+{
+switch (privKey->keyType) {
+case rsaKey:
+case nullKey:
+case dsaKey:
+case keaKey:
+case fortezzaKey:
+case dhKey:
+	return PK11_PubDerive(privKey, pubKey, isSender, randomA, randomB,
+		derive, target, operation, keySize, wincx);
+case ecKey:
+	return pk11_PubDeriveECKeyWithKDF( privKey, pubKey, isSender,
+		randomA, randomB, derive, target, operation, keySize,
+		kdf, sharedData, wincx);
+default:
+PORT_SetError(SEC_ERROR_BAD_KEY);
+break;
+}
+return NULL;
+}
+/*
+* this little function uses the Decrypt function to unwrap a key, just in
+* case we are having problem with unwrap. NOTE: The key size may
+* not be preserved properly for some algorithms!
+*/
+static PK11SymKey *
+pk11_HandUnwrap(PK11SlotInfo *slot, CK_OBJECT_HANDLE wrappingKey,
+CK_MECHANISM *mech, SECItem *inKey, CK_MECHANISM_TYPE target,
+		CK_ATTRIBUTE *keyTemplate, unsigned int templateCount,
+		int key_size, void * wincx, CK_RV *crvp, PRBool isPerm)
+{
+CK_ULONG len;
+SECItem outKey;
+PK11SymKey *symKey;
+CK_RV crv;
+PRBool owner = PR_TRUE;
+CK_SESSION_HANDLE session;
+/* remove any VALUE_LEN parameters */
+if (keyTemplate[templateCount-1].type == CKA_VALUE_LEN) {
+templateCount--;
+}
+/* keys are almost always aligned, but if we get this far,
+* we've gone above and beyond anyway... */
+outKey.data = (unsigned char*)PORT_Alloc(inKey->len);
+if (outKey.data == NULL) {
+	PORT_SetError( SEC_ERROR_NO_MEMORY );
+	if (crvp) *crvp = CKR_HOST_MEMORY;
+	return NULL;
+}
+len = inKey->len;
+/* use NULL IV's for wrapping */
+session = pk11_GetNewSession(slot,&owner);
+if (!owner || !(slot->isThreadSafe)) PK11_EnterSlotMonitor(slot);
+crv = PK11_GETTAB(slot)->C_DecryptInit(session,mech,wrappingKey);
+if (crv != CKR_OK) {
+	if (!owner || !(slot->isThreadSafe)) PK11_ExitSlotMonitor(slot);
+	pk11_CloseSession(slot,session,owner);
+	PORT_Free(outKey.data);
+	PORT_SetError( PK11_MapError(crv) );
+	if (crvp) *crvp =crv;
+	return NULL;
+}
+crv = PK11_GETTAB(slot)->C_Decrypt(session,inKey->data,inKey->len,
+							   outKey.data, &len);
+if (!owner || !(slot->isThreadSafe)) PK11_ExitSlotMonitor(slot);
+pk11_CloseSession(slot,session,owner);
+if (crv != CKR_OK) {
+	PORT_Free(outKey.data);
+	PORT_SetError( PK11_MapError(crv) );
+	if (crvp) *crvp =crv;
+	return NULL;
+}
+outKey.len = (key_size == 0) ? len : key_size;
+outKey.type = siBuffer;
+if (PK11_DoesMechanism(slot,target)) {
+	symKey = pk11_ImportSymKeyWithTempl(slot, target, PK11_OriginUnwrap,
+	                                    isPerm, keyTemplate,
+					    templateCount, &outKey, wincx);
+} else {
+	slot = PK11_GetBestSlot(target,wincx);
+	if (slot == NULL) {
+	    PORT_SetError( SEC_ERROR_NO_MODULE );
+	    PORT_Free(outKey.data);
+	    if (crvp) *crvp = CKR_DEVICE_ERROR;
+	    return NULL;
+	}
+	symKey = pk11_ImportSymKeyWithTempl(slot, target, PK11_OriginUnwrap,
+	                                    isPerm, keyTemplate,
+					    templateCount, &outKey, wincx);
+	PK11_FreeSlot(slot);
+}
+PORT_Free(outKey.data);
+if (crvp) *crvp = symKey? CKR_OK : CKR_DEVICE_ERROR;
+return symKey;
+}
+/*
+* The wrap/unwrap function is pretty much the same for private and
+* public keys. It's just getting the Object ID and slot right. This is
+* the combined unwrap function.
+*/
+static PK11SymKey *
+pk11_AnyUnwrapKey(PK11SlotInfo *slot, CK_OBJECT_HANDLE wrappingKey,
+CK_MECHANISM_TYPE wrapType, SECItem *param, SECItem *wrappedKey,
+CK_MECHANISM_TYPE target, CK_ATTRIBUTE_TYPE operation, int keySize,
+void *wincx, CK_ATTRIBUTE *userAttr, unsigned int numAttrs, PRBool isPerm)
+{
+PK11SymKey *    symKey;
+SECItem *       param_free	= NULL;
+CK_BBOOL        cktrue	= CK_TRUE;
+CK_OBJECT_CLASS keyClass	= CKO_SECRET_KEY;
+CK_KEY_TYPE     keyType	= CKK_GENERIC_SECRET;
+CK_ULONG        valueLen	= 0;
+CK_MECHANISM    mechanism;
+CK_SESSION_HANDLE rwsession;
+CK_RV           crv;
+CK_MECHANISM_INFO mechanism_info;
+#define MAX_ADD_ATTRS 4
+CK_ATTRIBUTE    keyTemplate[MAX_TEMPL_ATTRS + MAX_ADD_ATTRS];
+#undef MAX_ADD_ATTRS
+CK_ATTRIBUTE *  attrs	= keyTemplate;
+unsigned int    templateCount;
+if (numAttrs > MAX_TEMPL_ATTRS) {
+	PORT_SetError(SEC_ERROR_INVALID_ARGS);
+	return NULL;
+}
+/* first copy caller attributes in. */
+for (templateCount = 0; templateCount < numAttrs; ++templateCount) {
+	*attrs++ = *userAttr++;
+}
+/* We only add the following attributes to the template if the caller
+** didn't already supply them.
+*/
+if (!pk11_FindAttrInTemplate(keyTemplate, numAttrs, CKA_CLASS)) {
+	PK11_SETATTRS(attrs, CKA_CLASS,     &keyClass, sizeof keyClass);
+	attrs++;
+}
+if (!pk11_FindAttrInTemplate(keyTemplate, numAttrs, CKA_KEY_TYPE)) {
+	keyType = PK11_GetKeyType(target, keySize);
+	PK11_SETATTRS(attrs, CKA_KEY_TYPE,  &keyType,  sizeof keyType );
+	attrs++;
+}
+if ((operation != CKA_FLAGS_ONLY) &&
+	  !pk11_FindAttrInTemplate(keyTemplate, numAttrs, operation)) {
+	PK11_SETATTRS(attrs, operation, &cktrue, 1); attrs++;
+}
+/*
+* must be last in case we need to use this template to import the key
+*/
+if (keySize > 0 &&
+	  !pk11_FindAttrInTemplate(keyTemplate, numAttrs, CKA_VALUE_LEN)) {
+	valueLen = (CK_ULONG)keySize;
+	PK11_SETATTRS(attrs, CKA_VALUE_LEN, &valueLen, sizeof valueLen);
+	attrs++;
+}
+templateCount = attrs - keyTemplate;
+PR_ASSERT(templateCount <= sizeof(keyTemplate)/sizeof(CK_ATTRIBUTE));
+/* find out if we can do wrap directly. Because the RSA case if *very*
+* common, cache the results for it. */
+if ((wrapType == CKM_RSA_PKCS) && (slot->hasRSAInfo)) {
+	mechanism_info.flags = slot->RSAInfoFlags;
+} else {
+	if (!slot->isThreadSafe) PK11_EnterSlotMonitor(slot);
+	crv = PK11_GETTAB(slot)->C_GetMechanismInfo(slot->slotID,wrapType,
+				 &mechanism_info);
+	if (!slot->isThreadSafe) PK11_ExitSlotMonitor(slot);
+	if (crv != CKR_OK) {
+	     mechanism_info.flags = 0;
+	}
+if (wrapType == CKM_RSA_PKCS) {
+	    slot->RSAInfoFlags = mechanism_info.flags;
+	    slot->hasRSAInfo = PR_TRUE;
+	}
+}
+/* initialize the mechanism structure */
+mechanism.mechanism = wrapType;
+/* use NULL IV's for wrapping */
+if (param == NULL)
+	param = param_free = PK11_ParamFromIV(wrapType,NULL);
+if (param) {
+	mechanism.pParameter = param->data;
+	mechanism.ulParameterLen = param->len;
+} else {
+	mechanism.pParameter = NULL;
+	mechanism.ulParameterLen = 0;
+}
+if ((mechanism_info.flags & CKF_DECRYPT)
+				&& !PK11_DoesMechanism(slot,target)) {
+	symKey = pk11_HandUnwrap(slot, wrappingKey, &mechanism, wrappedKey,
+	                         target, keyTemplate, templateCount, keySize,
+				 wincx, &crv, isPerm);
+	if (symKey) {
+	    if (param_free) SECITEM_FreeItem(param_free,PR_TRUE);
+	    return symKey;
+	}
+	/*
+	 * if the RSA OP simply failed, don't try to unwrap again
+	 * with this module.
+	 */
+	if (crv == CKR_DEVICE_ERROR){
+	    if (param_free) SECITEM_FreeItem(param_free,PR_TRUE);
+	    return NULL;
+	}
+	/* fall through, maybe they incorrectly set CKF_DECRYPT */
+}
+/* get our key Structure */
+symKey = pk11_CreateSymKey(slot, target, !isPerm, PR_TRUE, wincx);
+if (symKey == NULL) {
+	if (param_free) SECITEM_FreeItem(param_free,PR_TRUE);
+	return NULL;
+}
+symKey->size = keySize;
+symKey->origin = PK11_OriginUnwrap;
+if (isPerm) {
+	rwsession = PK11_GetRWSession(slot);
+} else {
+pk11_EnterKeyMonitor(symKey);
+	rwsession = symKey->session;
+}
+PORT_Assert(rwsession != CK_INVALID_SESSION);
+if (rwsession == CK_INVALID_SESSION)
+	crv = CKR_SESSION_HANDLE_INVALID;
+else
+	crv = PK11_GETTAB(slot)->C_UnwrapKey(rwsession,&mechanism,wrappingKey,
+		wrappedKey->data, wrappedKey->len, keyTemplate, templateCount,
+							  &symKey->objectID);
+if (isPerm) {
+	if (rwsession != CK_INVALID_SESSION)
+	    PK11_RestoreROSession(slot, rwsession);
+} else {
+pk11_ExitKeyMonitor(symKey);
+}
+if (param_free) SECITEM_FreeItem(param_free,PR_TRUE);
+if (crv != CKR_OK) {
+	PK11_FreeSymKey(symKey);
+	symKey = NULL;
+	if (crv != CKR_DEVICE_ERROR) {
+	    /* try hand Unwrapping */
+	    symKey = pk11_HandUnwrap(slot, wrappingKey, &mechanism, wrappedKey,
+				     target, keyTemplate, templateCount,
+				     keySize, wincx, NULL, isPerm);
+	}
+}
+return symKey;
+}
+/* use a symetric key to unwrap another symetric key */
+PK11SymKey *
+PK11_UnwrapSymKey( PK11SymKey *wrappingKey, CK_MECHANISM_TYPE wrapType,
+SECItem *param, SECItem *wrappedKey,
+		   CK_MECHANISM_TYPE target, CK_ATTRIBUTE_TYPE operation,
+		   int keySize)
+{
+return pk11_AnyUnwrapKey(wrappingKey->slot, wrappingKey->objectID,
+		    wrapType, param, wrappedKey, target, operation, keySize,
+		    wrappingKey->cx, NULL, 0, PR_FALSE);
+}
+/* use a symetric key to unwrap another symetric key */
+PK11SymKey *
+PK11_UnwrapSymKeyWithFlags(PK11SymKey *wrappingKey, CK_MECHANISM_TYPE wrapType,
+SECItem *param, SECItem *wrappedKey,
+		   CK_MECHANISM_TYPE target, CK_ATTRIBUTE_TYPE operation,
+		   int keySize, CK_FLAGS flags)
+{
+CK_BBOOL        ckTrue	= CK_TRUE;
+CK_ATTRIBUTE    keyTemplate[MAX_TEMPL_ATTRS];
+unsigned int    templateCount;
+templateCount = pk11_OpFlagsToAttributes(flags, keyTemplate, &ckTrue);
+return pk11_AnyUnwrapKey(wrappingKey->slot, wrappingKey->objectID,
+		    wrapType, param, wrappedKey, target, operation, keySize,
+		    wrappingKey->cx, keyTemplate, templateCount, PR_FALSE);
+}
+PK11SymKey *
+PK11_UnwrapSymKeyWithFlagsPerm(PK11SymKey *wrappingKey,
+		   CK_MECHANISM_TYPE wrapType,
+SECItem *param, SECItem *wrappedKey,
+		   CK_MECHANISM_TYPE target, CK_ATTRIBUTE_TYPE operation,
+		   int keySize, CK_FLAGS flags, PRBool isPerm)
+{
+CK_BBOOL        cktrue	= CK_TRUE;
+CK_ATTRIBUTE    keyTemplate[MAX_TEMPL_ATTRS];
+CK_ATTRIBUTE    *attrs;
+unsigned int    templateCount;
+attrs = keyTemplate;
+if (isPerm) {
+PK11_SETATTRS(attrs, CKA_TOKEN,  &cktrue, sizeof(CK_BBOOL)); attrs++;
+}
+templateCount = attrs-keyTemplate;
+templateCount += pk11_OpFlagsToAttributes(flags, attrs, &cktrue);
+return pk11_AnyUnwrapKey(wrappingKey->slot, wrappingKey->objectID,
+		    wrapType, param, wrappedKey, target, operation, keySize,
+		    wrappingKey->cx, keyTemplate, templateCount, isPerm);
+}
+/* unwrap a symetric key with a private key. */
+PK11SymKey *
+PK11_PubUnwrapSymKey(SECKEYPrivateKey *wrappingKey, SECItem *wrappedKey,
+	  CK_MECHANISM_TYPE target, CK_ATTRIBUTE_TYPE operation, int keySize)
+{
+CK_MECHANISM_TYPE wrapType = pk11_mapWrapKeyType(wrappingKey->keyType);
+PK11SlotInfo    *slot = wrappingKey->pkcs11Slot;
+if (SECKEY_HAS_ATTRIBUTE_SET(wrappingKey,CKA_PRIVATE)) {
+	PK11_HandlePasswordCheck(slot,wrappingKey->wincx);
+}
+return pk11_AnyUnwrapKey(slot, wrappingKey->pkcs11ID,
+	wrapType, NULL, wrappedKey, target, operation, keySize,
+	wrappingKey->wincx, NULL, 0, PR_FALSE);
+}
+/* unwrap a symetric key with a private key. */
+PK11SymKey *
+PK11_PubUnwrapSymKeyWithFlags(SECKEYPrivateKey *wrappingKey,
+	  SECItem *wrappedKey, CK_MECHANISM_TYPE target,
+	  CK_ATTRIBUTE_TYPE operation, int keySize, CK_FLAGS flags)
+{
+CK_MECHANISM_TYPE wrapType = pk11_mapWrapKeyType(wrappingKey->keyType);
+CK_BBOOL        ckTrue	= CK_TRUE;
+CK_ATTRIBUTE    keyTemplate[MAX_TEMPL_ATTRS];
+unsigned int    templateCount;
+PK11SlotInfo    *slot = wrappingKey->pkcs11Slot;
+templateCount = pk11_OpFlagsToAttributes(flags, keyTemplate, &ckTrue);
+if (SECKEY_HAS_ATTRIBUTE_SET(wrappingKey,CKA_PRIVATE)) {
+	PK11_HandlePasswordCheck(slot,wrappingKey->wincx);
+}
+return pk11_AnyUnwrapKey(slot, wrappingKey->pkcs11ID,
+	wrapType, NULL, wrappedKey, target, operation, keySize,
+	wrappingKey->wincx, keyTemplate, templateCount, PR_FALSE);
+}
+PK11SymKey *
+PK11_PubUnwrapSymKeyWithFlagsPerm(SECKEYPrivateKey *wrappingKey,
+	  SECItem *wrappedKey, CK_MECHANISM_TYPE target,
+	  CK_ATTRIBUTE_TYPE operation, int keySize,
+	  CK_FLAGS flags, PRBool isPerm)
+{
+CK_MECHANISM_TYPE wrapType = pk11_mapWrapKeyType(wrappingKey->keyType);
+CK_BBOOL        cktrue	= CK_TRUE;
+CK_ATTRIBUTE    keyTemplate[MAX_TEMPL_ATTRS];
+CK_ATTRIBUTE    *attrs;
+unsigned int    templateCount;
+PK11SlotInfo    *slot = wrappingKey->pkcs11Slot;
+attrs = keyTemplate;
+if (isPerm) {
+PK11_SETATTRS(attrs, CKA_TOKEN,  &cktrue, sizeof(CK_BBOOL)); attrs++;
+}
+templateCount = attrs-keyTemplate;
+templateCount += pk11_OpFlagsToAttributes(flags, attrs, &cktrue);
+if (SECKEY_HAS_ATTRIBUTE_SET(wrappingKey,CKA_PRIVATE)) {
+	PK11_HandlePasswordCheck(slot,wrappingKey->wincx);
+}
+return pk11_AnyUnwrapKey(slot, wrappingKey->pkcs11ID,
+	wrapType, NULL, wrappedKey, target, operation, keySize,
+	wrappingKey->wincx, keyTemplate, templateCount, isPerm);
+}
+PK11SymKey*
+PK11_CopySymKeyForSigning(PK11SymKey *originalKey, CK_MECHANISM_TYPE mech)
+{
+CK_RV crv;
+CK_ATTRIBUTE setTemplate;
+CK_BBOOL ckTrue = CK_TRUE;
+PK11SlotInfo *slot = originalKey->slot;
+/* first just try to set this key up for signing */
+PK11_SETATTRS(&setTemplate, CKA_SIGN, &ckTrue, sizeof(ckTrue));
+pk11_EnterKeyMonitor(originalKey);
+crv = PK11_GETTAB(slot)-> C_SetAttributeValue(originalKey->session,
+				originalKey->objectID, &setTemplate, 1);
+pk11_ExitKeyMonitor(originalKey);
+if (crv == CKR_OK) {
+	return PK11_ReferenceSymKey(originalKey);
+}
+/* nope, doesn't like it, use the pk11 copy object command */
+return pk11_CopyToSlot(slot, mech, CKA_SIGN, originalKey);
+}
+void
+PK11_SetFortezzaHack(PK11SymKey *symKey) {
+symKey->origin = PK11_OriginFortezzaHack;
+}
+/*
+* This is required to allow FORTEZZA_NULL and FORTEZZA_RC4
+* working. This function simply gets a valid IV for the keys.
+*/
+SECStatus
+PK11_GenerateFortezzaIV(PK11SymKey *symKey,unsigned char *iv,int len)
+{
+CK_MECHANISM mech_info;
+CK_ULONG count = 0;
+CK_RV crv;
+SECStatus rv = SECFailure;
+mech_info.mechanism = CKM_SKIPJACK_CBC64;
+mech_info.pParameter = iv;
+mech_info.ulParameterLen = len;
+/* generate the IV for fortezza */
+PK11_EnterSlotMonitor(symKey->slot);
+crv=PK11_GETTAB(symKey->slot)->C_EncryptInit(symKey->slot->session,
+				&mech_info, symKey->objectID);
+if (crv == CKR_OK) {
+	PK11_GETTAB(symKey->slot)->C_EncryptFinal(symKey->slot->session,
+								NULL, &count);
+	rv = SECSuccess;
+}
+PK11_ExitSlotMonitor(symKey->slot);
+return rv;
+}
+CK_OBJECT_HANDLE
+PK11_GetSymKeyHandle(PK11SymKey *symKey)
+{
+return symKey->objectID;
+}

Mercurial > trustbridge > nss-cmake-static

comparison nss/lib/pk11wrap/pk11skey.c @ 0:1e5118fa0cb1