The Tor Browser: security/nss/lib/ckfw/nssmkey/mobject.c@b8a032363ba2 (annotated)

security/nss/lib/ckfw/nssmkey/mobject.c@b8a032363ba2 (annotated)

security/nss/lib/ckfw/nssmkey/mobject.c

Thu, 22 Jan 2015 13:21:57 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Thu, 22 Jan 2015 13:21:57 +0100
branch: TOR_BUG_9701
changeset 15: b8a032363ba2
permissions: -rw-r--r--

Incorporate requested changes from Mozilla in review:
https://bugzilla.mozilla.org/show_bug.cgi?id=1123480#c6

 /* 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/. */
 #include "ckmk.h"
 #include "nssbase.h"
 #include "secdert.h" /* for DER_INTEGER */
 #include "string.h"
 /* asn1 encoder (to build pkcs#8 blobs) */
 #include <seccomon.h>
 #include <secitem.h>
 #include <blapit.h>
 #include <secoid.h>
 #include <secasn1.h>
 /* for importing the keys */
 #include <CoreFoundation/CoreFoundation.h>
 #include <security/SecImportExport.h>
 /*
  * nssmkey/mobject.c
  *
  * This file implements the NSSCKMDObject object for the
  * "nssmkey" cryptoki module.
  */
 const CK_ATTRIBUTE_TYPE certAttrs[] = {
     CKA_CLASS,
     CKA_TOKEN,
     CKA_PRIVATE,
     CKA_MODIFIABLE,
     CKA_LABEL,
     CKA_CERTIFICATE_TYPE,
     CKA_SUBJECT,
     CKA_ISSUER,
     CKA_SERIAL_NUMBER,
     CKA_VALUE
 };
 const PRUint32 certAttrsCount = NSS_CKMK_ARRAY_SIZE(certAttrs);
 /* private keys, for now only support RSA */
 const CK_ATTRIBUTE_TYPE privKeyAttrs[] = {
     CKA_CLASS,
     CKA_TOKEN,
     CKA_PRIVATE,
     CKA_MODIFIABLE,
     CKA_LABEL,
     CKA_KEY_TYPE,
     CKA_DERIVE,
     CKA_LOCAL,
     CKA_SUBJECT,
     CKA_SENSITIVE,
     CKA_DECRYPT,
     CKA_SIGN,
     CKA_SIGN_RECOVER,
     CKA_UNWRAP,
     CKA_EXTRACTABLE,
     CKA_ALWAYS_SENSITIVE,
     CKA_NEVER_EXTRACTABLE,
     CKA_MODULUS,
     CKA_PUBLIC_EXPONENT,
 };
 const PRUint32 privKeyAttrsCount = NSS_CKMK_ARRAY_SIZE(privKeyAttrs);
 /* public keys, for now only support RSA */
 const CK_ATTRIBUTE_TYPE pubKeyAttrs[] = {
     CKA_CLASS,
     CKA_TOKEN,
     CKA_PRIVATE,
     CKA_MODIFIABLE,
     CKA_LABEL,
     CKA_KEY_TYPE,
     CKA_DERIVE,
     CKA_LOCAL,
     CKA_SUBJECT,
     CKA_ENCRYPT,
     CKA_VERIFY,
     CKA_VERIFY_RECOVER,
     CKA_WRAP,
     CKA_MODULUS,
     CKA_PUBLIC_EXPONENT,
 };
 const PRUint32 pubKeyAttrsCount = NSS_CKMK_ARRAY_SIZE(pubKeyAttrs);
 static const CK_BBOOL ck_true = CK_TRUE;
 static const CK_BBOOL ck_false = CK_FALSE;
 static const CK_CERTIFICATE_TYPE ckc_x509 = CKC_X_509;
 static const CK_KEY_TYPE ckk_rsa = CKK_RSA;
 static const CK_OBJECT_CLASS cko_certificate = CKO_CERTIFICATE;
 static const CK_OBJECT_CLASS cko_private_key = CKO_PRIVATE_KEY;
 static const CK_OBJECT_CLASS cko_public_key = CKO_PUBLIC_KEY;
 static const NSSItem ckmk_trueItem = {
   (void *)&ck_true, (PRUint32)sizeof(CK_BBOOL) };
 static const NSSItem ckmk_falseItem = {
   (void *)&ck_false, (PRUint32)sizeof(CK_BBOOL) };
 static const NSSItem ckmk_x509Item = {
   (void *)&ckc_x509, (PRUint32)sizeof(CK_CERTIFICATE_TYPE) };
 static const NSSItem ckmk_rsaItem = {
   (void *)&ckk_rsa, (PRUint32)sizeof(CK_KEY_TYPE) };
 static const NSSItem ckmk_certClassItem = {
   (void *)&cko_certificate, (PRUint32)sizeof(CK_OBJECT_CLASS) };
 static const NSSItem ckmk_privKeyClassItem = {
   (void *)&cko_private_key, (PRUint32)sizeof(CK_OBJECT_CLASS) };
 static const NSSItem ckmk_pubKeyClassItem = {
   (void *)&cko_public_key, (PRUint32)sizeof(CK_OBJECT_CLASS) };
 static const NSSItem ckmk_emptyItem = {
   (void *)&ck_true, 0};
 /*
  * these are utilities. The chould be moved to a new utilities file.
  */
 #ifdef DEBUG
 static void
 itemdump(char *str, void *data, int size, CK_RV error)
 {
   unsigned char *ptr = (unsigned char *)data;
   int i;
   fprintf(stderr,str);
   for (i=0; i < size; i++) {
     fprintf(stderr,"%02x ",(unsigned int) ptr[i]);
   }
   fprintf(stderr," (error = %d)\n", (int ) error);
 }
 #endif
 /*
  * unwrap a single DER value
  * now that we have util linked in, we should probably use
  * the ANS1_Decoder for this work...
  */
 unsigned char *
 nss_ckmk_DERUnwrap
 (
   unsigned char *src,
   int size,
   int *outSize,
   unsigned char **next
 )
 {
   unsigned char *start = src;
   unsigned int len = 0;
   /* initialize error condition return values */
   *outSize = 0;
   if (next) {
     *next = src;
   }
   if (size < 2) {
     return start;
   }
   src ++ ; /* skip the tag -- should check it against an expected value! */
   len = (unsigned) *src++;
   if (len & 0x80) {
     int count = len & 0x7f;
     len =0;
     if (count+2 > size) {
       return start;
     }
     while (count-- > 0) {
       len = (len << 8) | (unsigned) *src++;
     }
   }
   if (len + (src-start) > (unsigned int)size) {
     return start;
   }
   if (next) {
     *next = src+len;
   }
   *outSize = len;
   return src;
 }
 /*
  * get an attribute from a template. Value is returned in NSS item.
  * data for the item is owned by the template.
  */
 CK_RV
 nss_ckmk_GetAttribute
 (
   CK_ATTRIBUTE_TYPE type,
   CK_ATTRIBUTE *template,
   CK_ULONG templateSize,
   NSSItem *item
 )
 {
   CK_ULONG i;
   for (i=0; i < templateSize; i++) {
     if (template[i].type == type) {
       item->data = template[i].pValue;
       item->size = template[i].ulValueLen;
       return CKR_OK;
     }
   }
   return CKR_TEMPLATE_INCOMPLETE;
 }
 /*
  * get an attribute which is type CK_ULONG.
  */
 CK_ULONG
 nss_ckmk_GetULongAttribute
 (
   CK_ATTRIBUTE_TYPE type,
   CK_ATTRIBUTE *template,
   CK_ULONG templateSize,
   CK_RV *pError
 )
 {
   NSSItem item;
   *pError = nss_ckmk_GetAttribute(type, template, templateSize, &item);
   if (CKR_OK != *pError) {
     return (CK_ULONG) 0;
   }
   if (item.size != sizeof(CK_ULONG)) {
     *pError = CKR_ATTRIBUTE_VALUE_INVALID;
     return (CK_ULONG) 0;
   }
   return *(CK_ULONG *)item.data;
 }
 /*
  * get an attribute which is type CK_BBOOL.
  */
 CK_BBOOL
 nss_ckmk_GetBoolAttribute
 (
   CK_ATTRIBUTE_TYPE type,
   CK_ATTRIBUTE *template,
   CK_ULONG templateSize,
   CK_BBOOL defaultBool
 )
 {
   NSSItem item;
   CK_RV error;
   error = nss_ckmk_GetAttribute(type, template, templateSize, &item);
   if (CKR_OK != error) {
     return defaultBool;
   }
   if (item.size != sizeof(CK_BBOOL)) {
     return defaultBool;
   }
   return *(CK_BBOOL *)item.data;
 }
 /*
  * get an attribute as a NULL terminated string. Caller is responsible to
  * free the string.
  */
 char *
 nss_ckmk_GetStringAttribute
 (
   CK_ATTRIBUTE_TYPE type,
   CK_ATTRIBUTE *template,
   CK_ULONG templateSize,
   CK_RV *pError
 )
 {
   NSSItem item;
   char *str;
   /* get the attribute */
   *pError = nss_ckmk_GetAttribute(type, template, templateSize, &item);
   if (CKR_OK != *pError) {
     return (char *)NULL;
   }
   /* make sure it is null terminated */
   str = nss_ZNEWARRAY(NULL, char, item.size+1);
   if ((char *)NULL == str) {
     *pError = CKR_HOST_MEMORY;
     return (char *)NULL;
   }
   nsslibc_memcpy(str, item.data, item.size);
   str[item.size] = 0;
   return str;
 }
 /*
  * Apple doesn't seem to have a public interface to the DER encoder,
  * wip out a quick one for integers only (anything more complicated,
  * we should use one of the 3 in lib/util). -- especially since we
  * now link with it.
  */
 static CK_RV
 ckmk_encodeInt(NSSItem *dest, void *src, int srcLen)
 {
   int dataLen = srcLen;
   int lenLen = 1;
   int encLen;
   int isSigned = 0;
   int offset = 0;
   unsigned char *data = NULL;
   int i;
   if (*(unsigned char *)src & 0x80) {
     dataLen++;
     isSigned = 1;
   }
   /* calculate the length of the length specifier */
   /* (NOTE: destroys dataLen value) */
   if (dataLen > 0x7f) {
     do {
       lenLen++;
       dataLen >>= 8;
     } while (dataLen);
   }
   /* calculate our total length */
   dataLen = isSigned + srcLen;
   encLen = 1 + lenLen + dataLen;
   data  = nss_ZNEWARRAY(NULL, unsigned char, encLen);
   if ((unsigned char *)NULL == data) {
     return CKR_HOST_MEMORY;
   }
   data[0] = DER_INTEGER;
   if (1 == lenLen) {
     data[1] = dataLen;
   } else {
     data[1] = 0x80 + lenLen;
     for (i=0; i < lenLen; i++) {
       data[i+1] = ((dataLen >> ((lenLen-i-1)*8)) & 0xff);
     }
   }
   offset = lenLen+1;
   if (isSigned) {
     data[offset++] = 0;
   }
   nsslibc_memcpy(&data[offset], src, srcLen);
   dest->data = data;
   dest->size = encLen;
   return CKR_OK;
 }
 /*
  * Get a Keyring attribute. If content is set to true, then we get the
  * content, not the attribute.
  */
 static CK_RV
 ckmk_GetCommonAttribute
 (
   ckmkInternalObject *io,
   SecItemAttr itemAttr,
   PRBool content,
   NSSItem *item,
   char *dbString
 )
 {
   SecKeychainAttributeList *attrList = NULL;
   SecKeychainAttributeInfo attrInfo;
   PRUint32 len = 0;
   PRUint32 dataLen = 0;
   PRUint32 attrFormat = 0;
   void *dataVal = 0;
   void *out = NULL;
   CK_RV error = CKR_OK;
   OSStatus macErr;
   attrInfo.count = 1;
   attrInfo.tag = &itemAttr;
   attrInfo.format = &attrFormat;
   macErr = SecKeychainItemCopyAttributesAndData(io->u.item.itemRef,
                                 &attrInfo, NULL, &attrList, &len, &out);
   if (noErr != macErr) {
     CKMK_MACERR(dbString, macErr);
     return CKR_ATTRIBUTE_TYPE_INVALID;
   }
   dataLen = content ? len : attrList->attr->length;
   dataVal = content ? out : attrList->attr->data;
   /* Apple's documentation says this value is DER Encoded, but it clearly isn't
    * der encode it before we ship it back off to NSS
    */
   if ( kSecSerialNumberItemAttr == itemAttr ) {
     error = ckmk_encodeInt(item, dataVal, dataLen);
     goto loser; /* logically 'done' if error == CKR_OK */
   }
   item->data = nss_ZNEWARRAY(NULL, char, dataLen);
   if (NULL == item->data) {
     error = CKR_HOST_MEMORY;
     goto loser;
   }
   nsslibc_memcpy(item->data, dataVal, dataLen);
   item->size = dataLen;
 loser:
   SecKeychainItemFreeAttributesAndData(attrList, out);
   return error;
 }
 /*
  * change an attribute (does not operate on the content).
  */
 static CK_RV
 ckmk_updateAttribute
 (
   SecKeychainItemRef itemRef,
   SecItemAttr itemAttr,
   void *data,
   PRUint32 len,
   char *dbString
 )
 {
   SecKeychainAttributeList attrList;
   SecKeychainAttribute     attrAttr;
   OSStatus macErr;
   CK_RV error = CKR_OK;
   attrList.count = 1;
   attrList.attr = &attrAttr;
   attrAttr.tag = itemAttr;
   attrAttr.data = data;
   attrAttr.length = len;
   macErr = SecKeychainItemModifyAttributesAndData(itemRef, &attrList, 0, NULL);
   if (noErr != macErr) {
     CKMK_MACERR(dbString, macErr);
     error = CKR_ATTRIBUTE_TYPE_INVALID;
   }
   return error;
 }
 /*
  * get an attribute (does not operate on the content)
  */
 static CK_RV
 ckmk_GetDataAttribute
 (
   ckmkInternalObject *io,
   SecItemAttr itemAttr,
   NSSItem *item,
   char *dbString
 )
 {
   return ckmk_GetCommonAttribute(io, itemAttr, PR_FALSE, item, dbString);
 }
 /*
  * get an attribute we know is a BOOL.
  */
 static CK_RV
 ckmk_GetBoolAttribute
 (
   ckmkInternalObject *io,
   SecItemAttr itemAttr,
   NSSItem *item,
   char *dbString
 )
 {
   SecKeychainAttribute attr;
   SecKeychainAttributeList attrList;
   CK_BBOOL *boolp = NULL;
   PRUint32 len = 0;;
   void *out = NULL;
   CK_RV error = CKR_OK;
   OSStatus macErr;
   attr.tag = itemAttr;
   attr.length = 0;
   attr.data = NULL;
   attrList.count = 1;
   attrList.attr = &attr;
   boolp = nss_ZNEW(NULL, CK_BBOOL);
   if ((CK_BBOOL *)NULL == boolp) {
     error = CKR_HOST_MEMORY;
     goto loser;
   }
   macErr = SecKeychainItemCopyContent(io->u.item.itemRef, NULL,
                                       &attrList, &len, &out);
   if (noErr != macErr) {
     CKMK_MACERR(dbString, macErr);
     error = CKR_ATTRIBUTE_TYPE_INVALID;
     goto loser;
   }
   if (sizeof(PRUint32) != attr.length) {
     error = CKR_ATTRIBUTE_TYPE_INVALID;
     goto loser;
   }
   *boolp = *(PRUint32 *)attr.data ? 1 : 0;
   item->data =  boolp;
   boolp = NULL;
   item->size = sizeof(CK_BBOOL);
 loser:
   nss_ZFreeIf(boolp);
   SecKeychainItemFreeContent(&attrList, out);
   return error;
 }
 /*
  * macros for fetching attributes into a cache and returning the
  * appropriate value. These operate inside switch statements
  */
 #define CKMK_HANDLE_ITEM(func, io, type, loc, item, error, str) \
     if (0 == (item)->loc.size) { \
       error = func(io, type, &(item)->loc, str); \
     } \
     return (CKR_OK == (error)) ? &(item)->loc : NULL;
 #define CKMK_HANDLE_OPT_ITEM(func, io, type, loc, item, error, str) \
     if (0 == (item)->loc.size) { \
       (void) func(io, type, &(item)->loc, str); \
     } \
     return &(item)->loc ;
 #define CKMK_HANDLE_BOOL_ITEM(io, type, loc, item, error, str) \
     CKMK_HANDLE_ITEM(ckmk_GetBoolAttribute, io, type, loc, item, error, str)
 #define CKMK_HANDLE_DATA_ITEM(io, type, loc, item, error, str) \
     CKMK_HANDLE_ITEM(ckmk_GetDataAttribute, io, type, loc, item, error, str)
 #define CKMK_HANDLE_OPT_DATA_ITEM(io, type, loc, item, error, str) \
     CKMK_HANDLE_OPT_ITEM(ckmk_GetDataAttribute, io, type, loc, item, error, str)
 /*
  * fetch the unique identifier for each object type.
  */
 static void
 ckmk_FetchHashKey
 (
   ckmkInternalObject *io
 )
 {
   NSSItem *key = &io->hashKey;
   if (io->objClass == CKO_CERTIFICATE) {
     ckmk_GetCommonAttribute(io, kSecCertEncodingItemAttr,
                             PR_TRUE, key, "Fetching HashKey (cert)");
   } else {
     ckmk_GetCommonAttribute(io, kSecKeyLabel,
                             PR_FALSE, key, "Fetching HashKey (key)");
   }
 }
 /*
  * Apple mucks with the actual subject and issuer, so go fetch
  * the real ones ourselves.
  */
 static void
 ckmk_fetchCert
 (
   ckmkInternalObject *io
 )
 {
   CK_RV error;
   unsigned char * cert, *next;
   int certSize, thisEntrySize;
   error = ckmk_GetCommonAttribute(io, kSecCertEncodingItemAttr, PR_TRUE,
                         &io->u.item.derCert, "Fetching Value (cert)");
   if (CKR_OK != error) {
     return;
   }
   /* unwrap the cert bundle */
   cert  = nss_ckmk_DERUnwrap((unsigned char *)io->u.item.derCert.data,
                             io->u.item.derCert.size,
                             &certSize, NULL);
   /* unwrap the cert itself */
   /* cert == certdata */
   cert = nss_ckmk_DERUnwrap(cert, certSize, &certSize, NULL);
   /* skip the optional version */
   if ((cert[0] & 0xa0) == 0xa0) {
     nss_ckmk_DERUnwrap(cert, certSize, &thisEntrySize, &next);
     certSize -= next - cert;
     cert = next;
   }
   /* skip the serial number */
   nss_ckmk_DERUnwrap(cert, certSize, &thisEntrySize, &next);
   certSize -= next - cert;
   cert = next;
   /* skip the OID */
   nss_ckmk_DERUnwrap(cert, certSize, &thisEntrySize, &next);
   certSize -= next - cert;
   cert = next;
   /* save the (wrapped) issuer */
   io->u.item.issuer.data = cert;
   nss_ckmk_DERUnwrap(cert, certSize, &thisEntrySize, &next);
   io->u.item.issuer.size = next - cert;
   certSize -= io->u.item.issuer.size;
   cert = next;
   /* skip the OID */
   nss_ckmk_DERUnwrap(cert, certSize, &thisEntrySize, &next);
   certSize -= next - cert;
   cert = next;
   /* save the (wrapped) subject */
   io->u.item.subject.data = cert;
   nss_ckmk_DERUnwrap(cert, certSize, &thisEntrySize, &next);
   io->u.item.subject.size = next - cert;
   certSize -= io->u.item.subject.size;
   cert = next;
 }
 static void
 ckmk_fetchModulus
 (
   ckmkInternalObject *io
 )
 {
   NSSItem item;
   PRInt32 modLen;
   CK_RV error;
   /* we can't reliably get the modulus for private keys through CSSM (sigh).
    * For NSS this is OK because we really only use this to get the modulus
    * length (unless we are trying to get a public key from a private keys,
    * something CSSM ALSO does not do!).
    */
   error = ckmk_GetDataAttribute(io, kSecKeyKeySizeInBits, &item,
                         "Key Fetch Modulus");
   if (CKR_OK != error) {
     return;
   }
   modLen = *(PRInt32 *)item.data;
   modLen = modLen/8; /* convert from bits to bytes */
   nss_ZFreeIf(item.data);
   io->u.item.modulus.data = nss_ZNEWARRAY(NULL, char, modLen);
   if (NULL == io->u.item.modulus.data) {
     return;
   }
   *(char *)io->u.item.modulus.data = 0x80; /* fake NSS out or it will
                                               * drop the first byte */
   io->u.item.modulus.size = modLen;
   return;
 }
 const NSSItem *
 ckmk_FetchCertAttribute
 (
   ckmkInternalObject *io,
   CK_ATTRIBUTE_TYPE type,
   CK_RV *pError
 )
 {
   ckmkItemObject *item = &io->u.item;
   *pError = CKR_OK;
   switch(type) {
   case CKA_CLASS:
     return &ckmk_certClassItem;
   case CKA_TOKEN:
   case CKA_MODIFIABLE:
     return &ckmk_trueItem;
   case CKA_PRIVATE:
     return &ckmk_falseItem;
   case CKA_CERTIFICATE_TYPE:
     return &ckmk_x509Item;
   case CKA_LABEL:
     CKMK_HANDLE_OPT_DATA_ITEM(io, kSecLabelItemAttr, label, item, *pError,
                               "Cert:Label attr")
   case CKA_SUBJECT:
     /* OK, well apple does provide an subject and issuer attribute, but they
      * decided to cannonicalize that value. Probably a good move for them,
      * but makes it useless for most users of PKCS #11.. Get the real subject
      * from the certificate */
     if (0 == item->derCert.size) {
       ckmk_fetchCert(io);
     }
     return &item->subject;
   case CKA_ISSUER:
     if (0 == item->derCert.size) {
       ckmk_fetchCert(io);
     }
     return &item->issuer;
   case CKA_SERIAL_NUMBER:
     CKMK_HANDLE_DATA_ITEM(io, kSecSerialNumberItemAttr, serial, item, *pError,
                           "Cert:Serial Number attr")
   case CKA_VALUE:
     if (0 == item->derCert.size) {
       ckmk_fetchCert(io);
     }
     return &item->derCert;
   case CKA_ID:
     CKMK_HANDLE_OPT_DATA_ITEM(io, kSecPublicKeyHashItemAttr, id, item, *pError,
                               "Cert:ID attr")
   default:
     *pError = CKR_ATTRIBUTE_TYPE_INVALID;
     break;
   }
   return NULL;
 }
 const NSSItem *
 ckmk_FetchPubKeyAttribute
 (
   ckmkInternalObject *io,
   CK_ATTRIBUTE_TYPE type,
   CK_RV *pError
 )
 {
   ckmkItemObject *item = &io->u.item;
   *pError = CKR_OK;
   switch(type) {
   case CKA_CLASS:
     return &ckmk_pubKeyClassItem;
   case CKA_TOKEN:
   case CKA_LOCAL:
     return &ckmk_trueItem;
   case CKA_KEY_TYPE:
     return &ckmk_rsaItem;
   case CKA_LABEL:
     CKMK_HANDLE_OPT_DATA_ITEM(io, kSecKeyPrintName, label, item, *pError,
                               "PubKey:Label attr")
   case CKA_ENCRYPT:
     CKMK_HANDLE_BOOL_ITEM(io, kSecKeyEncrypt, encrypt, item, *pError,
                               "PubKey:Encrypt attr")
   case CKA_VERIFY:
     CKMK_HANDLE_BOOL_ITEM(io, kSecKeyVerify, verify, item, *pError,
                               "PubKey:Verify attr")
   case CKA_VERIFY_RECOVER:
     CKMK_HANDLE_BOOL_ITEM(io, kSecKeyVerifyRecover, verifyRecover,
                           item, *pError, "PubKey:VerifyRecover attr")
   case CKA_PRIVATE:
     CKMK_HANDLE_BOOL_ITEM(io, kSecKeyPrivate, private, item, *pError,
                               "PubKey:Private attr")
   case CKA_MODIFIABLE:
     CKMK_HANDLE_BOOL_ITEM(io, kSecKeyModifiable, modify, item, *pError,
                               "PubKey:Modify attr")
   case CKA_DERIVE:
     CKMK_HANDLE_BOOL_ITEM(io, kSecKeyDerive, derive, item, *pError,
                               "PubKey:Derive attr")
   case CKA_WRAP:
     CKMK_HANDLE_BOOL_ITEM(io, kSecKeyWrap, wrap, item, *pError,
                               "PubKey:Wrap attr")
   case CKA_SUBJECT:
     CKMK_HANDLE_OPT_DATA_ITEM(io, kSecSubjectItemAttr, subject, item, *pError,
                               "PubKey:Subect attr")
   case CKA_MODULUS:
     return &ckmk_emptyItem;
   case CKA_PUBLIC_EXPONENT:
     return &ckmk_emptyItem;
   case CKA_ID:
     CKMK_HANDLE_OPT_DATA_ITEM(io, kSecKeyLabel, id, item, *pError,
                               "PubKey:ID attr")
   default:
     *pError = CKR_ATTRIBUTE_TYPE_INVALID;
     break;
   }
   return NULL;
 }
 const NSSItem *
 ckmk_FetchPrivKeyAttribute
 (
   ckmkInternalObject *io,
   CK_ATTRIBUTE_TYPE type,
   CK_RV *pError
 )
 {
   ckmkItemObject *item = &io->u.item;
   *pError = CKR_OK;
   switch(type) {
   case CKA_CLASS:
     return &ckmk_privKeyClassItem;
   case CKA_TOKEN:
   case CKA_LOCAL:
     return &ckmk_trueItem;
   case CKA_SENSITIVE:
   case CKA_EXTRACTABLE: /* will probably move in the future */
   case CKA_ALWAYS_SENSITIVE:
   case CKA_NEVER_EXTRACTABLE:
     return &ckmk_falseItem;
   case CKA_KEY_TYPE:
     return &ckmk_rsaItem;
   case CKA_LABEL:
     CKMK_HANDLE_OPT_DATA_ITEM(io, kSecKeyPrintName, label, item, *pError,
                               "PrivateKey:Label attr")
   case CKA_DECRYPT:
     CKMK_HANDLE_BOOL_ITEM(io, kSecKeyDecrypt, decrypt, item, *pError,
                               "PrivateKey:Decrypt attr")
   case CKA_SIGN:
     CKMK_HANDLE_BOOL_ITEM(io, kSecKeySign, sign, item, *pError,
                               "PrivateKey:Sign attr")
   case CKA_SIGN_RECOVER:
     CKMK_HANDLE_BOOL_ITEM(io, kSecKeySignRecover, signRecover, item, *pError,
                               "PrivateKey:Sign Recover attr")
   case CKA_PRIVATE:
     CKMK_HANDLE_BOOL_ITEM(io, kSecKeyPrivate, private, item, *pError,
                               "PrivateKey:Private attr")
   case CKA_MODIFIABLE:
     CKMK_HANDLE_BOOL_ITEM(io, kSecKeyModifiable, modify, item, *pError,
                               "PrivateKey:Modify attr")
   case CKA_DERIVE:
     CKMK_HANDLE_BOOL_ITEM(io, kSecKeyDerive, derive, item, *pError,
                               "PrivateKey:Derive attr")
   case CKA_UNWRAP:
     CKMK_HANDLE_BOOL_ITEM(io, kSecKeyUnwrap, unwrap, item, *pError,
                               "PrivateKey:Unwrap attr")
   case CKA_SUBJECT:
     CKMK_HANDLE_OPT_DATA_ITEM(io, kSecSubjectItemAttr, subject, item, *pError,
                               "PrivateKey:Subject attr")
   case CKA_MODULUS:
     if (0 == item->modulus.size) {
       ckmk_fetchModulus(io);
     }
     return &item->modulus;
   case CKA_PUBLIC_EXPONENT:
     return &ckmk_emptyItem;
 #ifdef notdef
   /* the following are sensitive attributes. We could implement them for
    * sensitive keys using the key export function, but it's better to
    * just support wrap through this token. That will more reliably allow us
    * to export any private key that is truly exportable.
    */
   case CKA_PRIVATE_EXPONENT:
     CKMK_HANDLE_DATA_ITEM(io, kSecPrivateExponentItemAttr, privateExponent,
                           item, *pError)
   case CKA_PRIME_1:
     CKMK_HANDLE_DATA_ITEM(io, kSecPrime1ItemAttr, prime1, item, *pError)
   case CKA_PRIME_2:
     CKMK_HANDLE_DATA_ITEM(io, kSecPrime2ItemAttr, prime2, item, *pError)
   case CKA_EXPONENT_1:
     CKMK_HANDLE_DATA_ITEM(io, kSecExponent1ItemAttr, exponent1, item, *pError)
   case CKA_EXPONENT_2:
     CKMK_HANDLE_DATA_ITEM(io, kSecExponent2ItemAttr, exponent2, item, *pError)
   case CKA_COEFFICIENT:
     CKMK_HANDLE_DATA_ITEM(io, kSecCoefficientItemAttr, coefficient,
                           item, *pError)
 #endif
   case CKA_ID:
     CKMK_HANDLE_OPT_DATA_ITEM(io, kSecKeyLabel, id, item, *pError,
                               "PrivateKey:ID attr")
   default:
     *pError = CKR_ATTRIBUTE_TYPE_INVALID;
     return NULL;
   }
 }
 const NSSItem *
 nss_ckmk_FetchAttribute
 (
   ckmkInternalObject *io,
   CK_ATTRIBUTE_TYPE type,
   CK_RV *pError
 )
 {
   CK_ULONG i;
   const NSSItem * value = NULL;
   if (io->type == ckmkRaw) {
     for( i = 0; i < io->u.raw.n; i++ ) {
       if( type == io->u.raw.types[i] ) {
         return &io->u.raw.items[i];
       }
     }
     *pError = CKR_ATTRIBUTE_TYPE_INVALID;
     return NULL;
   }
   /* deal with the common attributes */
   switch (io->objClass) {
   case CKO_CERTIFICATE:
    value = ckmk_FetchCertAttribute(io, type, pError);
    break;
   case CKO_PRIVATE_KEY:
    value = ckmk_FetchPrivKeyAttribute(io, type, pError);
    break;
   case CKO_PUBLIC_KEY:
    value = ckmk_FetchPubKeyAttribute(io, type, pError);
    break;
   default:
     *pError = CKR_OBJECT_HANDLE_INVALID;
     return NULL;
  }
 #ifdef DEBUG
   if (CKA_ID == type) {
     itemdump("id: ", value->data, value->size, *pError);
   }
 #endif
   return value;
 }
 static void
 ckmk_removeObjectFromHash
 (
   ckmkInternalObject *io
 );
 /*
  *
  * These are the MSObject functions we need to implement
  *
  * Finalize - unneeded (actually we should clean up the hashtables)
  * Destroy
  * IsTokenObject - CK_TRUE
  * GetAttributeCount
  * GetAttributeTypes
  * GetAttributeSize
  * GetAttribute
  * SetAttribute
  * GetObjectSize
  */
 static CK_RV
 ckmk_mdObject_Destroy
 (
   NSSCKMDObject *mdObject,
   NSSCKFWObject *fwObject,
   NSSCKMDSession *mdSession,
   NSSCKFWSession *fwSession,
   NSSCKMDToken *mdToken,
   NSSCKFWToken *fwToken,
   NSSCKMDInstance *mdInstance,
   NSSCKFWInstance *fwInstance
 )
 {
   ckmkInternalObject *io = (ckmkInternalObject *)mdObject->etc;
   OSStatus macErr;
   if (ckmkRaw == io->type) {
     /* there is not 'object write protected' error, use the next best thing */
     return CKR_TOKEN_WRITE_PROTECTED;
   }
   /* This API is done well. The following 4 lines are the complete apple
    * specific part of this implementation */
   macErr = SecKeychainItemDelete(io->u.item.itemRef);
   if (noErr != macErr) {
     CKMK_MACERR("Delete object", macErr);
   }
   /* remove it from the hash */
   ckmk_removeObjectFromHash(io);
   /* free the puppy.. */
   nss_ckmk_DestroyInternalObject(io);
   return CKR_OK;
 }
 static CK_BBOOL
 ckmk_mdObject_IsTokenObject
 (
   NSSCKMDObject *mdObject,
   NSSCKFWObject *fwObject,
   NSSCKMDSession *mdSession,
   NSSCKFWSession *fwSession,
   NSSCKMDToken *mdToken,
   NSSCKFWToken *fwToken,
   NSSCKMDInstance *mdInstance,
   NSSCKFWInstance *fwInstance
 )
 {
   return CK_TRUE;
 }
 static CK_ULONG
 ckmk_mdObject_GetAttributeCount
 (
   NSSCKMDObject *mdObject,
   NSSCKFWObject *fwObject,
   NSSCKMDSession *mdSession,
   NSSCKFWSession *fwSession,
   NSSCKMDToken *mdToken,
   NSSCKFWToken *fwToken,
   NSSCKMDInstance *mdInstance,
   NSSCKFWInstance *fwInstance,
   CK_RV *pError
 )
 {
   ckmkInternalObject *io = (ckmkInternalObject *)mdObject->etc;
   if (ckmkRaw == io->type) {
      return io->u.raw.n;
   }
   switch (io->objClass) {
   case CKO_CERTIFICATE:
     return certAttrsCount;
   case CKO_PUBLIC_KEY:
     return pubKeyAttrsCount;
   case CKO_PRIVATE_KEY:
     return privKeyAttrsCount;
   default:
     break;
   }
   return 0;
 }
 static CK_RV
 ckmk_mdObject_GetAttributeTypes
 (
   NSSCKMDObject *mdObject,
   NSSCKFWObject *fwObject,
   NSSCKMDSession *mdSession,
   NSSCKFWSession *fwSession,
   NSSCKMDToken *mdToken,
   NSSCKFWToken *fwToken,
   NSSCKMDInstance *mdInstance,
   NSSCKFWInstance *fwInstance,
   CK_ATTRIBUTE_TYPE_PTR typeArray,
   CK_ULONG ulCount
 )
 {
   ckmkInternalObject *io = (ckmkInternalObject *)mdObject->etc;
   CK_ULONG i;
   CK_RV error = CKR_OK;
   const CK_ATTRIBUTE_TYPE *attrs = NULL;
   CK_ULONG size = ckmk_mdObject_GetAttributeCount(
                         mdObject, fwObject, mdSession, fwSession,
                         mdToken, fwToken, mdInstance, fwInstance, &error);
   if( size != ulCount ) {
     return CKR_BUFFER_TOO_SMALL;
   }
   if (io->type == ckmkRaw) {
     attrs = io->u.raw.types;
   } else switch(io->objClass) {
     case CKO_CERTIFICATE:
       attrs = certAttrs;
       break;
     case CKO_PUBLIC_KEY:
       attrs = pubKeyAttrs;
       break;
     case CKO_PRIVATE_KEY:
       attrs = privKeyAttrs;
       break;
     default:
       return CKR_OK;
   }
   for( i = 0; i < size; i++) {
     typeArray[i] = attrs[i];
   }
   return CKR_OK;
 }
 static CK_ULONG
 ckmk_mdObject_GetAttributeSize
 (
   NSSCKMDObject *mdObject,
   NSSCKFWObject *fwObject,
   NSSCKMDSession *mdSession,
   NSSCKFWSession *fwSession,
   NSSCKMDToken *mdToken,
   NSSCKFWToken *fwToken,
   NSSCKMDInstance *mdInstance,
   NSSCKFWInstance *fwInstance,
   CK_ATTRIBUTE_TYPE attribute,
   CK_RV *pError
 )
 {
   ckmkInternalObject *io = (ckmkInternalObject *)mdObject->etc;
   const NSSItem *b;
   b = nss_ckmk_FetchAttribute(io, attribute, pError);
   if ((const NSSItem *)NULL == b) {
     return 0;
   }
   return b->size;
 }
 static CK_RV
 ckmk_mdObject_SetAttribute
 (
   NSSCKMDObject *mdObject,
   NSSCKFWObject *fwObject,
   NSSCKMDSession *mdSession,
   NSSCKFWSession *fwSession,
   NSSCKMDToken *mdToken,
   NSSCKFWToken *fwToken,
   NSSCKMDInstance *mdInstance,
   NSSCKFWInstance *fwInstance,
   CK_ATTRIBUTE_TYPE attribute,
   NSSItem           *value
 )
 {
   ckmkInternalObject *io = (ckmkInternalObject *)mdObject->etc;
   SecKeychainItemRef itemRef;
   if (io->type == ckmkRaw) {
     return CKR_TOKEN_WRITE_PROTECTED;
   }
   itemRef = io->u.item.itemRef;
   switch (io->objClass) {
   case CKO_PRIVATE_KEY:
   case CKO_PUBLIC_KEY:
     switch (attribute) {
     case CKA_ID:
       ckmk_updateAttribute(itemRef, kSecKeyLabel,
                               value->data, value->size, "Set Attr Key ID");
 #ifdef DEBUG
       itemdump("key id: ", value->data, value->size, CKR_OK);
 #endif
       break;
     case CKA_LABEL:
       ckmk_updateAttribute(itemRef, kSecKeyPrintName, value->data,
                               value->size, "Set Attr Key Label");
       break;
     default:
       break;
     }
     break;
   case CKO_CERTIFICATE:
     switch (attribute) {
     case CKA_ID:
       ckmk_updateAttribute(itemRef, kSecPublicKeyHashItemAttr,
                               value->data, value->size, "Set Attr Cert ID");
       break;
     case CKA_LABEL:
       ckmk_updateAttribute(itemRef, kSecLabelItemAttr, value->data,
                               value->size, "Set Attr Cert Label");
       break;
     default:
       break;
     }
     break;
    default:
     break;
   }
   return CKR_OK;
 }
 static NSSCKFWItem
 ckmk_mdObject_GetAttribute
 (
   NSSCKMDObject *mdObject,
   NSSCKFWObject *fwObject,
   NSSCKMDSession *mdSession,
   NSSCKFWSession *fwSession,
   NSSCKMDToken *mdToken,
   NSSCKFWToken *fwToken,
   NSSCKMDInstance *mdInstance,
   NSSCKFWInstance *fwInstance,
   CK_ATTRIBUTE_TYPE attribute,
   CK_RV *pError
 )
 {
   NSSCKFWItem mdItem;
   ckmkInternalObject *io = (ckmkInternalObject *)mdObject->etc;
   mdItem.needsFreeing = PR_FALSE;
   mdItem.item = (NSSItem*)nss_ckmk_FetchAttribute(io, attribute, pError);
   return mdItem;
 }
 static CK_ULONG
 ckmk_mdObject_GetObjectSize
 (
   NSSCKMDObject *mdObject,
   NSSCKFWObject *fwObject,
   NSSCKMDSession *mdSession,
   NSSCKFWSession *fwSession,
   NSSCKMDToken *mdToken,
   NSSCKFWToken *fwToken,
   NSSCKMDInstance *mdInstance,
   NSSCKFWInstance *fwInstance,
   CK_RV *pError
 )
 {
   CK_ULONG rv = 1;
   /* size is irrelevant to this token */
   return rv;
 }
 static const NSSCKMDObject
 ckmk_prototype_mdObject = {
   (void *)NULL, /* etc */
   NULL, /* Finalize */
   ckmk_mdObject_Destroy,
   ckmk_mdObject_IsTokenObject,
   ckmk_mdObject_GetAttributeCount,
   ckmk_mdObject_GetAttributeTypes,
   ckmk_mdObject_GetAttributeSize,
   ckmk_mdObject_GetAttribute,
   NULL, /* FreeAttribute */
   ckmk_mdObject_SetAttribute,
   ckmk_mdObject_GetObjectSize,
   (void *)NULL /* null terminator */
 };
 static nssHash *ckmkInternalObjectHash = NULL;
 NSS_IMPLEMENT NSSCKMDObject *
 nss_ckmk_CreateMDObject
 (
   NSSArena *arena,
   ckmkInternalObject *io,
   CK_RV *pError
 )
 {
   if ((nssHash *)NULL == ckmkInternalObjectHash) {
     ckmkInternalObjectHash = nssHash_CreateItem(NULL, 10);
   }
   if (ckmkItem == io->type) {
     /* the hash key, not a cryptographic key */
     NSSItem *key = &io->hashKey;
     ckmkInternalObject *old_o = NULL;
     if (key->size == 0) {
       ckmk_FetchHashKey(io);
     }
     old_o = (ckmkInternalObject *)
               nssHash_Lookup(ckmkInternalObjectHash, key);
     if (!old_o) {
       nssHash_Add(ckmkInternalObjectHash, key, io);
     } else if (old_o != io) {
       nss_ckmk_DestroyInternalObject(io);
       io = old_o;
     }
   }
   if ( (void*)NULL == io->mdObject.etc) {
     (void) nsslibc_memcpy(&io->mdObject,&ckmk_prototype_mdObject,
                                         sizeof(ckmk_prototype_mdObject));
     io->mdObject.etc = (void *)io;
   }
   return &io->mdObject;
 }
 static void
 ckmk_removeObjectFromHash
 (
   ckmkInternalObject *io
 )
 {
   NSSItem *key = &io->hashKey;
   if ((nssHash *)NULL == ckmkInternalObjectHash) {
     return;
   }
   if (key->size == 0) {
     ckmk_FetchHashKey(io);
   }
   nssHash_Remove(ckmkInternalObjectHash, key);
   return;
 }
 void
 nss_ckmk_DestroyInternalObject
 (
   ckmkInternalObject *io
 )
 {
   switch (io->type) {
   case ckmkRaw:
     return;
   case ckmkItem:
     nss_ZFreeIf(io->u.item.modify.data);
     nss_ZFreeIf(io->u.item.private.data);
     nss_ZFreeIf(io->u.item.encrypt.data);
     nss_ZFreeIf(io->u.item.decrypt.data);
     nss_ZFreeIf(io->u.item.derive.data);
     nss_ZFreeIf(io->u.item.sign.data);
     nss_ZFreeIf(io->u.item.signRecover.data);
     nss_ZFreeIf(io->u.item.verify.data);
     nss_ZFreeIf(io->u.item.verifyRecover.data);
     nss_ZFreeIf(io->u.item.wrap.data);
     nss_ZFreeIf(io->u.item.unwrap.data);
     nss_ZFreeIf(io->u.item.label.data);
     /*nss_ZFreeIf(io->u.item.subject.data); */
     /*nss_ZFreeIf(io->u.item.issuer.data); */
     nss_ZFreeIf(io->u.item.serial.data);
     nss_ZFreeIf(io->u.item.modulus.data);
     nss_ZFreeIf(io->u.item.exponent.data);
     nss_ZFreeIf(io->u.item.privateExponent.data);
     nss_ZFreeIf(io->u.item.prime1.data);
     nss_ZFreeIf(io->u.item.prime2.data);
     nss_ZFreeIf(io->u.item.exponent1.data);
     nss_ZFreeIf(io->u.item.exponent2.data);
     nss_ZFreeIf(io->u.item.coefficient.data);
     break;
   }
   nss_ZFreeIf(io);
   return;
 }
 static ckmkInternalObject *
 nss_ckmk_NewInternalObject
 (
   CK_OBJECT_CLASS objClass,
   SecKeychainItemRef itemRef,
   SecItemClass itemClass,
   CK_RV *pError
 )
 {
   ckmkInternalObject *io = nss_ZNEW(NULL, ckmkInternalObject);
   if ((ckmkInternalObject *)NULL == io) {
     *pError = CKR_HOST_MEMORY;
     return io;
   }
   io->type = ckmkItem;
   io->objClass = objClass;
   io->u.item.itemRef = itemRef;
   io->u.item.itemClass = itemClass;
   return io;
 }
 /*
  * Apple doesn't alway have a default keyChain set by the OS, use the
  * SearchList to try to find one.
  */
 static CK_RV
 ckmk_GetSafeDefaultKeychain
 (
   SecKeychainRef *keychainRef
 )
 {
   OSStatus macErr;
   CFArrayRef searchList = 0;
   CK_RV error = CKR_OK;
   macErr = SecKeychainCopyDefault(keychainRef);
   if (noErr != macErr) {
     int searchCount = 0;
     if (errSecNoDefaultKeychain != macErr) {
       CKMK_MACERR("Getting default key chain", macErr);
       error = CKR_GENERAL_ERROR;
       goto loser;
     }
     /* ok, we don't have a default key chain, find one */
     macErr = SecKeychainCopySearchList(&searchList);
     if (noErr != macErr) {
       CKMK_MACERR("failed to find a keyring searchList", macErr);
       error = CKR_DEVICE_REMOVED;
       goto loser;
     }
     searchCount = CFArrayGetCount(searchList);
     if (searchCount < 1) {
       error = CKR_DEVICE_REMOVED;
       goto loser;
     }
     *keychainRef =
         (SecKeychainRef)CFRetain(CFArrayGetValueAtIndex(searchList, 0));
     if (0 == *keychainRef) {
       error = CKR_DEVICE_REMOVED;
       goto loser;
     }
     /* should we set it as default? */
   }
 loser:
   if (0 != searchList) {
     CFRelease(searchList);
   }
   return error;
 }
 static ckmkInternalObject *
 nss_ckmk_CreateCertificate
 (
   NSSCKFWSession *fwSession,
   CK_ATTRIBUTE_PTR pTemplate,
   CK_ULONG ulAttributeCount,
   CK_RV *pError
 )
 {
   NSSItem value;
   ckmkInternalObject *io = NULL;
   OSStatus macErr;
   SecCertificateRef certRef;
   SecKeychainItemRef itemRef;
   SecKeychainRef keychainRef;
   CSSM_DATA certData;
   *pError = nss_ckmk_GetAttribute(CKA_VALUE, pTemplate,
                                   ulAttributeCount, &value);
   if (CKR_OK != *pError) {
     goto loser;
   }
   certData.Data = value.data;
   certData.Length = value.size;
   macErr = SecCertificateCreateFromData(&certData, CSSM_CERT_X_509v3,
                               CSSM_CERT_ENCODING_BER, &certRef);
   if (noErr != macErr) {
     CKMK_MACERR("Create cert from data Failed", macErr);
     *pError = CKR_GENERAL_ERROR; /* need to map macErr */
     goto loser;
   }
   *pError = ckmk_GetSafeDefaultKeychain(&keychainRef);
   if (CKR_OK != *pError) {
     goto loser;
   }
   macErr = SecCertificateAddToKeychain( certRef, keychainRef);
   itemRef = (SecKeychainItemRef) certRef;
   if (errSecDuplicateItem != macErr) {
     NSSItem keyID = { NULL, 0 };
     char *nickname = NULL;
     CK_RV dummy;
     if (noErr != macErr) {
       CKMK_MACERR("Add cert to keychain Failed", macErr);
       *pError = CKR_GENERAL_ERROR; /* need to map macErr */
       goto loser;
     }
     /* these two are optional */
     nickname = nss_ckmk_GetStringAttribute(CKA_LABEL, pTemplate,
                                   ulAttributeCount, &dummy);
     /* we've added a new one, update the attributes in the key ring */
     if (nickname) {
       ckmk_updateAttribute(itemRef, kSecLabelItemAttr, nickname,
                               strlen(nickname)+1, "Modify Cert Label");
       nss_ZFreeIf(nickname);
     }
     dummy = nss_ckmk_GetAttribute(CKA_ID, pTemplate,
                                   ulAttributeCount, &keyID);
     if (CKR_OK == dummy) {
       dummy = ckmk_updateAttribute(itemRef, kSecPublicKeyHashItemAttr,
                               keyID.data, keyID.size, "Modify Cert ID");
     }
   }
   io = nss_ckmk_NewInternalObject(CKO_CERTIFICATE, itemRef,
                                   kSecCertificateItemClass, pError);
   if ((ckmkInternalObject *)NULL != io) {
     itemRef = 0;
   }
 loser:
   if (0 != itemRef) {
     CFRelease(itemRef);
   }
   if (0 != keychainRef) {
     CFRelease(keychainRef);
   }
   return io;
 }
 /*
  * PKCS #8 attributes
  */
 struct ckmk_AttributeStr {
     SECItem attrType;
     SECItem *attrValue;
 };
 typedef struct ckmk_AttributeStr ckmk_Attribute;
 /*
 ** A PKCS#8 private key info object
 */
 struct PrivateKeyInfoStr {
     PLArenaPool *arena;
     SECItem version;
     SECAlgorithmID algorithm;
     SECItem privateKey;
     ckmk_Attribute **attributes;
 };
 typedef struct PrivateKeyInfoStr PrivateKeyInfo;
 const SEC_ASN1Template ckmk_RSAPrivateKeyTemplate[] = {
     { SEC_ASN1_SEQUENCE, 0, NULL, sizeof(RSAPrivateKey) },
     { SEC_ASN1_INTEGER, offsetof(RSAPrivateKey,version) },
     { SEC_ASN1_INTEGER, offsetof(RSAPrivateKey,modulus) },
     { SEC_ASN1_INTEGER, offsetof(RSAPrivateKey,publicExponent) },
     { SEC_ASN1_INTEGER, offsetof(RSAPrivateKey,privateExponent) },
     { SEC_ASN1_INTEGER, offsetof(RSAPrivateKey,prime1) },
     { SEC_ASN1_INTEGER, offsetof(RSAPrivateKey,prime2) },
     { SEC_ASN1_INTEGER, offsetof(RSAPrivateKey,exponent1) },
     { SEC_ASN1_INTEGER, offsetof(RSAPrivateKey,exponent2) },
     { SEC_ASN1_INTEGER, offsetof(RSAPrivateKey,coefficient) },
     { 0 }
 };
 const SEC_ASN1Template ckmk_AttributeTemplate[] = {
     { SEC_ASN1_SEQUENCE, 0, NULL, sizeof(ckmk_Attribute) },
     { SEC_ASN1_OBJECT_ID, offsetof(ckmk_Attribute, attrType) },
     { SEC_ASN1_SET_OF, offsetof(ckmk_Attribute, attrValue),
         SEC_AnyTemplate },
     { 0 }
 };
 const SEC_ASN1Template ckmk_SetOfAttributeTemplate[] = {
     { SEC_ASN1_SET_OF, 0, ckmk_AttributeTemplate },
 };
 SEC_ASN1_MKSUB(SECOID_AlgorithmIDTemplate)
 /* ASN1 Templates for new decoder/encoder */
 const SEC_ASN1Template ckmk_PrivateKeyInfoTemplate[] = {
     { SEC_ASN1_SEQUENCE, 0, NULL, sizeof(PrivateKeyInfo) },
     { SEC_ASN1_INTEGER, offsetof(PrivateKeyInfo,version) },
     { SEC_ASN1_INLINE | SEC_ASN1_XTRN, offsetof(PrivateKeyInfo,algorithm),
         SEC_ASN1_SUB(SECOID_AlgorithmIDTemplate) },
     { SEC_ASN1_OCTET_STRING, offsetof(PrivateKeyInfo,privateKey) },
     { SEC_ASN1_OPTIONAL | SEC_ASN1_CONSTRUCTED | SEC_ASN1_CONTEXT_SPECIFIC | 0,
         offsetof(PrivateKeyInfo, attributes), ckmk_SetOfAttributeTemplate },
     { 0 }
 };
 #define CKMK_PRIVATE_KEY_INFO_VERSION 0
 static CK_RV
 ckmk_CreateRSAKeyBlob
 (
   RSAPrivateKey *lk,
   NSSItem *keyBlob
 )
 {
   PrivateKeyInfo *pki = NULL;
   PLArenaPool *arena = NULL;
   SECOidTag algorithm = SEC_OID_UNKNOWN;
   void *dummy;
   SECStatus rv;
   SECItem *encodedKey = NULL;
   CK_RV error = CKR_OK;
   arena = PORT_NewArena(2048);         /* XXX different size? */
   if(!arena) {
     error = CKR_HOST_MEMORY;
     goto loser;
   }
   pki = (PrivateKeyInfo*)PORT_ArenaZAlloc(arena, sizeof(PrivateKeyInfo));
   if(!pki) {
     error = CKR_HOST_MEMORY;
     goto loser;
   }
   pki->arena = arena;
   dummy = SEC_ASN1EncodeItem(arena, &pki->privateKey, lk,
                              ckmk_RSAPrivateKeyTemplate);
   algorithm = SEC_OID_PKCS1_RSA_ENCRYPTION;
   if (!dummy) {
     error = CKR_DEVICE_ERROR; /* should map NSS SECError */
     goto loser;
   }
   rv = SECOID_SetAlgorithmID(arena, &pki->algorithm, algorithm,
                              (SECItem*)NULL);
   if (rv != SECSuccess) {
     error = CKR_DEVICE_ERROR; /* should map NSS SECError */
     goto loser;
   }
   dummy = SEC_ASN1EncodeInteger(arena, &pki->version,
                                 CKMK_PRIVATE_KEY_INFO_VERSION);
   if (!dummy) {
     error = CKR_DEVICE_ERROR; /* should map NSS SECError */
     goto loser;
   }
   encodedKey = SEC_ASN1EncodeItem(NULL, NULL, pki,
                                   ckmk_PrivateKeyInfoTemplate);
   if (!encodedKey) {
     error = CKR_DEVICE_ERROR;
     goto loser;
   }
   keyBlob->data = nss_ZNEWARRAY(NULL, char, encodedKey->len);
   if (NULL == keyBlob->data) {
     error = CKR_HOST_MEMORY;
     goto loser;
   }
   nsslibc_memcpy(keyBlob->data, encodedKey->data, encodedKey->len);
   keyBlob->size = encodedKey->len;
 loser:
   if(arena) {
     PORT_FreeArena(arena, PR_TRUE);
   }
   if (encodedKey) {
     SECITEM_FreeItem(encodedKey, PR_TRUE);
   }
   return error;
 }
 /*
  * There MUST be a better way to do this. For now, find the key based on the
  * default name Apple gives it once we import.
  */
 #define IMPORTED_NAME "Imported Private Key"
 static CK_RV
 ckmk_FindImportedKey
 (
   SecKeychainRef keychainRef,
   SecItemClass itemClass,
   SecKeychainItemRef *outItemRef
 )
 {
   OSStatus macErr;
   SecKeychainSearchRef searchRef = 0;
   SecKeychainItemRef newItemRef;
   macErr = SecKeychainSearchCreateFromAttributes(keychainRef, itemClass,
            NULL, &searchRef);
   if (noErr != macErr) {
     CKMK_MACERR("Can't search for Key", macErr);
     return CKR_GENERAL_ERROR;
   }
   while (noErr == SecKeychainSearchCopyNext(searchRef, &newItemRef)) {
     SecKeychainAttributeList *attrList = NULL;
     SecKeychainAttributeInfo attrInfo;
     SecItemAttr itemAttr = kSecKeyPrintName;
     PRUint32 attrFormat = 0;
     OSStatus macErr;
     attrInfo.count = 1;
     attrInfo.tag = &itemAttr;
     attrInfo.format = &attrFormat;
     macErr = SecKeychainItemCopyAttributesAndData(newItemRef,
                                 &attrInfo, NULL, &attrList, NULL, NULL);
     if (noErr == macErr) {
       if (nsslibc_memcmp(attrList->attr->data, IMPORTED_NAME,
                          attrList->attr->length, NULL) == 0) {
         *outItemRef = newItemRef;
         CFRelease (searchRef);
         SecKeychainItemFreeAttributesAndData(attrList, NULL);
         return CKR_OK;
       }
       SecKeychainItemFreeAttributesAndData(attrList, NULL);
     }
     CFRelease(newItemRef);
   }
   CFRelease (searchRef);
   return CKR_GENERAL_ERROR; /* we can come up with something better! */
 }
 static ckmkInternalObject *
 nss_ckmk_CreatePrivateKey
 (
   NSSCKFWSession *fwSession,
   CK_ATTRIBUTE_PTR pTemplate,
   CK_ULONG ulAttributeCount,
   CK_RV *pError
 )
 {
   NSSItem attribute;
   RSAPrivateKey lk;
   NSSItem keyID;
   char *nickname = NULL;
   ckmkInternalObject *io = NULL;
   CK_KEY_TYPE keyType;
   OSStatus macErr;
   SecKeychainItemRef itemRef = 0;
   NSSItem keyBlob = { NULL, 0 };
   CFDataRef dataRef = 0;
   SecExternalFormat inputFormat = kSecFormatBSAFE;
   /*SecExternalFormat inputFormat = kSecFormatOpenSSL;  */
   SecExternalItemType itemType = kSecItemTypePrivateKey;
   SecKeyImportExportParameters keyParams ;
   SecKeychainRef targetKeychain = 0;
   unsigned char zero = 0;
   CK_RV error;
   keyParams.version = SEC_KEY_IMPORT_EXPORT_PARAMS_VERSION;
   keyParams.flags = 0;
   keyParams.passphrase = 0;
   keyParams.alertTitle = 0;
   keyParams.alertPrompt = 0;
   keyParams.accessRef = 0; /* default */
   keyParams.keyUsage = 0; /* will get filled in */
   keyParams.keyAttributes = CSSM_KEYATTR_PERMANENT; /* will get filled in */
   keyType = nss_ckmk_GetULongAttribute
                   (CKA_KEY_TYPE, pTemplate, ulAttributeCount, pError);
   if (CKR_OK != *pError) {
     return (ckmkInternalObject *)NULL;
   }
   if (CKK_RSA != keyType) {
     *pError = CKR_ATTRIBUTE_VALUE_INVALID;
     return (ckmkInternalObject *)NULL;
   }
   if (nss_ckmk_GetBoolAttribute(CKA_DECRYPT,
                                 pTemplate, ulAttributeCount, CK_TRUE)) {
     keyParams.keyUsage |= CSSM_KEYUSE_DECRYPT;
   }
   if (nss_ckmk_GetBoolAttribute(CKA_UNWRAP,
                                 pTemplate, ulAttributeCount, CK_TRUE)) {
     keyParams.keyUsage |=  CSSM_KEYUSE_UNWRAP;
   }
   if (nss_ckmk_GetBoolAttribute(CKA_SIGN,
                                 pTemplate, ulAttributeCount, CK_TRUE)) {
     keyParams.keyUsage |= CSSM_KEYUSE_SIGN;
   }
   if (nss_ckmk_GetBoolAttribute(CKA_DERIVE,
                                 pTemplate, ulAttributeCount, CK_FALSE)) {
     keyParams.keyUsage |= CSSM_KEYUSE_DERIVE;
   }
   if (nss_ckmk_GetBoolAttribute(CKA_SENSITIVE,
                                 pTemplate, ulAttributeCount, CK_TRUE)) {
     keyParams.keyAttributes |= CSSM_KEYATTR_SENSITIVE;
   }
   if (nss_ckmk_GetBoolAttribute(CKA_EXTRACTABLE,
                                 pTemplate, ulAttributeCount, CK_TRUE)) {
     keyParams.keyAttributes |= CSSM_KEYATTR_EXTRACTABLE;
   }
   lk.version.type = siUnsignedInteger;
   lk.version.data = &zero;
   lk.version.len = 1;
   *pError = nss_ckmk_GetAttribute(CKA_MODULUS, pTemplate,
                                   ulAttributeCount, &attribute);
   if (CKR_OK != *pError) {
     return (ckmkInternalObject *)NULL;
   }
   lk.modulus.type = siUnsignedInteger;
   lk.modulus.data = attribute.data;
   lk.modulus.len = attribute.size;
   *pError = nss_ckmk_GetAttribute(CKA_PUBLIC_EXPONENT, pTemplate,
                                   ulAttributeCount, &attribute);
   if (CKR_OK != *pError) {
     return (ckmkInternalObject *)NULL;
   }
   lk.publicExponent.type = siUnsignedInteger;
   lk.publicExponent.data = attribute.data;
   lk.publicExponent.len = attribute.size;
   *pError = nss_ckmk_GetAttribute(CKA_PRIVATE_EXPONENT, pTemplate,
                                   ulAttributeCount, &attribute);
   if (CKR_OK != *pError) {
     return (ckmkInternalObject *)NULL;
   }
   lk.privateExponent.type = siUnsignedInteger;
   lk.privateExponent.data = attribute.data;
   lk.privateExponent.len = attribute.size;
   *pError = nss_ckmk_GetAttribute(CKA_PRIME_1, pTemplate,
                                   ulAttributeCount, &attribute);
   if (CKR_OK != *pError) {
     return (ckmkInternalObject *)NULL;
   }
   lk.prime1.type = siUnsignedInteger;
   lk.prime1.data = attribute.data;
   lk.prime1.len = attribute.size;
   *pError = nss_ckmk_GetAttribute(CKA_PRIME_2, pTemplate,
                                   ulAttributeCount, &attribute);
   if (CKR_OK != *pError) {
     return (ckmkInternalObject *)NULL;
   }
   lk.prime2.type = siUnsignedInteger;
   lk.prime2.data = attribute.data;
   lk.prime2.len = attribute.size;
   *pError = nss_ckmk_GetAttribute(CKA_EXPONENT_1, pTemplate,
                                   ulAttributeCount, &attribute);
   if (CKR_OK != *pError) {
     return (ckmkInternalObject *)NULL;
   }
   lk.exponent1.type = siUnsignedInteger;
   lk.exponent1.data = attribute.data;
   lk.exponent1.len = attribute.size;
   *pError = nss_ckmk_GetAttribute(CKA_EXPONENT_2, pTemplate,
                                   ulAttributeCount, &attribute);
   if (CKR_OK != *pError) {
     return (ckmkInternalObject *)NULL;
   }
   lk.exponent2.type = siUnsignedInteger;
   lk.exponent2.data = attribute.data;
   lk.exponent2.len = attribute.size;
   *pError = nss_ckmk_GetAttribute(CKA_COEFFICIENT, pTemplate,
                                   ulAttributeCount, &attribute);
   if (CKR_OK != *pError) {
     return (ckmkInternalObject *)NULL;
   }
   lk.coefficient.type = siUnsignedInteger;
   lk.coefficient.data = attribute.data;
   lk.coefficient.len = attribute.size;
   /* ASN1 Encode the pkcs8 structure... look at softoken to see how this
    * is done... */
   error = ckmk_CreateRSAKeyBlob(&lk, &keyBlob);
   if (CKR_OK != error) {
     goto loser;
   }
   dataRef = CFDataCreate(NULL, (UInt8 *)keyBlob.data, keyBlob.size);
   if (0 == dataRef) {
     *pError = CKR_HOST_MEMORY;
     goto loser;
   }
   *pError == ckmk_GetSafeDefaultKeychain(&targetKeychain);
   if (CKR_OK != *pError) {
     goto loser;
   }
   /* the itemArray that is returned is useless. the item does not
    * is 'not on the key chain' so none of the modify calls work on it.
    * It also has a key that isn't the same key as the one in the actual
    * key chain. In short it isn't the item we want, and it gives us zero
    * information about the item we want, so don't even bother with it...
    */
   macErr = SecKeychainItemImport(dataRef, NULL, &inputFormat, &itemType, 0,
         &keyParams, targetKeychain, NULL);
   if (noErr != macErr) {
     CKMK_MACERR("Import Private Key", macErr);
     *pError = CKR_GENERAL_ERROR;
     goto loser;
   }
   *pError = ckmk_FindImportedKey(targetKeychain,
                                  CSSM_DL_DB_RECORD_PRIVATE_KEY,
                                  &itemRef);
   if (CKR_OK != *pError) {
 #ifdef DEBUG
     fprintf(stderr,"couldn't find key in keychain \n");
 #endif
     goto loser;
   }
   /* set the CKA_ID and  the CKA_LABEL */
   error = nss_ckmk_GetAttribute(CKA_ID, pTemplate,
                                   ulAttributeCount, &keyID);
   if (CKR_OK == error) {
     error = ckmk_updateAttribute(itemRef, kSecKeyLabel,
                               keyID.data, keyID.size, "Modify Key ID");
 #ifdef DEBUG
     itemdump("key id: ", keyID.data, keyID.size, error);
 #endif
   }
   nickname = nss_ckmk_GetStringAttribute(CKA_LABEL, pTemplate,
                                   ulAttributeCount, &error);
   if (nickname) {
     ckmk_updateAttribute(itemRef, kSecKeyPrintName, nickname,
                               strlen(nickname)+1, "Modify Key Label");
   } else {
 #define DEFAULT_NICKNAME "NSS Imported Key"
     ckmk_updateAttribute(itemRef, kSecKeyPrintName, DEFAULT_NICKNAME,
                               sizeof(DEFAULT_NICKNAME), "Modify Key Label");
   }
   io = nss_ckmk_NewInternalObject(CKO_PRIVATE_KEY, itemRef,
                                   CSSM_DL_DB_RECORD_PRIVATE_KEY, pError);
   if ((ckmkInternalObject *)NULL == io) {
     CFRelease(itemRef);
   }
   return io;
 loser:
   /* free the key blob */
   if (keyBlob.data) {
     nss_ZFreeIf(keyBlob.data);
   }
   if (0 != targetKeychain) {
     CFRelease(targetKeychain);
   }
   if (0 != dataRef) {
     CFRelease(dataRef);
   }
   return io;
 }
 NSS_EXTERN NSSCKMDObject *
 nss_ckmk_CreateObject
 (
   NSSCKFWSession *fwSession,
   CK_ATTRIBUTE_PTR pTemplate,
   CK_ULONG ulAttributeCount,
   CK_RV *pError
 )
 {
   CK_OBJECT_CLASS objClass;
   ckmkInternalObject *io;
   CK_BBOOL isToken;
   /*
    * only create token objects
    */
   isToken = nss_ckmk_GetBoolAttribute(CKA_TOKEN, pTemplate,
                                       ulAttributeCount, CK_FALSE);
   if (!isToken) {
     *pError = CKR_ATTRIBUTE_VALUE_INVALID;
     return (NSSCKMDObject *) NULL;
   }
   /*
    * only create keys and certs.
    */
   objClass = nss_ckmk_GetULongAttribute(CKA_CLASS, pTemplate,
                                         ulAttributeCount, pError);
   if (CKR_OK != *pError) {
     return (NSSCKMDObject *) NULL;
   }
 #ifdef notdef
   if (objClass == CKO_PUBLIC_KEY) {
     return CKR_OK; /* fake public key creation, happens as a side effect of
                     * private key creation */
   }
 #endif
   if (objClass == CKO_CERTIFICATE) {
     io = nss_ckmk_CreateCertificate(fwSession, pTemplate,
                                     ulAttributeCount, pError);
   } else if (objClass == CKO_PRIVATE_KEY) {
     io = nss_ckmk_CreatePrivateKey(fwSession, pTemplate,
                                    ulAttributeCount, pError);
   } else {
     *pError = CKR_ATTRIBUTE_VALUE_INVALID;
   }
   if ((ckmkInternalObject *)NULL == io) {
     return (NSSCKMDObject *) NULL;
   }
   return nss_ckmk_CreateMDObject(NULL, io, pError);
 }

The Tor Browser / annotate

security/nss/lib/ckfw/nssmkey/mobject.c@b8a032363ba2 (annotated)

security/nss/lib/ckfw/nssmkey/mobject.c