开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 加密解密 > CA认证 > 查看源码
pk11cert.c
资源名称：nss-3.1.1.tar.gz　[点击查看]
上传用户：lyxiangda
上传日期：2007-01-12
资源大小：3042k
文件大小：69k
源码类别：

CA认证

开发平台：

WINDOWS

pk11cert.c：源码内容
  1. /*
  2.  * The contents of this file are subject to the Mozilla Public
  3.  * License Version 1.1 (the "License"); you may not use this file
  4.  * except in compliance with the License. You may obtain a copy of
  5.  * the License at http://www.mozilla.org/MPL/
  6.  * 
  7.  * Software distributed under the License is distributed on an "AS
  8.  * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
  9.  * implied. See the License for the specific language governing
  10.  * rights and limitations under the License.
  11.  * 
  12.  * The Original Code is the Netscape security libraries.
  13.  * 
  14.  * The Initial Developer of the Original Code is Netscape
  15.  * Communications Corporation.  Portions created by Netscape are 
  16.  * Copyright (C) 1994-2000 Netscape Communications Corporation.  All
  17.  * Rights Reserved.
  18.  * 
  19.  * Contributor(s):
  20.  * 
  21.  * Alternatively, the contents of this file may be used under the
  22.  * terms of the GNU General Public License Version 2 or later (the
  23.  * "GPL"), in which case the provisions of the GPL are applicable 
  24.  * instead of those above.  If you wish to allow use of your 
  25.  * version of this file only under the terms of the GPL and not to
  26.  * allow others to use your version of this file under the MPL,
  27.  * indicate your decision by deleting the provisions above and
  28.  * replace them with the notice and other provisions required by
  29.  * the GPL.  If you do not delete the provisions above, a recipient
  30.  * may use your version of this file under either the MPL or the
  31.  * GPL.
  32.  */
  33. /*
  34.  * This file implements the Symkey wrapper and the PKCS context
  35.  * Interfaces.
  36.  */
  37. #include "seccomon.h"
  38. #include "secmod.h"
  39. #include "prlock.h"
  40. #include "secmodi.h"
  41. #include "pkcs11.h"
  42. #include "pk11func.h"
  43. #include "cert.h"
  44. #include "secitem.h"
  45. #include "key.h"
  46. #include "hasht.h"
  47. #include "secoid.h"
  48. #include "pkcs7t.h"
  49. #include "cmsreclist.h"
  51. #include "certdb.h"
  52. #include "secerr.h"
  53. #include "sslerr.h"
  55. #define NSSCKT_H /* we included pkcs11t.h, so block ckt.h from including nssckt.h */
  56. #include "ckt.h"
  58. #define PK11_SEARCH_CHUNKSIZE 10
  60. CK_OBJECT_HANDLE
  61. pk11_FindPubKeyByAnyCert(CERTCertificate *cert, PK11SlotInfo **slot, void *wincx);
  63. /*
  64.  * build a cert nickname based on the token name and the label of the 
  65.  * certificate If the label in NULL, build a label based on the ID.
  66.  */
  67. static int toHex(int x) { return (x < 10) ? (x+'0') : (x+'a'-10); }
  68. #define MAX_CERT_ID 4
  69. #define DEFAULT_STRING "Cert ID "
  70. static char *
  71. pk11_buildNickname(PK11SlotInfo *slot,CK_ATTRIBUTE *cert_label,
  72. CK_ATTRIBUTE *key_label, CK_ATTRIBUTE *cert_id)
  73. {
  74.     int prefixLen = PORT_Strlen(slot->token_name);
  75.     int suffixLen = 0;
  76.     char *suffix = NULL;
  77.     char buildNew[sizeof(DEFAULT_STRING)+MAX_CERT_ID*2];
  78.     char *next,*nickname;
  80.     if (slot->isInternal) {
  81. return NULL;
  82.     }
  84.     if ((cert_label) && (cert_label->pValue)) {
  85. suffixLen = cert_label->ulValueLen;
  86. suffix = (char*)cert_label->pValue;
  87.     } else if (key_label && (key_label->pValue)) {
  88. suffixLen = key_label->ulValueLen;
  89. suffix = (char*)key_label->pValue;
  90.     } else if ((cert_id) && cert_id->pValue) {
  91. int i,first = cert_id->ulValueLen - MAX_CERT_ID;
  92. int offset = sizeof(DEFAULT_STRING);
  93. char *idValue = (char *)cert_id->pValue;
  95. PORT_Memcpy(buildNew,DEFAULT_STRING,sizeof(DEFAULT_STRING)-1);
  96. next = buildNew + offset;
  97. if (first < 0) first = 0;
  98. for (i=first; i < (int) cert_id->ulValueLen; i++) {
  99. *next++ = toHex((idValue[i] >> 4) & 0xf);
  100. *next++ = toHex(idValue[i] & 0xf);
  101. }
  102. *next++ = 0;
  103. suffix = buildNew;
  104. suffixLen = PORT_Strlen(buildNew);
  105.     } else {
  106. PORT_SetError( SEC_ERROR_LIBRARY_FAILURE );
  107. return NULL;
  108.     }
  110.     next = nickname = (char *)PORT_Alloc(prefixLen+1+suffixLen+1);
  111.     if (nickname == NULL) return NULL;
  113.     PORT_Memcpy(next,slot->token_name,prefixLen);
  114.     next += prefixLen;
  115.     *next++ = ':';
  116.     PORT_Memcpy(next,suffix,suffixLen);
  117.     next += suffixLen;
  118.     *next++ = 0;
  119.     return nickname;
  120. }
  122. /*
  123.  * return the object handle that matches the template
  124.  */
  125. CK_OBJECT_HANDLE
  126. pk11_FindObjectByTemplate(PK11SlotInfo *slot,CK_ATTRIBUTE *theTemplate,int tsize)
  127. {
  128.     CK_OBJECT_HANDLE object;
  129.     CK_RV crv;
  130.     CK_ULONG objectCount;
  132.     /*
  133.      * issue the find
  134.      */
  135.     PK11_EnterSlotMonitor(slot);
  136.     crv=PK11_GETTAB(slot)->C_FindObjectsInit(slot->session, theTemplate, tsize);
  137.     if (crv != CKR_OK) {
  138.         PK11_ExitSlotMonitor(slot);
  139. PORT_SetError( PK11_MapError(crv) );
  140. return CK_INVALID_KEY;
  141.     }
  143.     crv=PK11_GETTAB(slot)->C_FindObjects(slot->session,&object,1,&objectCount);
  144.     PK11_GETTAB(slot)->C_FindObjectsFinal(slot->session);
  145.     PK11_ExitSlotMonitor(slot);
  146.     if ((crv != CKR_OK) || (objectCount < 1)) {
  147. /* shouldn't use SSL_ERROR... here */
  148. PORT_SetError( crv != CKR_OK ? PK11_MapError(crv) :
  149.   SSL_ERROR_NO_CERTIFICATE);
  150. return CK_INVALID_KEY;
  151.     }
  153.     /* blow up if the PKCS #11 module returns us and invalid object handle */
  154.     PORT_Assert(object != CK_INVALID_KEY);
  155.     return object;
  156. } 
  158. /*
  159.  * return all the object handles that matches the template
  160.  */
  161. CK_OBJECT_HANDLE *
  162. pk11_FindObjectsByTemplate(PK11SlotInfo *slot,
  163. CK_ATTRIBUTE *findTemplate,int findCount,int *object_count) {
  164.     CK_OBJECT_HANDLE *objID = NULL;
  165.     CK_ULONG returned_count = 0;
  166.     CK_RV crv;
  169.     PK11_EnterSlotMonitor(slot);
  170.     crv = PK11_GETTAB(slot)->C_FindObjectsInit(slot->session, findTemplate, 
  171. findCount);
  172.     if (crv != CKR_OK) {
  173. PK11_ExitSlotMonitor(slot);
  174. PORT_SetError( PK11_MapError(crv) );
  175. *object_count = -1;
  176. return NULL;
  177.     }
  180.     /*
  181.      * collect all the Matching Objects
  182.      */
  183.     do {
  184. CK_OBJECT_HANDLE *oldObjID = objID;
  186. if (objID == NULL) {
  187.          objID = (CK_OBJECT_HANDLE *) PORT_Alloc(sizeof(CK_OBJECT_HANDLE)*
  188. (*object_count+ PK11_SEARCH_CHUNKSIZE));
  189. } else {
  190.          objID = (CK_OBJECT_HANDLE *) PORT_Realloc(objID,
  191. sizeof(CK_OBJECT_HANDLE)*(*object_count+PK11_SEARCH_CHUNKSIZE));
  192. }
  194. if (objID == NULL) {
  195.     if (oldObjID) PORT_Free(oldObjID);
  196.     break;
  197. }
  198.      crv = PK11_GETTAB(slot)->C_FindObjects(slot->session,
  199. &objID[*object_count],PK11_SEARCH_CHUNKSIZE,&returned_count);
  200. if (crv != CKR_OK) {
  201.     PORT_SetError( PK11_MapError(crv) );
  202.     PORT_Free(objID);
  203.     objID = NULL;
  204.     break;
  205.      }
  206. *object_count += returned_count;
  207.     } while (returned_count == PK11_SEARCH_CHUNKSIZE);
  209.     PK11_GETTAB(slot)->C_FindObjectsFinal(slot->session);
  210.     PK11_ExitSlotMonitor(slot);
  212.     if (objID && (*object_count == 0)) {
  213. PORT_Free(objID);
  214. return NULL;
  215.     }
  216.     if (objID == NULL) *object_count = -1;
  217.     return objID;
  218. }
  219. /*
  220.  * given a PKCS #11 object, match it's peer based on the KeyID. searchID
  221.  * is typically a privateKey or a certificate while the peer is the opposite
  222.  */
  223. CK_OBJECT_HANDLE
  224. PK11_MatchItem(PK11SlotInfo *slot, CK_OBJECT_HANDLE searchID,
  225.   CK_OBJECT_CLASS matchclass)
  226. {
  227.     CK_ATTRIBUTE theTemplate[] = {
  228. { CKA_ID, NULL, 0 },
  229. { CKA_CLASS, NULL, 0 }
  230.     };
  231.     /* if you change the array, change the variable below as well */
  232.     CK_ATTRIBUTE *keyclass = &theTemplate[1];
  233.     int tsize = sizeof(theTemplate)/sizeof(theTemplate[0]);
  234.     /* if you change the array, change the variable below as well */
  235.     CK_OBJECT_HANDLE peerID;
  236.     CK_OBJECT_HANDLE parent;
  237.     PRArenaPool *arena;
  238.     CK_RV crv;
  240.     /* now we need to create space for the public key */
  241.     arena = PORT_NewArena( DER_DEFAULT_CHUNKSIZE);
  242.     if (arena == NULL) return CK_INVALID_KEY;
  244.     crv = PK11_GetAttributes(arena,slot,searchID,theTemplate,tsize);
  245.     if (crv != CKR_OK) {
  246. PORT_FreeArena(arena,PR_FALSE);
  247. PORT_SetError( PK11_MapError(crv) );
  248. return CK_INVALID_KEY;
  249.     }
  251.     /*
  252.      * issue the find
  253.      */
  254.     parent = *(CK_OBJECT_CLASS *)(keyclass->pValue);
  255.     *(CK_OBJECT_CLASS *)(keyclass->pValue) = matchclass;
  257.     peerID = pk11_FindObjectByTemplate(slot,theTemplate,tsize);
  258.     PORT_FreeArena(arena,PR_FALSE);
  260.     return peerID;
  261. }
  263. PRBool
  264. PK11_IsUserCert(PK11SlotInfo *slot, CERTCertificate *cert,
  265. CK_OBJECT_HANDLE certID)
  266. {
  267.     CK_OBJECT_CLASS theClass;
  269.     if (slot == NULL) return PR_FALSE;
  270.     if (cert == NULL) return PR_FALSE;
  272.     theClass = CKO_PRIVATE_KEY;
  273.     if (!PK11_IsLoggedIn(slot,NULL) && PK11_NeedLogin(slot)) {
  274. theClass = CKO_PUBLIC_KEY;
  275.     }
  276.     if (PK11_MatchItem(slot, certID , theClass) != CK_INVALID_KEY) {
  277. return PR_TRUE;
  278.     }
  280.    if (theClass == CKO_PUBLIC_KEY) {
  281. SECKEYPublicKey *pubKey= CERT_ExtractPublicKey(cert);
  282. CK_ATTRIBUTE theTemplate;
  284. if (pubKey == NULL) {
  285.    return PR_FALSE;
  286. }
  288. PK11_SETATTRS(&theTemplate,0,NULL,0);
  289. switch (pubKey->keyType) {
  290. case rsaKey:
  291.     PK11_SETATTRS(&theTemplate,CKA_MODULUS, pubKey->u.rsa.modulus.data,
  292. pubKey->u.rsa.modulus.len);
  293.     break;
  294. case dsaKey:
  295.     PK11_SETATTRS(&theTemplate,CKA_VALUE, pubKey->u.dsa.publicValue.data,
  296. pubKey->u.dsa.publicValue.len);
  297. case dhKey:
  298.     PK11_SETATTRS(&theTemplate,CKA_VALUE, pubKey->u.dh.publicValue.data,
  299. pubKey->u.dh.publicValue.len);
  300.     break;
  301. }
  303. if (theTemplate.ulValueLen == 0) {
  304.     SECKEY_DestroyPublicKey(pubKey);
  305.     return PR_FALSE;
  306. }
  307. pk11_SignedToUnsigned(&theTemplate);
  308. if (pk11_FindObjectByTemplate(slot,&theTemplate,1) != CK_INVALID_KEY) {
  309.     SECKEY_DestroyPublicKey(pubKey);
  310.     return PR_TRUE;
  311. }
  312. SECKEY_DestroyPublicKey(pubKey);
  313.     }
  314.     return PR_FALSE;
  315. }
  317. /*
  318.  * Check out if a cert has ID of zero. This is a magic ID that tells
  319.  * NSS that this cert may be an automagically trusted cert.
  320.  * The Cert has to be self signed as well. That check is done elsewhere.
  321.  *  
  322.  */
  323. PRBool
  324. pk11_isID0(PK11SlotInfo *slot, CK_OBJECT_HANDLE certID)
  325. {
  326.     CK_ATTRIBUTE keyID = {CKA_ID, NULL, 0};
  327.     PRBool isZero = PR_FALSE;
  328.     int i;
  329.     CK_RV crv;
  332.     crv = PK11_GetAttributes(NULL,slot,certID,&keyID,1);
  333.     if (crv != CKR_OK) {
  334. return isZero;
  335.     }
  337.     if (keyID.ulValueLen != 0) {
  338. char *value = (char *)keyID.pValue;
  339. isZero = PR_TRUE; /* ID exists, may be zero */
  340. for (i=0; i < (int) keyID.ulValueLen; i++) {
  341.     if (value[i] != 0) {
  342. isZero = PR_FALSE; /* nope */
  343. break;
  344.     }
  345. }
  346.     }
  347.     PORT_Free(keyID.pValue);
  348.     return isZero;
  350. }
  351.      
  352. CERTCertificate
  353. *pk11_fastCert(PK11SlotInfo *slot, CK_OBJECT_HANDLE certID, 
  354. CK_ATTRIBUTE *privateLabel, char **nickptr)
  355. {
  356.     CK_ATTRIBUTE certTemp[] = {
  357. { CKA_ID, NULL, 0 },
  358. { CKA_VALUE, NULL, 0 },
  359. { CKA_LABEL, NULL, 0 }
  360.     };
  361.     CK_ATTRIBUTE *id = &certTemp[0];
  362.     CK_ATTRIBUTE *certDER = &certTemp[1];
  363.     CK_ATTRIBUTE *label = &certTemp[2];
  364.     SECItem derCert;
  365.     int csize = sizeof(certTemp)/sizeof(certTemp[0]);
  366.     PRArenaPool *arena;
  367.     char *nickname;
  368.     CERTCertificate *cert;
  369.     CK_RV crv;
  371.     arena = PORT_NewArena( DER_DEFAULT_CHUNKSIZE);
  372.     if (arena == NULL) return NULL;
  373.     /*
  374.      * grab the der encoding
  375.      */
  376.     crv = PK11_GetAttributes(arena,slot,certID,certTemp,csize);
  377.     if (crv != CKR_OK) {
  378. PORT_FreeArena(arena,PR_FALSE);
  379. PORT_SetError( PK11_MapError(crv) );
  380. return NULL;
  381.     }
  383.     /*
  384.      * build a certificate out of it
  385.      */
  386.     derCert.data = (unsigned char*)certDER->pValue;
  387.     derCert.len = certDER->ulValueLen;
  389.     /* figure out the nickname.... */
  390.     nickname = pk11_buildNickname(slot,label,privateLabel,id);
  391.     cert = CERT_NewTempCertificate(CERT_GetDefaultCertDB(), &derCert, nickname,
  392. PR_FALSE, PR_TRUE);
  393.     if (nickptr) {
  394. *nickptr = nickname;
  395.     } else {
  396. if (nickname) PORT_Free(nickname);
  397.     }
  398.     PORT_FreeArena(arena,PR_FALSE);
  399.     return cert;
  400. }
  402. CK_TRUST
  403. pk11_GetTrustField(PK11SlotInfo *slot, PRArenaPool *arena, 
  404.                    CK_OBJECT_HANDLE id, CK_ATTRIBUTE_TYPE type)
  405. {
  406.   CK_TRUST rv = 0;
  407.   SECItem item;
  409.   item.data = NULL;
  410.   item.len = 0;
  412.   if( SECSuccess == PK11_ReadAttribute(slot, id, type, arena, &item) ) {
  413.     PORT_Assert(item.len == sizeof(CK_TRUST));
  414.     PORT_Memcpy(&rv, item.data, sizeof(CK_TRUST));
  415.     /* Damn, is there an endian problem here? */
  416.     return rv;
  417.   }
  419.   return 0;
  420. }
  422. PRBool
  423. pk11_HandleTrustObject(PK11SlotInfo *slot, CERTCertificate *cert, CERTCertTrust *trust)
  424. {
  425.   PRArenaPool *arena;
  427.   CK_ATTRIBUTE tobjTemplate[] = {
  428.     { CKA_CLASS, NULL, 0 },
  429.     { CKA_CERT_SHA1_HASH, NULL, 0 },
  430.   };
  432.   CK_OBJECT_CLASS tobjc = CKO_NETSCAPE_TRUST;
  433.   CK_OBJECT_HANDLE tobjID;
  434.   unsigned char sha1_hash[SHA1_LENGTH];
  436.   CK_TRUST digitalSignature, nonRepudiation, keyEncipherment, dataEncipherment,
  437.     keyAgreement, keyCertSign, crlSign, serverAuth, clientAuth, codeSigning,
  438.     emailProtection, ipsecEndSystem, ipsecTunnel, ipsecUser, timeStamping;
  440.   SECItem item;
  442.   PK11_HashBuf(SEC_OID_SHA1, sha1_hash, cert->derCert.data, cert->derCert.len);
  444.   PK11_SETATTRS(&tobjTemplate[0], CKA_CLASS, &tobjc, sizeof(tobjc));
  445.   PK11_SETATTRS(&tobjTemplate[1], CKA_CERT_SHA1_HASH, sha1_hash, 
  446.                 SHA1_LENGTH);
  448.   tobjID = pk11_FindObjectByTemplate(slot, tobjTemplate, 
  449.                                      sizeof(tobjTemplate)/sizeof(tobjTemplate[0]));
  450.   if( CK_INVALID_KEY == tobjID ) {
  451.     return PR_FALSE;
  452.   }
  454.   arena = PORT_NewArena(DER_DEFAULT_CHUNKSIZE);
  455.   if( NULL == arena ) return PR_FALSE;
  457.   /* Unfortunately, it seems that PK11_GetAttributes doesn't deal
  458.    * well with nonexistant attributes.  I guess we have to check 
  459.    * the trust info fields one at a time.
  460.    */
  462.   /* We could verify CKA_CERT_HASH here */
  464.   /* We could verify CKA_EXPIRES here */
  466.   /* "Usage" trust information */
  467.   /* digitalSignature = pk11_GetTrustField(slot, arena, tobjID, CKA_TRUST_DIGITAL_SIGNATURE); */
  468.   /* nonRepudiation   = pk11_GetTrustField(slot, arena, tobjID, CKA_TRUST_NON_REPUDIATION); */
  469.   /* keyEncipherment  = pk11_GetTrustField(slot, arena, tobjID, CKA_TRUST_KEY_ENCIPHERMENT); */
  470.   /* dataEncipherment = pk11_GetTrustField(slot, arena, tobjID, CKA_TRUST_DATA_ENCIPHERMENT); */
  471.   /* keyAgreement     = pk11_GetTrustField(slot, arena, tobjID, CKA_TRUST_KEY_AGREEMENT); */
  472.   /* keyCertSign      = pk11_GetTrustField(slot, arena, tobjID, CKA_TRUST_KEY_CERT_SIGN); */
  473.   /* crlSign          = pk11_GetTrustField(slot, arena, tobjID, CKA_TRUST_CRL_SIGN); */
  475.   /* "Purpose" trust information */
  476.   serverAuth       = pk11_GetTrustField(slot, arena, tobjID, CKA_TRUST_SERVER_AUTH);
  477.   /* clientAuth       = pk11_GetTrustField(slot, arena, tobjID, CKA_TRUST_CLIENT_AUTH); */
  478.   codeSigning      = pk11_GetTrustField(slot, arena, tobjID, CKA_TRUST_CODE_SIGNING);
  479.   emailProtection  = pk11_GetTrustField(slot, arena, tobjID, CKA_TRUST_EMAIL_PROTECTION);
  480.   /* ipsecEndSystem   = pk11_GetTrustField(slot, arena, tobjID, CKA_TRUST_IPSEC_END_SYSTEM); */
  481.   /* ipsecTunnel      = pk11_GetTrustField(slot, arena, tobjID, CKA_TRUST_IPSEC_TUNNEL); */
  482.   /* ipsecUser        = pk11_GetTrustField(slot, arena, tobjID, CKA_TRUST_IPSEC_USER); */
  483.   /* timeStamping     = pk11_GetTrustField(slot, arena, tobjID, CKA_TRUST_TIME_STAMPING); */
  485.   /* Here's where the fun logic happens.  We have to map back from the key usage,
  486.    * extended key usage, purpose, and possibly other trust values into the old
  487.    * trust-flags bits.
  488.    */
  490.   /* First implementation: keep it simple for testing.  We can study what other
  491.    * mappings would be appropriate and add them later.. fgmr 20000724 */
  493.   if( serverAuth & CKT_NETSCAPE_TRUSTED ) {
  494.     trust->sslFlags |= CERTDB_VALID_PEER | CERTDB_TRUSTED;
  495.   }
  497.   if( serverAuth & CKT_NETSCAPE_TRUSTED_DELEGATOR ) {
  498.     trust->sslFlags |= CERTDB_VALID_CA | CERTDB_TRUSTED_CA | CERTDB_NS_TRUSTED_CA;
  499.   }
  501.   if( emailProtection & CKT_NETSCAPE_TRUSTED ) {
  502.     trust->emailFlags |= CERTDB_VALID_PEER | CERTDB_TRUSTED;
  503.   }
  505.   if( emailProtection & CKT_NETSCAPE_TRUSTED_DELEGATOR ) {
  506.     trust->emailFlags |= CERTDB_VALID_CA | CERTDB_TRUSTED_CA | CERTDB_NS_TRUSTED_CA;
  507.   }
  509.   if( codeSigning & CKT_NETSCAPE_TRUSTED ) {
  510.     trust->objectSigningFlags |= CERTDB_VALID_PEER | CERTDB_TRUSTED;
  511.   }
  513.   if( codeSigning & CKT_NETSCAPE_TRUSTED_DELEGATOR ) {
  514.     trust->objectSigningFlags |= CERTDB_VALID_CA | CERTDB_TRUSTED_CA | CERTDB_NS_TRUSTED_CA;
  515.   }
  517.   /* There's certainly a lot more logic that can go here.. */
  519.   return PR_TRUE;
  520. }
  522. /*
  523.  * Build an CERTCertificate structure from a PKCS#11 object ID.... certID
  524.  * Must be a CertObject. This code does not explicitly checks that.
  525.  */
  526. CERTCertificate *
  527. PK11_MakeCertFromHandle(PK11SlotInfo *slot,CK_OBJECT_HANDLE certID,
  528. CK_ATTRIBUTE *privateLabel)
  529. {
  530.     char * nickname = NULL;
  531.     CERTCertificate *cert = NULL;
  532.     CERTCertTrust *trust;
  533.     PRBool isFortezzaRootCA = PR_FALSE;
  534.     PRBool swapNickname = PR_FALSE;
  536.     cert = pk11_fastCert(slot,certID,privateLabel, &nickname);
  537.     if (cert == NULL) goto loser;
  539.     if (nickname) {
  540. if (cert->nickname != NULL) {
  541. cert->dbnickname = cert->nickname;
  542. } 
  543. cert->nickname = PORT_ArenaStrdup(cert->arena,nickname);
  544. PORT_Free(nickname);
  545. nickname = NULL;
  546. swapNickname = PR_TRUE;
  547.     }
  549.     /* remember where this cert came from.... If we have just looked
  550.      * it up from the database and it already has a slot, don't add a new
  551.      * one. */
  552.     if (cert->slot == NULL) {
  553. cert->slot = PK11_ReferenceSlot(slot);
  554. cert->pkcs11ID = certID;
  555. cert->ownSlot = PR_TRUE;
  556.     }
  558.     if (cert->trust == NULL) {
  559. unsigned int type;
  561. trust = 
  562.   (CERTCertTrust*)PORT_ArenaAlloc(cert->arena, sizeof(CERTCertTrust));
  563. if (trust == NULL) goto loser;
  565. PORT_Memset(trust,0, sizeof(CERTCertTrust));
  566. cert->trust = trust;
  567. /* build some cert trust flags */
  569.     /* First, see if there's a trust object for this cert. */
  570.     /* For the first implementation, we'll just check this slot
  571.      * and worry about overriding trust info later. */
  572.     if( pk11_HandleTrustObject(slot, cert, trust) ) {
  573.       ;
  574.     } else
  576. if (CERT_IsCACert(cert, &type)) {
  577.     unsigned int trustflags = CERTDB_VALID_CA;
  578.    
  579.     /* Allow PKCS #11 modules to give us trusted CA's. We only accept
  580.      * valid CA's which are self-signed here. They must have an object
  581.      * ID of '0'.  */ 
  582.     if (pk11_isID0(slot,certID) && 
  583. SECITEM_CompareItem(&cert->derSubject,&cert->derIssuer)
  584.    == SECEqual) {
  585. trustflags |= CERTDB_TRUSTED_CA;
  586. /* is the slot a fortezza card? allow the user or
  587.  * admin to turn on objectSigning, but don't turn
  588.  * full trust on explicitly */
  589. if (PK11_DoesMechanism(slot,CKM_KEA_KEY_DERIVE)) {
  590.     trust->objectSigningFlags |= CERTDB_VALID_CA;
  591.     isFortezzaRootCA = PR_TRUE;
  592. }
  593.     }
  594.     if ((type & NS_CERT_TYPE_SSL_CA) == NS_CERT_TYPE_SSL_CA) {
  595. trust->sslFlags |= trustflags;
  596.     }
  597.     if ((type & NS_CERT_TYPE_EMAIL_CA) == NS_CERT_TYPE_EMAIL_CA) {
  598. trust->emailFlags |= trustflags;
  599.     }
  600.     if ((type & NS_CERT_TYPE_OBJECT_SIGNING_CA) 
  601. == NS_CERT_TYPE_OBJECT_SIGNING_CA) {
  602. trust->objectSigningFlags |= trustflags;
  603.     }
  604. }
  605.     } else  {
  606. trust = cert->trust;
  607.     }
  609.     if (PK11_IsUserCert(slot,cert,certID)) {
  610. trust->sslFlags |= CERTDB_USER;
  611. trust->emailFlags |= CERTDB_USER;
  612. /*    trust->objectSigningFlags |= CERTDB_USER; */
  613.     }
  616.     /* if fortezza, write the root cert to the DB */
  617.     if ((isFortezzaRootCA) && (!cert->isperm)) {
  618. char *name = NULL;
  619. if (swapNickname) {
  620.     nickname = cert->nickname;
  621.     cert->nickname = cert->dbnickname;
  622. }
  623. if (cert->nickname) {
  624.      name = PORT_Strdup(cert->nickname);
  625. }
  626. if (name == NULL) name = CERT_MakeCANickname(cert);
  627. CERT_AddTempCertToPerm(cert,name,cert->trust);
  628. if (name) PORT_Free(name);
  629. if (swapNickname) {
  630.     if (cert->nickname != NULL) {
  631. cert->dbnickname = cert->nickname;
  632.     }
  633.     cert->nickname = PORT_ArenaStrdup(cert->arena,nickname);
  634. }
  636.     }
  638.     return cert;
  640. loser:
  641.     if (nickname) PORT_Free(nickname);
  642.     if (cert) CERT_DestroyCertificate(cert);
  643.     return NULL;
  644. }
  647. /*
  648.  * Build get a certificate from a private key
  649.  */
  650. CERTCertificate *
  651. PK11_GetCertFromPrivateKey(SECKEYPrivateKey *privKey)
  652. {
  653.     PK11SlotInfo *slot = privKey->pkcs11Slot;
  654.     CK_OBJECT_HANDLE certID = 
  655. PK11_MatchItem(slot,privKey->pkcs11ID,CKO_CERTIFICATE);
  656.     SECStatus rv;
  657.     CERTCertificate *cert;
  659.     if (certID == CK_INVALID_KEY) {
  660. /* couldn't find it on the card, look in our data base */
  661. SECItem derSubject;
  663. rv = PK11_ReadAttribute(slot, privKey->pkcs11ID, CKA_SUBJECT, NULL,
  664. &derSubject);
  665. if (rv != SECSuccess) {
  666.     PORT_SetError(SSL_ERROR_NO_CERTIFICATE);
  667.     return NULL;
  668. }
  670. cert = CERT_FindCertByName(CERT_GetDefaultCertDB(),&derSubject);
  671. PORT_Free(derSubject.data);
  672. return cert;
  673.     }
  674.     cert = PK11_MakeCertFromHandle(slot,certID,NULL);
  675.     return (cert);
  677. }
  679. /*
  680.  * destroy a private key if there are no matching certs.
  681.  * this function also frees the privKey structure.
  682.  */
  683. SECStatus
  684. PK11_DeleteTokenPrivateKey(SECKEYPrivateKey *privKey)
  685. {
  686.     CERTCertificate *cert=PK11_GetCertFromPrivateKey(privKey);
  688.     /* found a cert matching the private key?. */
  689.     if (cert != NULL) {
  690. /* yes, don't delete the key */
  691.         CERT_DestroyCertificate(cert);
  692. SECKEY_DestroyPrivateKey(privKey);
  693. return SECWouldBlock;
  694.     }
  695.     /* now, then it's safe for the key to go away */
  696.     PK11_DestroyTokenObject(privKey->pkcs11Slot,privKey->pkcs11ID);
  697.     SECKEY_DestroyPrivateKey(privKey);
  698.     return SECSuccess;
  699. }
  702. /*
  703.  * delete a cert and it's private key (if no other certs are pointing to the
  704.  * private key.
  705.  */
  706. SECStatus
  707. PK11_DeleteTokenCertAndKey(CERTCertificate *cert,void *wincx)
  708. {
  709.     SECKEYPrivateKey *privKey = PK11_FindKeyByAnyCert(cert,wincx);
  710.     CK_OBJECT_HANDLE pubKey;
  711.     PK11SlotInfo *slot = NULL;
  713.     pubKey = pk11_FindPubKeyByAnyCert(cert, &slot, wincx);
  714.     if (privKey) {
  715.      PK11_DestroyTokenObject(cert->slot,cert->pkcs11ID);
  716. PK11_DeleteTokenPrivateKey(privKey);
  717.     }
  718.     if ((pubKey != CK_INVALID_KEY) && (slot != NULL)) { 
  719.      PK11_DestroyTokenObject(slot,pubKey);
  720.         PK11_FreeSlot(slot);
  721.     }
  722.     return SECSuccess;
  723. }
  725. /*
  726.  * count the number of objects that match the template.
  727.  */
  728. int
  729. PK11_NumberObjectsFor(PK11SlotInfo *slot, CK_ATTRIBUTE *findTemplate, 
  730. int templateCount)
  731. {
  732.     CK_OBJECT_HANDLE objID[PK11_SEARCH_CHUNKSIZE];
  733.     int object_count = 0;
  734.     CK_ULONG returned_count = 0;
  735.     CK_RV crv;
  737.     PK11_EnterSlotMonitor(slot);
  738.     crv = PK11_GETTAB(slot)->C_FindObjectsInit(slot->session,
  739. findTemplate, templateCount);
  740.     if (crv != CKR_OK) {
  741.         PK11_ExitSlotMonitor(slot);
  742. PORT_SetError( PK11_MapError(crv) );
  743. return 0;
  744.     }
  746.     /*
  747.      * collect all the Matching Objects
  748.      */
  749.     do {
  750.      crv = PK11_GETTAB(slot)->C_FindObjects(slot->session,
  751. objID,PK11_SEARCH_CHUNKSIZE,&returned_count);
  752. if (crv != CKR_OK) {
  753.     PORT_SetError( PK11_MapError(crv) );
  754.     break;
  755.      }
  756. object_count += returned_count;
  757.     } while (returned_count == PK11_SEARCH_CHUNKSIZE);
  759.     PK11_GETTAB(slot)->C_FindObjectsFinal(slot->session);
  760.     PK11_ExitSlotMonitor(slot);
  761.     return object_count;
  762. }
  764. /*
  765.  * cert callback structure
  766.  */
  767. typedef struct pk11DoCertCallbackStr {
  768. SECStatus(* callback)(PK11SlotInfo *slot, CERTCertificate*, void *);
  769. SECStatus(* noslotcallback)(CERTCertificate*, void *);
  770. void *callbackArg;
  771. } pk11DoCertCallback;
  773. /*
  774.  * callback to map object handles to certificate structures.
  775.  */
  776. SECStatus
  777. pk11_DoCerts(PK11SlotInfo *slot, CK_OBJECT_HANDLE certID, void *arg)
  778. {
  779.     CERTCertificate *cert;
  780.     pk11DoCertCallback *certcb = (pk11DoCertCallback *) arg;
  782.     cert = PK11_MakeCertFromHandle(slot, certID, NULL);
  784.     if (cert == NULL) {
  785. return SECFailure;
  786.     }
  788.     if (certcb ) {
  789. if (certcb->callback) {
  790.     (*certcb->callback)(slot, cert, certcb->callbackArg);
  791. }
  792. if (certcb->noslotcallback) {
  793.     (*certcb->noslotcallback)(cert, certcb->callbackArg);
  794. }
  795.     }
  797.     CERT_DestroyCertificate(cert);
  798.     
  799.     return SECSuccess;
  800. }
  803. /*
  804.  * key call back structure.
  805.  */
  806. typedef struct pk11KeyCallbackStr {
  807. SECStatus (* callback)(SECKEYPrivateKey *,void *);
  808. void *callbackArg;
  809. void *wincx;
  810. } pk11KeyCallback;
  812. /*
  813.  * callback to map Object Handles to Private Keys;
  814.  */
  815. SECStatus
  816. pk11_DoKeys(PK11SlotInfo *slot, CK_OBJECT_HANDLE keyHandle, void *arg)
  817. {
  818.     SECStatus rv = SECSuccess;
  819.     SECKEYPrivateKey *privKey;
  820.     pk11KeyCallback *keycb = (pk11KeyCallback *) arg;
  822.     privKey = PK11_MakePrivKey(slot,nullKey,PR_TRUE,keyHandle,keycb->wincx);
  824.     if (privKey == NULL) {
  825. return SECFailure;
  826.     }
  828.     if (keycb && (keycb->callback)) {
  829. rv = (*keycb->callback)(privKey,keycb->callbackArg);
  830.     }
  832.     SECKEY_DestroyPrivateKey(privKey);     
  833.     return rv;
  834. }
  837. /* Traverse slots callback */
  838. typedef struct pk11TraverseSlotStr {
  839.     SECStatus (*callback)(PK11SlotInfo *,CK_OBJECT_HANDLE, void *);
  840.     void *callbackArg;
  841.     CK_ATTRIBUTE *findTemplate;
  842.     int templateCount;
  843. } pk11TraverseSlotCert;
  845. /*
  846.  * Extract all the certs on a card from a slot.
  847.  */
  848. SECStatus
  849. PK11_TraverseSlot(PK11SlotInfo *slot, void *arg)
  850. {
  851.     int i;
  852.     CK_OBJECT_HANDLE *objID = NULL;
  853.     int object_count = 0;
  854.     CK_ULONG returned_count = 0;
  855.     pk11TraverseSlotCert *slotcb = (pk11TraverseSlotCert *) arg;
  857.     objID = pk11_FindObjectsByTemplate(slot,slotcb->findTemplate,
  858. slotcb->templateCount,&object_count);
  860.     /*Actually this isn't a failure... there just were no objs to be found*/
  861.     if (object_count == 0) {
  862. return SECSuccess;
  863.     }
  865.     if (objID == NULL) {
  866. return SECFailure;
  867.     }
  869.     for (i=0; i < object_count; i++) {
  870. (*slotcb->callback)(slot,objID[i],slotcb->callbackArg);
  871.     }
  872.     PORT_Free(objID);
  873.     return SECSuccess;
  874. }
  876. typedef struct pk11CertCallbackStr {
  877. SECStatus(* callback)(CERTCertificate*,SECItem *,void *);
  878. void *callbackArg;
  879. } pk11CertCallback;
  881. static SECStatus
  882. pk11_SaveCert(PK11SlotInfo *slot, CERTCertificate *cert, void *arg)
  883. {
  884.     pk11CertCallback *certcb = (pk11CertCallback *)arg;
  885.     SECStatus rv = SECSuccess;
  887.     if (slot->cert_count == slot->array_size) return CKR_OK;
  889.     slot->cert_array[slot->cert_count] = CERT_DupCertificate(cert);
  890.     if (slot->cert_array[slot->cert_count] == NULL) {
  891. return SECFailure;
  892.     }
  893.     /* now the slot has a hold of the cert, free the slot's element in the
  894.      * cert.. */
  895.     if (cert->ownSlot && (slot == cert->slot)) {
  896.         PK11_FreeSlot(cert->slot);
  897. cert->ownSlot = PR_FALSE;
  898.     }
  899.     slot->cert_count++;
  901.     if (certcb->callback) {
  902. rv = (*certcb->callback)(cert, NULL, certcb->callbackArg);
  903.     }
  904.     return rv;
  905. }
  908. /* free the slots */
  909. void
  910. PK11_FreeSlotCerts(PK11SlotInfo *slot)
  911. {
  912.     int i;
  914.     if (slot->cert_array) {
  915. for (i=0; i < slot->cert_count; i++) {
  916.     /* if we point the cert on our array, the cert doesn't have a
  917.      * reference to use (otherwise you would never be able to free
  918.      * a slot :) */
  919.     if ((slot->cert_array[i]->slot == slot) && 
  920. (!slot->cert_array[i]->ownSlot)) {
  921.  slot->cert_array[i]->slot = NULL;
  922.     }
  923.     CERT_DestroyCertificate(slot->cert_array[i]);
  924. }
  925. PORT_Free(slot->cert_array);
  926. slot->cert_array = NULL;
  927. slot->cert_count = 0;
  928.     }
  929.     return;
  930. }
  932. /*
  933.  *  Update PQG parameters for all the certs on a slot.
  934.  */
  935. static SECStatus
  936. pk11_UpdateSlotPQG(PK11SlotInfo *slot)
  937. {
  938.     int i, tag;
  939.     CERTCertificate * cert;
  940.     SECOidData *oid;
  941.     SECStatus rv1 = SECSuccess;
  942.     SECStatus rv2 = SECSuccess;
  944.     if (slot->cert_array) {
  945. for (i=0; i < slot->cert_count; i++) {
  947.             cert = slot->cert_array[i];
  949.             oid = SECOID_FindOID(&cert->subjectPublicKeyInfo.algorithm.algorithm);
  950.             
  951.     if (oid != NULL) {  
  952.         tag = oid->offset;
  953.              
  954.                 /* Check if cert has a DSA or Fortezza public key */
  955.         if ( (tag == SEC_OID_MISSI_KEA_DSS_OLD) ||
  956.              (tag == SEC_OID_MISSI_DSS_OLD) ||
  957.                      (tag == SEC_OID_MISSI_KEA_DSS) ||
  958.                      (tag == SEC_OID_MISSI_DSS) ||               
  959.                      (tag == SEC_OID_ANSIX9_DSA_SIGNATURE) ||
  960.                      (tag == SEC_OID_ANSIX9_DSA_SIGNATURE_WITH_SHA1_DIGEST) ||
  961.                      (tag == SEC_OID_BOGUS_DSA_SIGNATURE_WITH_SHA1_DIGEST) ) {
  963.                     /* update PQG parameters */
  964.                     
  965.                     rv1 = SECKEY_UpdateCertPQG(cert);
  966.                     if (rv1 == SECFailure) {
  967.                         rv2 = rv1;
  968.                     }      
  969.         }
  970.     }     /* end of if oid != NULL */ 
  971.         }      /* end of for loop */
  972.     }
  973.     return rv2;
  974. }
  977. /*
  978.  * Extract all the certs on a card from a slot.
  979.  */
  980. static SECStatus
  981. pk11_ExtractCertsFromSlot(PK11SlotInfo *slot, void *arg)
  982. {
  983.     pk11TraverseSlotCert *slotcb = (pk11TraverseSlotCert *) arg;
  984.     int object_count;
  985.     SECStatus rv;
  987.     rv = SECSuccess;
  989.     PK11_FreeSlotCerts(slot);
  991.     object_count = PK11_NumberObjectsFor(slot,slotcb->findTemplate, 
  992. slotcb->templateCount);
  994.     /*Actually this isn't a failure... there just were no certs to be found*/
  995.     if (object_count == 0) {
  996. return SECSuccess;
  997.     }
  999.     slot->cert_array = (CERTCertificate **)
  1000. PORT_Alloc(sizeof(CERTCertificate *)*object_count);
  1001.     if (slot->cert_array == NULL) {
  1002. return SECFailure;
  1003.     }
  1004.     slot->cert_count = 0;
  1005.     slot->array_size = object_count;
  1006.     PK11_TraverseSlot(slot,arg);
  1008.     /* Update the PQG parameters for the extracted certs. */
  1009.     rv = pk11_UpdateSlotPQG(slot);
  1011.     return rv;
  1012. }
  1014. /*
  1015.  * read all the certs from a slot
  1016.  */
  1017. SECStatus
  1018. PK11_ReadSlotCerts(PK11SlotInfo *slot)
  1019. {
  1021.     /* build slot list */
  1022.     pk11CertCallback caller;
  1023.     pk11DoCertCallback saver;
  1024.     pk11TraverseSlotCert creater;
  1025.     CK_ATTRIBUTE theTemplate;
  1026.     CK_OBJECT_CLASS certClass = CKO_CERTIFICATE;
  1028.     PK11_SETATTRS(&theTemplate, CKA_CLASS, &certClass, sizeof(certClass));
  1030.     caller.callback = NULL;
  1031.     caller.callbackArg = NULL;
  1032.     saver.callback = pk11_SaveCert;
  1033.     saver.noslotcallback = NULL;
  1034.     saver.callbackArg = (void *) & caller;
  1035.     creater.callback = pk11_DoCerts;
  1036.     creater.callbackArg = (void *) & saver;
  1037.     creater.findTemplate = &theTemplate;
  1038.     creater.templateCount = 1;
  1040.     return pk11_ExtractCertsFromSlot(slot, &creater);
  1041. }
  1043. /*
  1044.  * Extract all the certs on a card from a slot.
  1045.  */
  1046. static SECStatus
  1047. pk11_TraverseAllSlots(PRBool loadCerts,
  1048. SECStatus (*callback)(PK11SlotInfo *,void *),void *arg,void *wincx) {
  1050.     PK11SlotList *list;
  1051.     PK11SlotListElement *le;
  1052.     SECStatus rv;
  1054.     /* get them all! */
  1055.     list = PK11_GetAllTokens(CKM_INVALID_MECHANISM,PR_FALSE,loadCerts,wincx);
  1056.     if (list == NULL) return SECFailure;
  1058.     /* look at each slot and authenticate as necessary */
  1059.     for (le = list->head ; le; le = le->next) {
  1060. /* don't nab internal slots */
  1061. if ((!loadCerts) && le->slot->isInternal == PR_TRUE) {
  1062.     continue;
  1063. }
  1064. if (loadCerts || !PK11_IsFriendly(le->slot)) {
  1065.              rv = PK11_Authenticate(le->slot, loadCerts, wincx);
  1066.              if (rv != SECSuccess) continue;
  1067. }
  1068. (*callback)(le->slot,arg);
  1069.     }
  1071.     PK11_FreeSlotList(list);
  1073.     return SECSuccess;
  1074. }
  1076. /*
  1077.  * Extract all the certs on a card from a slot.
  1078.  */
  1079. SECStatus
  1080. PK11_TraverseSlotCerts(SECStatus(* callback)(CERTCertificate*,SECItem *,void *),
  1081. void *arg, void *wincx) {
  1082.     pk11CertCallback caller;
  1083.     pk11DoCertCallback saver;
  1084.     pk11TraverseSlotCert creater;
  1085.     CK_ATTRIBUTE theTemplate;
  1086.     CK_OBJECT_CLASS certClass = CKO_CERTIFICATE;
  1088.     PK11_SETATTRS(&theTemplate, CKA_CLASS, &certClass, sizeof(certClass));
  1090.     caller.callback = callback;
  1091.     caller.callbackArg = arg;
  1092.     saver.callback = pk11_SaveCert;
  1093.     saver.noslotcallback = NULL;
  1094.     saver.callbackArg = (void *) & caller;
  1095.     creater.callback = pk11_DoCerts;
  1096.     creater.callbackArg = (void *) & saver;
  1097.     creater.findTemplate = &theTemplate;
  1098.     creater.templateCount = 1;
  1100.     return pk11_TraverseAllSlots(PR_FALSE, pk11_ExtractCertsFromSlot, 
  1101. &creater, wincx);
  1102. }
  1104. CK_OBJECT_HANDLE *
  1105. PK11_FindObjectsFromNickname(char *nickname,PK11SlotInfo **slotptr,
  1106. CK_OBJECT_CLASS objclass, int *returnCount, void *wincx) {
  1107.     char *tokenName;
  1108.     char *delimit;
  1109.     PK11SlotInfo *slot;
  1110.     CK_OBJECT_HANDLE *objID;
  1111.     CK_ATTRIBUTE findTemplate[] = {
  1112.  { CKA_LABEL, NULL, 0},
  1113.  { CKA_CLASS, NULL, 0},
  1114.     };
  1115.     int findCount = sizeof(findTemplate)/sizeof(findTemplate[0]);
  1116.     SECStatus rv;
  1117.     PK11_SETATTRS(&findTemplate[1], CKA_CLASS, &objclass, sizeof(objclass));
  1119.     *slotptr = slot = NULL;
  1120.     *returnCount = 0;
  1121.     /* first find the slot associated with this nickname */
  1122.     if ((delimit = PORT_Strchr(nickname,':')) != NULL) {
  1123. int len = delimit - nickname;
  1124. tokenName = (char*)PORT_Alloc(len+1);
  1125. PORT_Memcpy(tokenName,nickname,len);
  1126. tokenName[len] = 0;
  1128.         slot = *slotptr = PK11_FindSlotByName(tokenName);
  1129.         PORT_Free(tokenName);
  1130. /* if we couldn't find a slot, assume the nickname is an internal cert
  1131.  * with no proceding slot name */
  1132. if (slot == NULL) {
  1133. slot = *slotptr = PK11_GetInternalKeySlot();
  1134. } else {
  1135. nickname = delimit+1;
  1136. }
  1137.     } else {
  1138. *slotptr = slot = PK11_GetInternalKeySlot();
  1139.     }
  1140.     if (slot == NULL) {
  1141.         return CK_INVALID_KEY;
  1142.     }
  1144.     if (!PK11_IsFriendly(slot)) {
  1145. rv = PK11_Authenticate(slot, PR_TRUE, wincx);
  1146. if (rv != SECSuccess) {
  1147.     PK11_FreeSlot(slot);
  1148.     *slotptr = NULL;
  1149.     return CK_INVALID_KEY;
  1150.  }
  1151.     }
  1153.     findTemplate[0].pValue = nickname;
  1154.     findTemplate[0].ulValueLen = PORT_Strlen(nickname);
  1155.     objID = pk11_FindObjectsByTemplate(slot,findTemplate,findCount,returnCount);
  1156.     if (objID == NULL) {
  1157. /* PKCS #11 isn't clear on whether or not the NULL is
  1158.  * stored in the template.... try the find again with the
  1159.  * full null terminated string. */
  1160.      findTemplate[0].ulValueLen += 1;
  1161.         objID = pk11_FindObjectsByTemplate(slot,findTemplate,findCount,
  1162. returnCount);
  1163. if (objID == NULL) {
  1164.     /* Well that's the best we can do. It's just not here */
  1165.     /* what about faked nicknames? */
  1166.     PK11_FreeSlot(slot);
  1167.     *slotptr = NULL;
  1168.     *returnCount = 0;
  1169. }
  1170.     }
  1172.     return objID;
  1173. }
  1175.    
  1176. CERTCertificate *
  1177. PK11_FindCertFromNickname(char *nickname, void *wincx) {
  1178.     PK11SlotInfo *slot;
  1179.     int count=0;
  1180.     CK_OBJECT_HANDLE *certID = PK11_FindObjectsFromNickname(nickname,&slot,
  1181.   CKO_CERTIFICATE, &count, wincx);
  1182.     CERTCertificate *cert;
  1184.     if (certID == CK_INVALID_KEY) return NULL;
  1185.     cert = PK11_MakeCertFromHandle(slot,certID[0],NULL);
  1186.     PK11_FreeSlot(slot);
  1187.     PORT_Free(certID);
  1188.     return cert;
  1189. }
  1191. CERTCertList *
  1192. PK11_FindCertsFromNickname(char *nickname, void *wincx) {
  1193.     PK11SlotInfo *slot;
  1194.     int i,count = 0;
  1195.     CK_OBJECT_HANDLE *certID = PK11_FindObjectsFromNickname(nickname,&slot,
  1196.   CKO_CERTIFICATE, &count, wincx);
  1197.     CERTCertList *certList = NULL;
  1199.     if (certID == NULL) return NULL;
  1201.     certList= CERT_NewCertList();
  1203.     for (i=0; i < count; i++) {
  1204.      CERTCertificate *cert = PK11_MakeCertFromHandle(slot,certID[i],NULL);
  1206. if (cert) CERT_AddCertToListTail(certList,cert);
  1207.     }
  1209.     if (CERT_LIST_HEAD(certList) == NULL) {
  1210. CERT_DestroyCertList(certList);
  1211. certList = NULL;
  1212.     }
  1213.     PK11_FreeSlot(slot);
  1214.     PORT_Free(certID);
  1215.     return certList;
  1216. }
  1218. /*
  1219.  * extract a key ID for a certificate...
  1220.  * NOTE: We call this function from PKCS11.c If we ever use
  1221.  * pkcs11 to extract the public key (we currently do not), this will break.
  1222.  */
  1223. SECItem *
  1224. PK11_GetPubIndexKeyID(CERTCertificate *cert) {
  1225.     SECKEYPublicKey *pubk;
  1226.     SECItem *newItem = NULL;
  1228.     pubk = CERT_ExtractPublicKey(cert);
  1229.     if (pubk == NULL) return NULL;
  1231.     switch (pubk->keyType) {
  1232.     case rsaKey:
  1233. newItem = SECITEM_DupItem(&pubk->u.rsa.modulus);
  1234. break;
  1235.     case dsaKey:
  1236.         newItem = SECITEM_DupItem(&pubk->u.dsa.publicValue);
  1237. break;
  1238.     case dhKey:
  1239.         newItem = SECITEM_DupItem(&pubk->u.dh.publicValue);
  1240.     case fortezzaKey:
  1241.     default:
  1242. newItem = NULL; /* Fortezza Fix later... */
  1243.     }
  1244.     SECKEY_DestroyPublicKey(pubk);
  1245.     /* make hash of it */
  1246.     return newItem;
  1247. }
  1249. /*
  1250.  * generate a CKA_ID from a certificate.
  1251.  */
  1252. SECItem *
  1253. pk11_mkcertKeyID(CERTCertificate *cert) {
  1254.     SECItem *pubKeyData = PK11_GetPubIndexKeyID(cert) ;
  1255.     SECItem *certCKA_ID;
  1257.     if (pubKeyData == NULL) return NULL;
  1258.     
  1259.     certCKA_ID = PK11_MakeIDFromPubKey(pubKeyData);
  1260.     SECITEM_FreeItem(pubKeyData,PR_TRUE);
  1261.     return certCKA_ID;
  1262. }
  1265. /*
  1266.  * Generate a CKA_ID from the relevant public key data. The CKA_ID is generated
  1267.  * from the pubKeyData by SHA1_Hashing it to produce a smaller CKA_ID (to make
  1268.  * smart cards happy.
  1269.  */
  1270. SECItem *
  1271. PK11_MakeIDFromPubKey(SECItem *pubKeyData) {
  1272.     PK11Context *context;
  1273.     SECItem *certCKA_ID;
  1274.     SECStatus rv;
  1276.     context = PK11_CreateDigestContext(SEC_OID_SHA1);
  1277.     if (context == NULL) {
  1278. return NULL;
  1279.     }
  1281.     rv = PK11_DigestBegin(context);
  1282.     if (rv == SECSuccess) {
  1283.      rv = PK11_DigestOp(context,pubKeyData->data,pubKeyData->len);
  1284.     }
  1285.     if (rv != SECSuccess) {
  1286. PK11_DestroyContext(context,PR_TRUE);
  1287. return NULL;
  1288.     }
  1290.     certCKA_ID = (SECItem *)PORT_Alloc(sizeof(SECItem));
  1291.     if (certCKA_ID == NULL) {
  1292. PK11_DestroyContext(context,PR_TRUE);
  1293. return NULL;
  1294.     }
  1296.     certCKA_ID->len = SHA1_LENGTH;
  1297.     certCKA_ID->data = (unsigned char*)PORT_Alloc(certCKA_ID->len);
  1298.     if (certCKA_ID->data == NULL) {
  1299. PORT_Free(certCKA_ID);
  1300. PK11_DestroyContext(context,PR_TRUE);
  1301.         return NULL;
  1302.     }
  1304.     rv = PK11_DigestFinal(context,certCKA_ID->data,&certCKA_ID->len,
  1305. SHA1_LENGTH);
  1306.     PK11_DestroyContext(context,PR_TRUE);
  1307.     if (rv != SECSuccess) {
  1308.      SECITEM_FreeItem(certCKA_ID,PR_TRUE);
  1309. return NULL;
  1310.     }
  1312.     return certCKA_ID;
  1313. }
  1315. /*
  1316.  * Write the cert into the token.
  1317.  */
  1318. SECStatus
  1319. PK11_ImportCert(PK11SlotInfo *slot, CERTCertificate *cert, 
  1320. CK_OBJECT_HANDLE key, char *nickname, PRBool includeTrust) {
  1321.     int len = 0;
  1322.     SECItem *keyID = pk11_mkcertKeyID(cert);
  1323.     CK_ATTRIBUTE keyAttrs[] = {
  1324. { CKA_LABEL, NULL, 0},
  1325. { CKA_SUBJECT, NULL, 0},
  1326.     };
  1327.     CK_OBJECT_CLASS certc = CKO_CERTIFICATE;
  1328.     CK_CERTIFICATE_TYPE certType = CKC_X_509;
  1329.     CK_OBJECT_HANDLE certID;
  1330.     CK_SESSION_HANDLE rwsession;
  1331.     CK_BBOOL cktrue = CK_TRUE;
  1332.     SECStatus rv = SECFailure;
  1333.     CK_ATTRIBUTE certAttrs[] = {
  1334. { CKA_ID, NULL, 0 },
  1335. { CKA_LABEL, NULL, 0},
  1336. { CKA_CLASS,  NULL, 0},
  1337. { CKA_TOKEN,  NULL, 0},
  1338. { CKA_CERTIFICATE_TYPE, NULL, 0},
  1339. { CKA_SUBJECT, NULL, 0},
  1340. { CKA_ISSUER, NULL, 0},
  1341. { CKA_SERIAL_NUMBER,  NULL, 0},
  1342. { CKA_VALUE,  NULL, 0},
  1343. { CKA_NETSCAPE_TRUST,  NULL, 0},
  1344.     };
  1345.     int certCount = sizeof(certAttrs)/sizeof(certAttrs[0]), keyCount = 2;
  1346.     CK_ATTRIBUTE *attrs;
  1347.     CK_RV crv;
  1348.     SECCertUsage *certUsage = NULL;
  1350.     if (keyID == NULL) {
  1351. PORT_SetError(SEC_ERROR_ADDING_CERT);
  1352. return rv;
  1353.     }
  1355.     len = ((nickname) ? PORT_Strlen(nickname) : 0);
  1356.     
  1357.     attrs = certAttrs;
  1358.     PK11_SETATTRS(attrs,CKA_ID, keyID->data, keyID->len); attrs++;
  1359.     if(nickname) {
  1360. PK11_SETATTRS(attrs,CKA_LABEL, nickname, len ); attrs++;
  1361.     }
  1362.     PK11_SETATTRS(attrs,CKA_CLASS, &certc, sizeof(certc) ); attrs++;
  1363.     PK11_SETATTRS(attrs,CKA_TOKEN, &cktrue, sizeof(cktrue) ); attrs++;
  1364.     PK11_SETATTRS(attrs,CKA_CERTIFICATE_TYPE, &certType,
  1365. sizeof(certType)); attrs++;
  1366.     PK11_SETATTRS(attrs,CKA_SUBJECT, cert->derSubject.data,
  1367.  cert->derSubject.len ); attrs++;
  1368.     PK11_SETATTRS(attrs,CKA_ISSUER, cert->derIssuer.data,
  1369.  cert->derIssuer.len ); attrs++;
  1370.     PK11_SETATTRS(attrs,CKA_SERIAL_NUMBER, cert->serialNumber.data,
  1371.  cert->serialNumber.len); attrs++;
  1372.     PK11_SETATTRS(attrs,CKA_VALUE, cert->derCert.data, cert->derCert.len);
  1373.     if(includeTrust && PK11_IsInternal(slot)) {
  1374. attrs++;
  1375. certUsage = (SECCertUsage*)PORT_Alloc(sizeof(SECCertUsage));
  1376. if(!certUsage) {
  1377.     SECITEM_FreeItem(keyID,PR_TRUE);
  1378.     PORT_SetError(SEC_ERROR_NO_MEMORY);
  1379.     return rv;
  1380. }
  1381. *certUsage = certUsageUserCertImport;
  1382. PK11_SETATTRS(attrs,CKA_NETSCAPE_TRUST, certUsage, sizeof(SECCertUsage));
  1383.     } else {
  1384. certCount--;
  1385.     }
  1387.     attrs = keyAttrs;
  1388.     if(nickname) {
  1389. PK11_SETATTRS(attrs,CKA_LABEL, nickname, len ); attrs++;
  1390.     }
  1391.     PK11_SETATTRS(attrs,CKA_SUBJECT, cert->derSubject.data,
  1392.  cert->derSubject.len );
  1394.     if(!nickname) {
  1395. certCount--;
  1396. keyCount--;
  1397.     }
  1399.     rwsession = PK11_GetRWSession(slot);
  1400.     crv = PK11_GETTAB(slot)->C_SetAttributeValue(rwsession,key,keyAttrs,
  1401. keyCount);
  1402.     if (crv != CKR_OK) {
  1403. PORT_SetError( PK11_MapError(crv) );
  1404. goto done;
  1405.     }
  1407.     crv = PK11_GETTAB(slot)->
  1408. C_CreateObject(rwsession,certAttrs,certCount,&certID);
  1409.     if (crv == CKR_OK) {
  1410. rv = SECSuccess;
  1411.     } else {
  1412. PORT_SetError( PK11_MapError(crv) );
  1413.     }
  1415. done:
  1416.     SECITEM_FreeItem(keyID,PR_TRUE);
  1417.     PK11_RestoreROSession(slot,rwsession);
  1418.     if(certUsage) {
  1419. PORT_Free(certUsage);
  1420.     }
  1421.     return rv;
  1423. }
  1425. /*
  1426.  * get a certificate handle, look at the cached handle first..
  1427.  */
  1428. CK_OBJECT_HANDLE
  1429. pk11_getcerthandle(PK11SlotInfo *slot, CERTCertificate *cert, 
  1430. CK_ATTRIBUTE *theTemplate,int tsize)
  1431. {
  1432.     CK_OBJECT_HANDLE certh;
  1434.     if (cert->slot == slot) {
  1435. certh = cert->pkcs11ID;
  1436. if (certh == CK_INVALID_KEY) {
  1437.           certh = pk11_FindObjectByTemplate(slot,theTemplate,tsize);
  1438.      cert->pkcs11ID = certh;
  1439. }
  1440.     } else {
  1441.      certh = pk11_FindObjectByTemplate(slot,theTemplate,tsize);
  1442.     }
  1443.     return certh;
  1444. }
  1446. /*
  1447.  * return the private key From a given Cert
  1448.  */
  1449. SECKEYPrivateKey *
  1450. PK11_FindPrivateKeyFromCert(PK11SlotInfo *slot, CERTCertificate *cert,
  1451.  void *wincx) {
  1452.     CK_OBJECT_CLASS certClass = CKO_CERTIFICATE;
  1453.     CK_ATTRIBUTE theTemplate[] = {
  1454. { CKA_VALUE, NULL, 0 },
  1455. { CKA_CLASS, NULL, 0 }
  1456.     };
  1457.     /* if you change the array, change the variable below as well */
  1458.     int tsize = sizeof(theTemplate)/sizeof(theTemplate[0]);
  1459.     CK_OBJECT_HANDLE certh;
  1460.     CK_OBJECT_HANDLE keyh;
  1461.     CK_ATTRIBUTE *attrs = theTemplate;
  1462.     SECStatus rv;
  1464.     PK11_SETATTRS(attrs, CKA_VALUE, cert->derCert.data, 
  1465. cert->derCert.len); attrs++;
  1466.     PK11_SETATTRS(attrs, CKA_CLASS, &certClass, sizeof(certClass));
  1468.     /*
  1469.      * issue the find
  1470.      */
  1471.     rv = PK11_Authenticate(slot, PR_TRUE, wincx);
  1472.     if (rv != SECSuccess) {
  1473. return NULL;
  1474.     }
  1476.     certh = pk11_getcerthandle(slot,cert,theTemplate,tsize);
  1477.     if (certh == CK_INVALID_KEY) {
  1478. return NULL;
  1479.     }
  1480.     keyh = PK11_MatchItem(slot,certh,CKO_PRIVATE_KEY);
  1481.     if (keyh == CK_INVALID_KEY) { return NULL; }
  1482.     return PK11_MakePrivKey(slot, nullKey, PR_TRUE, keyh, wincx);
  1483. } 
  1486. /*
  1487.  * return the private key with the given ID
  1488.  */
  1489. static CK_OBJECT_HANDLE
  1490. pk11_FindPrivateKeyFromCertID(PK11SlotInfo *slot, SECItem *keyID)  {
  1491.     CK_OBJECT_CLASS privKey = CKO_PRIVATE_KEY;
  1492.     CK_ATTRIBUTE theTemplate[] = {
  1493. { CKA_ID, NULL, 0 },
  1494. { CKA_CLASS, NULL, 0 },
  1495.     };
  1496.     /* if you change the array, change the variable below as well */
  1497.     int tsize = sizeof(theTemplate)/sizeof(theTemplate[0]);
  1498.     CK_ATTRIBUTE *attrs = theTemplate;
  1500.     PK11_SETATTRS(attrs, CKA_ID, keyID->data, keyID->len ); attrs++;
  1501.     PK11_SETATTRS(attrs, CKA_CLASS, &privKey, sizeof(privKey));
  1503.     return pk11_FindObjectByTemplate(slot,theTemplate,tsize);
  1504. } 
  1506. /*
  1507.  * import a cert for a private key we have already generated. Set the label
  1508.  * on both to be the nickname. This is for the Key Gen, orphaned key case.
  1509.  */
  1510. PK11SlotInfo *
  1511. PK11_KeyForCertExists(CERTCertificate *cert, CK_OBJECT_HANDLE *keyPtr, 
  1512. void *wincx) {
  1513.     PK11SlotList *list;
  1514.     PK11SlotListElement *le;
  1515.     SECItem *keyID;
  1516.     CK_OBJECT_HANDLE key;
  1517.     PK11SlotInfo *slot = NULL;
  1518.     SECStatus rv;
  1520.     keyID = pk11_mkcertKeyID(cert);
  1521.     /* get them all! */
  1522.     list = PK11_GetAllTokens(CKM_INVALID_MECHANISM,PR_FALSE,PR_TRUE,wincx);
  1523.     if ((keyID == NULL) || (list == NULL)) {
  1524. if (keyID) SECITEM_FreeItem(keyID,PR_TRUE);
  1525. if (list) PK11_FreeSlotList(list);
  1526.      return NULL;
  1527.     }
  1529.     /* Look for the slot that holds the Key */
  1530.     for (le = list->head ; le; le = le->next) {
  1531. rv = PK11_Authenticate(le->slot, PR_TRUE, wincx);
  1532. if (rv != SECSuccess) continue;
  1534. key = pk11_FindPrivateKeyFromCertID(le->slot,keyID);
  1535. if (key != CK_INVALID_KEY) {
  1536.     slot = PK11_ReferenceSlot(le->slot);
  1537.     if (keyPtr) *keyPtr = key;
  1538.     break;
  1539. }
  1540.     }
  1542.     SECITEM_FreeItem(keyID,PR_TRUE);
  1543.     PK11_FreeSlotList(list);
  1544.     return slot;
  1546. }
  1548. PK11SlotInfo *
  1549. PK11_ImportCertForKey(CERTCertificate *cert, char *nickname,void *wincx) {
  1550.     PK11SlotInfo *slot = NULL;
  1551.     CK_OBJECT_HANDLE key;
  1553.     slot = PK11_KeyForCertExists(cert,&key,wincx);
  1555.     if (slot) {
  1556. if (PK11_ImportCert(slot,cert,key,nickname,PR_FALSE) != SECSuccess) {
  1557.     PK11_FreeSlot(slot);
  1558.     slot = NULL;
  1559. }
  1560.     } else {
  1561. PORT_SetError(SEC_ERROR_ADDING_CERT);
  1562.     }
  1564.     return slot;
  1565. }
  1567. static CK_OBJECT_HANDLE
  1568. pk11_FindCertObjectByTemplate(PK11SlotInfo **slotPtr, 
  1569. CK_ATTRIBUTE *searchTemplate, int count, void *wincx) {
  1570.     PK11SlotList *list;
  1571.     PK11SlotListElement *le;
  1572.     CK_OBJECT_HANDLE certHandle = CK_INVALID_KEY;
  1573.     PK11SlotInfo *slot = NULL;
  1574.     SECStatus rv;
  1576.     *slotPtr = NULL;
  1578.     /* get them all! */
  1579.     list = PK11_GetAllTokens(CKM_INVALID_MECHANISM,PR_FALSE,PR_TRUE,wincx);
  1580.     if (list == NULL) {
  1581. if (list) PK11_FreeSlotList(list);
  1582.      return CK_INVALID_KEY;
  1583.     }
  1586.     /* Look for the slot that holds the Key */
  1587.     for (le = list->head ; le; le = le->next) {
  1588.   if (!PK11_IsFriendly(le->slot)) {
  1589.     rv = PK11_Authenticate(le->slot, PR_TRUE, wincx);
  1590.     if (rv != SECSuccess) continue;
  1591. }
  1593. certHandle = pk11_FindObjectByTemplate(le->slot,searchTemplate,count);
  1594. if (certHandle != CK_INVALID_KEY) {
  1595.     slot = PK11_ReferenceSlot(le->slot);
  1596.     break;
  1597. }
  1598.     }
  1600.     PK11_FreeSlotList(list);
  1602.     if (slot == NULL) {
  1603. return CK_INVALID_KEY;
  1604.     }
  1605.     *slotPtr = slot;
  1606.     return certHandle;
  1607. }
  1610. /*
  1611.  * We're looking for a cert which we have the private key for that's on the
  1612.  * list of recipients. This searches one slot.
  1613.  * this is the new version for NSS SMIME code
  1614.  * this stuff should REALLY be in the SMIME code, but some things in here are not public
  1615.  * (they should be!)
  1616.  */
  1617. static CK_OBJECT_HANDLE
  1618. pk11_FindCertObjectByRecipientNew(PK11SlotInfo *slot, NSSCMSRecipient **recipientlist, int *rlIndex)
  1619. {
  1620.     CK_OBJECT_HANDLE certHandle;
  1621.     CK_OBJECT_CLASS certClass = CKO_CERTIFICATE;
  1622.     CK_OBJECT_CLASS peerClass ;
  1623.     CK_ATTRIBUTE searchTemplate[] = {
  1624. { CKA_CLASS, NULL, 0 },
  1625. { CKA_ISSUER, NULL, 0 },
  1626. { CKA_SERIAL_NUMBER, NULL, 0}
  1627.     };
  1628.     int count = sizeof(searchTemplate)/sizeof(CK_ATTRIBUTE);
  1629.     NSSCMSRecipient *ri = NULL;
  1630.     CK_ATTRIBUTE *attrs;
  1631.     int i;
  1633.     peerClass = CKO_PRIVATE_KEY;
  1634.     if (!PK11_IsLoggedIn(slot,NULL) && PK11_NeedLogin(slot)) {
  1635. peerClass = CKO_PUBLIC_KEY;
  1636.     }
  1638.     for (i=0; (ri = recipientlist[i]) != NULL; i++) {
  1639. /* XXXXX fixme - not yet implemented! */
  1640. if (ri->kind == RLSubjKeyID)
  1641.     continue;
  1643.      attrs = searchTemplate;
  1645. PK11_SETATTRS(attrs, CKA_CLASS, &certClass,sizeof(certClass)); attrs++;
  1646. PK11_SETATTRS(attrs, CKA_ISSUER, ri->id.issuerAndSN->derIssuer.data, 
  1647. ri->id.issuerAndSN->derIssuer.len); attrs++;
  1648. PK11_SETATTRS(attrs, CKA_SERIAL_NUMBER, 
  1649.   ri->id.issuerAndSN->serialNumber.data,ri->id.issuerAndSN->serialNumber.len);
  1651. certHandle = pk11_FindObjectByTemplate(slot,searchTemplate,count);
  1652. if (certHandle != CK_INVALID_KEY) {
  1653.     CERTCertificate *cert = pk11_fastCert(slot,certHandle,NULL,NULL);
  1654.     if (PK11_IsUserCert(slot,cert,certHandle)) {
  1655. /* we've found a cert handle, now let's see if there is a key
  1656.          * associated with it... */
  1657. ri->slot = PK11_ReferenceSlot(slot);
  1658. *rlIndex = i;
  1660. CERT_DestroyCertificate(cert);       
  1661. return certHandle;
  1662.     }
  1663.     CERT_DestroyCertificate(cert);       
  1664. }
  1665.     }
  1666.     *rlIndex = -1;
  1667.     return CK_INVALID_KEY;
  1668. }
  1670. /*
  1671.  * This function is the same as above, but it searches all the slots.
  1672.  * this is the new version for NSS SMIME code
  1673.  * this stuff should REALLY be in the SMIME code, but some things in here are not public
  1674.  * (they should be!)
  1675.  */
  1676. static CK_OBJECT_HANDLE
  1677. pk11_AllFindCertObjectByRecipientNew(NSSCMSRecipient **recipientlist, void *wincx, int *rlIndex)
  1678. {
  1679.     PK11SlotList *list;
  1680.     PK11SlotListElement *le;
  1681.     CK_OBJECT_HANDLE certHandle = CK_INVALID_KEY;
  1682.     PK11SlotInfo *slot = NULL;
  1683.     SECStatus rv;
  1685.     /* get them all! */
  1686.     list = PK11_GetAllTokens(CKM_INVALID_MECHANISM,PR_FALSE,PR_TRUE,wincx);
  1687.     if (list == NULL) {
  1688. if (list) PK11_FreeSlotList(list);
  1689.      return CK_INVALID_KEY;
  1690.     }
  1692.     /* Look for the slot that holds the Key */
  1693.     for (le = list->head ; le; le = le->next) {
  1694. if ( !PK11_IsFriendly(le->slot)) {
  1695.     rv = PK11_Authenticate(le->slot, PR_TRUE, wincx);
  1696.     if (rv != SECSuccess) continue;
  1697. }
  1699. certHandle = pk11_FindCertObjectByRecipientNew(le->slot, recipientlist, rlIndex);
  1700. if (certHandle != CK_INVALID_KEY)
  1701.     break;
  1702.     }
  1704.     PK11_FreeSlotList(list);
  1706.     return (le == NULL) ? CK_INVALID_KEY : certHandle;
  1707. }
  1709. /*
  1710.  * We're looking for a cert which we have the private key for that's on the
  1711.  * list of recipients. This searches one slot.
  1712.  */
  1713. static CK_OBJECT_HANDLE
  1714. pk11_FindCertObjectByRecipient(PK11SlotInfo *slot, 
  1715. SEC_PKCS7RecipientInfo **recipientArray,SEC_PKCS7RecipientInfo **rip)
  1716. {
  1717.     CK_OBJECT_HANDLE certHandle;
  1718.     CK_OBJECT_CLASS certClass = CKO_CERTIFICATE;
  1719.     CK_OBJECT_CLASS peerClass ;
  1720.     CK_ATTRIBUTE searchTemplate[] = {
  1721. { CKA_CLASS, NULL, 0 },
  1722. { CKA_ISSUER, NULL, 0 },
  1723. { CKA_SERIAL_NUMBER, NULL, 0}
  1724.     };
  1725.     int count = sizeof(searchTemplate)/sizeof(CK_ATTRIBUTE);
  1726.     SEC_PKCS7RecipientInfo *ri = NULL;
  1727.     CK_ATTRIBUTE *attrs;
  1728.     int i;
  1731.     peerClass = CKO_PRIVATE_KEY;
  1732.     if (!PK11_IsLoggedIn(slot,NULL) && PK11_NeedLogin(slot)) {
  1733. peerClass = CKO_PUBLIC_KEY;
  1734.     }
  1736.     for (i=0; (ri = recipientArray[i]) != NULL; i++) {
  1737.      attrs = searchTemplate;
  1739. PK11_SETATTRS(attrs, CKA_CLASS, &certClass,sizeof(certClass)); attrs++;
  1740. PK11_SETATTRS(attrs, CKA_ISSUER, ri->issuerAndSN->derIssuer.data, 
  1741. ri->issuerAndSN->derIssuer.len); attrs++;
  1742. PK11_SETATTRS(attrs, CKA_SERIAL_NUMBER, 
  1743.   ri->issuerAndSN->serialNumber.data,ri->issuerAndSN->serialNumber.len);
  1745. certHandle = pk11_FindObjectByTemplate(slot,searchTemplate,count);
  1746. if (certHandle != CK_INVALID_KEY) {
  1747.     CERTCertificate *cert = pk11_fastCert(slot,certHandle,NULL,NULL);
  1748.     if (PK11_IsUserCert(slot,cert,certHandle)) {
  1749. /* we've found a cert handle, now let's see if there is a key
  1750.          * associated with it... */
  1751. *rip = ri;
  1753. CERT_DestroyCertificate(cert);       
  1754. return certHandle;
  1755.     }
  1756.     CERT_DestroyCertificate(cert);       
  1757. }
  1758.     }
  1759.     *rip = NULL;
  1760.     return CK_INVALID_KEY;
  1761. }
  1763. /*
  1764.  * This function is the same as above, but it searches all the slots.
  1765.  */
  1766. static CK_OBJECT_HANDLE
  1767. pk11_AllFindCertObjectByRecipient(PK11SlotInfo **slotPtr, 
  1768. SEC_PKCS7RecipientInfo **recipientArray,SEC_PKCS7RecipientInfo **rip,
  1769. void *wincx) {
  1770.     PK11SlotList *list;
  1771.     PK11SlotListElement *le;
  1772.     CK_OBJECT_HANDLE certHandle = CK_INVALID_KEY;
  1773.     PK11SlotInfo *slot = NULL;
  1774.     SECStatus rv;
  1776.     *slotPtr = NULL;
  1778.     /* get them all! */
  1779.     list = PK11_GetAllTokens(CKM_INVALID_MECHANISM,PR_FALSE,PR_TRUE,wincx);
  1780.     if (list == NULL) {
  1781. if (list) PK11_FreeSlotList(list);
  1782.      return CK_INVALID_KEY;
  1783.     }
  1785.     *rip = NULL;
  1787.     /* Look for the slot that holds the Key */
  1788.     for (le = list->head ; le; le = le->next) {
  1789. if ( !PK11_IsFriendly(le->slot)) {
  1790.     rv = PK11_Authenticate(le->slot, PR_TRUE, wincx);
  1791.     if (rv != SECSuccess) continue;
  1792. }
  1794. certHandle = pk11_FindCertObjectByRecipient(le->slot,
  1795. recipientArray,rip);
  1796. if (certHandle != CK_INVALID_KEY) {
  1797.     slot = PK11_ReferenceSlot(le->slot);
  1798.     break;
  1799. }
  1800.     }
  1802.     PK11_FreeSlotList(list);
  1804.     if (slot == NULL) {
  1805. return CK_INVALID_KEY;
  1806.     }
  1807.     *slotPtr = slot;
  1808.     return certHandle;
  1809. }
  1811. /*
  1812.  * We need to invert the search logic for PKCS 7 because if we search for
  1813.  * each cert on the list over all the slots, we wind up with lots of spurious
  1814.  * password prompts. This way we get only one password prompt per slot, at
  1815.  * the max, and most of the time we can find the cert, and only prompt for
  1816.  * the key...
  1817.  */
  1818. CERTCertificate *
  1819. PK11_FindCertAndKeyByRecipientList(PK11SlotInfo **slotPtr, 
  1820. SEC_PKCS7RecipientInfo **array, SEC_PKCS7RecipientInfo **rip,
  1821. SECKEYPrivateKey**privKey, void *wincx)
  1822. {
  1823.     CK_OBJECT_HANDLE certHandle = CK_INVALID_KEY;
  1824.     CK_OBJECT_HANDLE keyHandle = CK_INVALID_KEY;
  1825.     PK11SlotInfo *slot = NULL;
  1826.     CERTCertificate *cert = NULL;
  1827.     SECStatus rv;
  1829.     *privKey = NULL;
  1830.     certHandle = pk11_AllFindCertObjectByRecipient(slotPtr,array,rip,wincx);
  1831.     if (certHandle == CK_INVALID_KEY) {
  1832. return NULL;
  1833.     }
  1835.     rv = PK11_Authenticate(*slotPtr,PR_TRUE,wincx);
  1836.     if (rv != SECSuccess) {
  1837. PK11_FreeSlot(*slotPtr);
  1838. *slotPtr = NULL;
  1839. return NULL;
  1840.     }
  1842.     keyHandle = PK11_MatchItem(*slotPtr,certHandle,CKO_PRIVATE_KEY);
  1843.     if (keyHandle == CK_INVALID_KEY) { 
  1844. PK11_FreeSlot(*slotPtr);
  1845. *slotPtr = NULL;
  1846. return NULL;
  1847.     }
  1849.     *privKey =  PK11_MakePrivKey(*slotPtr, nullKey, PR_TRUE, keyHandle, wincx);
  1850.     if (*privKey == NULL) {
  1851. PK11_FreeSlot(*slotPtr);
  1852. *slotPtr = NULL;
  1853. return NULL;
  1854.     }
  1855.     cert = PK11_MakeCertFromHandle(*slotPtr,certHandle,NULL);
  1856.     if (cert == NULL) {
  1857. PK11_FreeSlot(*slotPtr);
  1858. SECKEY_DestroyPrivateKey(*privKey);
  1859. *slotPtr = NULL;
  1860. *privKey = NULL;
  1861. return NULL;
  1862.     }
  1863.     return cert;
  1864. }
  1866. /*
  1867.  * This is the new version of the above function for NSS SMIME code
  1868.  * this stuff should REALLY be in the SMIME code, but some things in here are not public
  1869.  * (they should be!)
  1870.  */
  1871. int
  1872. PK11_FindCertAndKeyByRecipientListNew(NSSCMSRecipient **recipientlist, void *wincx)
  1873. {
  1874.     CK_OBJECT_HANDLE certHandle = CK_INVALID_KEY;
  1875.     CK_OBJECT_HANDLE keyHandle = CK_INVALID_KEY;
  1876.     SECStatus rv;
  1877.     NSSCMSRecipient *rl;
  1878.     int rlIndex;
  1880.     certHandle = pk11_AllFindCertObjectByRecipientNew(recipientlist, wincx, &rlIndex);
  1881.     if (certHandle == CK_INVALID_KEY) {
  1882. return NULL;
  1883.     }
  1885.     rl = recipientlist[rlIndex];
  1887.     /* at this point, rl->slot is set */
  1889.     /* authenticate to the token */
  1890.     if (PK11_Authenticate(rl->slot, PR_TRUE, wincx) != SECSuccess) {
  1891. PK11_FreeSlot(rl->slot);
  1892. rl->slot = NULL;
  1893. return -1;
  1894.     }
  1896.     /* try to get a private key handle for the cert we found */
  1897.     keyHandle = PK11_MatchItem(rl->slot, certHandle, CKO_PRIVATE_KEY);
  1898.     if (keyHandle == CK_INVALID_KEY) { 
  1899. PK11_FreeSlot(rl->slot);
  1900. rl->slot = NULL;
  1901. return -1;
  1902.     }
  1904.     /* make a private key out of the handle */
  1905.     rl->privkey = PK11_MakePrivKey(rl->slot, nullKey, PR_TRUE, keyHandle, wincx);
  1906.     if (rl->privkey == NULL) {
  1907. PK11_FreeSlot(rl->slot);
  1908. rl->slot = NULL;
  1909. return -1;
  1910.     }
  1911.     /* make a cert from the cert handle */
  1912.     rl->cert = PK11_MakeCertFromHandle(rl->slot, certHandle, NULL);
  1913.     if (rl->cert == NULL) {
  1914. PK11_FreeSlot(rl->slot);
  1915. SECKEY_DestroyPrivateKey(rl->privkey);
  1916. rl->slot = NULL;
  1917. rl->privkey = NULL;
  1918. return NULL;
  1919.     }
  1920.     return rlIndex;
  1921. }
  1923. CERTCertificate *
  1924. PK11_FindCertByIssuerAndSN(PK11SlotInfo **slotPtr, CERTIssuerAndSN *issuerSN,
  1925.  void *wincx)
  1926. {
  1927.     CK_OBJECT_HANDLE certHandle;
  1928.     CERTCertificate *cert = NULL;
  1929.     CK_ATTRIBUTE searchTemplate[] = {
  1930. { CKA_ISSUER, NULL, 0 },
  1931. { CKA_SERIAL_NUMBER, NULL, 0}
  1932.     };
  1933.     int count = sizeof(searchTemplate)/sizeof(CK_ATTRIBUTE);
  1934.     CK_ATTRIBUTE *attrs = searchTemplate;
  1936.     PK11_SETATTRS(attrs, CKA_ISSUER, issuerSN->derIssuer.data, 
  1937. issuerSN->derIssuer.len); attrs++;
  1938.     PK11_SETATTRS(attrs, CKA_SERIAL_NUMBER, issuerSN->serialNumber.data, 
  1939. issuerSN->serialNumber.len);
  1941.     certHandle = pk11_FindCertObjectByTemplate
  1942. (slotPtr,searchTemplate,count,wincx);
  1943.     if (certHandle == CK_INVALID_KEY) {
  1944. return NULL;
  1945.     }
  1946.     cert = PK11_MakeCertFromHandle(*slotPtr,certHandle,NULL);
  1947.     if (cert == NULL) {
  1948. PK11_FreeSlot(*slotPtr);
  1949. return NULL;
  1950.     }
  1951.     return cert;
  1952. }
  1954. CK_OBJECT_HANDLE
  1955. PK11_FindObjectForCert(CERTCertificate *cert, void *wincx, PK11SlotInfo **pSlot)
  1956. {
  1957.     CK_OBJECT_HANDLE certHandle;
  1958.     CK_ATTRIBUTE searchTemplate = { CKA_VALUE, NULL, 0 };
  1959.     
  1960.     PK11_SETATTRS(&searchTemplate, CKA_VALUE, cert->derCert.data,
  1961.   cert->derCert.len);
  1963.     if (cert->slot) {
  1964. certHandle = pk11_getcerthandle(cert->slot,cert,&searchTemplate,1);
  1965. if (certHandle != CK_INVALID_KEY) {
  1966.     *pSlot = PK11_ReferenceSlot(cert->slot);
  1967.     return certHandle;
  1968. }
  1969.     }
  1971.     certHandle = pk11_FindCertObjectByTemplate(pSlot,&searchTemplate,1,wincx);
  1972.     if (certHandle != CK_INVALID_KEY) {
  1973. if (cert->slot == NULL) {
  1974.     cert->slot = PK11_ReferenceSlot(*pSlot);
  1975.     cert->pkcs11ID = certHandle;
  1976.     cert->ownSlot = PR_FALSE;
  1977. }
  1978.     }
  1980.     return(certHandle);
  1981. }
  1983. SECKEYPrivateKey *
  1984. PK11_FindKeyByAnyCert(CERTCertificate *cert, void *wincx)
  1985. {
  1986.     CK_OBJECT_HANDLE certHandle;
  1987.     CK_OBJECT_HANDLE keyHandle;
  1988.     PK11SlotInfo *slot = NULL;
  1989.     SECKEYPrivateKey *privKey;
  1990.     SECStatus rv;
  1992.     certHandle = PK11_FindObjectForCert(cert, wincx, &slot);
  1993.     if (certHandle == CK_INVALID_KEY) {
  1994.  return NULL;
  1995.     }
  1996.     rv = PK11_Authenticate(slot, PR_TRUE, wincx);
  1997.     if (rv != SECSuccess) {
  1998. PK11_FreeSlot(slot);
  1999. return NULL;
  2000.     }
  2001.     keyHandle = PK11_MatchItem(slot,certHandle,CKO_PRIVATE_KEY);
  2002.     if (keyHandle == CK_INVALID_KEY) { 
  2003. PK11_FreeSlot(slot);
  2004. return NULL;
  2005.     }
  2006.     privKey =  PK11_MakePrivKey(slot, nullKey, PR_TRUE, keyHandle, wincx);
  2007.     PK11_FreeSlot(slot);
  2008.     return privKey;
  2009. }
  2011. CK_OBJECT_HANDLE
  2012. pk11_FindPubKeyByAnyCert(CERTCertificate *cert, PK11SlotInfo **slot, void *wincx)
  2013. {
  2014.     CK_OBJECT_HANDLE certHandle;
  2015.     CK_OBJECT_HANDLE keyHandle;
  2017.     certHandle = PK11_FindObjectForCert(cert, wincx, slot);
  2018.     if (certHandle == CK_INVALID_KEY) {
  2019.  return CK_INVALID_KEY;
  2020.     }
  2021.     keyHandle = PK11_MatchItem(*slot,certHandle,CKO_PUBLIC_KEY);
  2022.     if (keyHandle == CK_INVALID_KEY) { 
  2023. PK11_FreeSlot(*slot);
  2024. return CK_INVALID_KEY;
  2025.     }
  2026.     return keyHandle;
  2027. }
  2029. SECKEYPrivateKey *
  2030. PK11_FindKeyByKeyID(PK11SlotInfo *slot, SECItem *keyID, void *wincx)
  2031. {
  2032.     CK_OBJECT_HANDLE keyHandle;
  2033.     SECKEYPrivateKey *privKey;
  2035.     keyHandle = pk11_FindPrivateKeyFromCertID(slot, keyID);
  2036.     if (keyHandle == CK_INVALID_KEY) { 
  2037. return NULL;
  2038.     }
  2039.     privKey =  PK11_MakePrivKey(slot, nullKey, PR_TRUE, keyHandle, wincx);
  2040.     return privKey;
  2041. }
  2043. /*
  2044.  * find the number of certs in the slot with the same subject name
  2045.  */
  2046. int
  2047. PK11_NumberCertsForCertSubject(CERTCertificate *cert)
  2048. {
  2049.     CK_OBJECT_CLASS certClass = CKO_CERTIFICATE;
  2050.     CK_ATTRIBUTE theTemplate[] = {
  2051. { CKA_CLASS, NULL, 0 },
  2052. { CKA_SUBJECT, NULL, 0 },
  2053.     };
  2054.     CK_ATTRIBUTE *attr = theTemplate;
  2055.    int templateSize = sizeof(theTemplate)/sizeof(theTemplate[0]);
  2057.     PK11_SETATTRS(attr,CKA_CLASS, &certClass, sizeof(certClass)); attr++;
  2058.     PK11_SETATTRS(attr,CKA_SUBJECT,cert->derSubject.data,cert->derSubject.len);
  2060.     if ((cert->slot == NULL) || (cert->slot->isInternal)) {
  2061. return 0;
  2062.     }
  2064.     return PK11_NumberObjectsFor(cert->slot,theTemplate,templateSize);
  2065. }
  2067. /*
  2068.  *  Walk all the certs with the same subject
  2069.  */
  2070. SECStatus
  2071. PK11_TraverseCertsForSubject(CERTCertificate *cert,
  2072.         SECStatus(* callback)(CERTCertificate*, void *), void *arg)
  2073. {
  2074.     if(!cert) {
  2075. return SECFailure;
  2076.     }
  2078.     return PK11_TraverseCertsForSubjectInSlot(cert, cert->slot, callback, arg);
  2079. }
  2081. SECStatus
  2082. PK11_TraverseCertsForSubjectInSlot(CERTCertificate *cert, PK11SlotInfo *slot,
  2083. SECStatus(* callback)(CERTCertificate*, void *), void *arg)
  2084. {
  2085.     pk11DoCertCallback caller;
  2086.     pk11TraverseSlotCert callarg;
  2087.     CK_OBJECT_CLASS certClass = CKO_CERTIFICATE;
  2088.     CK_ATTRIBUTE theTemplate[] = {
  2089. { CKA_CLASS, NULL, 0 },
  2090. { CKA_SUBJECT, NULL, 0 },
  2091.     };
  2092.     CK_ATTRIBUTE *attr = theTemplate;
  2093.    int templateSize = sizeof(theTemplate)/sizeof(theTemplate[0]);
  2095.     PK11_SETATTRS(attr,CKA_CLASS, &certClass, sizeof(certClass)); attr++;
  2096.     PK11_SETATTRS(attr,CKA_SUBJECT,cert->derSubject.data,cert->derSubject.len);
  2098.     if ((slot == NULL) || (slot->isInternal)) {
  2099. return SECSuccess;
  2100.     }
  2101.     caller.noslotcallback = callback;
  2102.     caller.callback = NULL;
  2103.     caller.callbackArg = arg;
  2104.     callarg.callback = pk11_DoCerts;
  2105.     callarg.callbackArg = (void *) & caller;
  2106.     callarg.findTemplate = theTemplate;
  2107.     callarg.templateCount = templateSize;
  2108.     
  2109.     return PK11_TraverseSlot(slot, &callarg);
  2110. }
  2112. SECStatus
  2113. PK11_TraverseCertsForNicknameInSlot(SECItem *nickname, PK11SlotInfo *slot,
  2114. SECStatus(* callback)(CERTCertificate*, void *), void *arg)
  2115. {
  2116.     pk11DoCertCallback caller;
  2117.     pk11TraverseSlotCert callarg;
  2118.     CK_OBJECT_CLASS certClass = CKO_CERTIFICATE;
  2119.     CK_ATTRIBUTE theTemplate[] = {
  2120. { CKA_CLASS, NULL, 0 },
  2121. { CKA_LABEL, NULL, 0 },
  2122.     };
  2123.     CK_ATTRIBUTE *attr = theTemplate;
  2124.     int templateSize = sizeof(theTemplate)/sizeof(theTemplate[0]);
  2126.     if(!nickname) {
  2127. return SECSuccess;
  2128.     }
  2130.     PK11_SETATTRS(attr,CKA_CLASS, &certClass, sizeof(certClass)); attr++;
  2131.     PK11_SETATTRS(attr,CKA_LABEL,nickname->data,nickname->len);
  2133.     if ((slot == NULL) || (slot->isInternal)) {
  2134. return SECSuccess;
  2135.     }
  2137.     caller.noslotcallback = callback;
  2138.     caller.callback = NULL;
  2139.     caller.callbackArg = arg;
  2140.     callarg.callback = pk11_DoCerts;
  2141.     callarg.callbackArg = (void *) & caller;
  2142.     callarg.findTemplate = theTemplate;
  2143.     callarg.templateCount = templateSize;
  2145.     return PK11_TraverseSlot(slot, &callarg);
  2146. }
  2148. SECStatus
  2149. PK11_TraverseCertsInSlot(PK11SlotInfo *slot,
  2150. SECStatus(* callback)(CERTCertificate*, void *), void *arg)
  2151. {
  2152.     pk11DoCertCallback caller;
  2153.     pk11TraverseSlotCert callarg;
  2154.     CK_OBJECT_CLASS certClass = CKO_CERTIFICATE;
  2155.     CK_ATTRIBUTE theTemplate[] = {
  2156. { CKA_CLASS, NULL, 0 },
  2157.     };
  2158.     CK_ATTRIBUTE *attr = theTemplate;
  2159.     int templateSize = sizeof(theTemplate)/sizeof(theTemplate[0]);
  2161.     PK11_SETATTRS(attr,CKA_CLASS, &certClass, sizeof(certClass)); attr++;
  2163.     if (slot == NULL) {
  2164. return SECSuccess;
  2165.     }
  2167.     caller.noslotcallback = callback;
  2168.     caller.callback = NULL;
  2169.     caller.callbackArg = arg;
  2170.     callarg.callback = pk11_DoCerts;
  2171.     callarg.callbackArg = (void *) & caller;
  2172.     callarg.findTemplate = theTemplate;
  2173.     callarg.templateCount = templateSize;
  2175.     return PK11_TraverseSlot(slot, &callarg);
  2176. }
  2178. /*
  2179.  * return the certificate associated with a derCert 
  2180.  */
  2181. CERTCertificate *
  2182. PK11_FindCertFromDERCert(PK11SlotInfo *slot, CERTCertificate *cert,
  2183.  void *wincx)
  2184. {
  2185.     CK_OBJECT_CLASS certClass = CKO_CERTIFICATE;
  2186.     CK_ATTRIBUTE theTemplate[] = {
  2187. { CKA_VALUE, NULL, 0 },
  2188. { CKA_CLASS, NULL, 0 }
  2189.     };
  2190.     /* if you change the array, change the variable below as well */
  2191.     int tsize = sizeof(theTemplate)/sizeof(theTemplate[0]);
  2192.     CK_OBJECT_HANDLE certh;
  2193.     CK_ATTRIBUTE *attrs = theTemplate;
  2194.     SECStatus rv;
  2196.     PK11_SETATTRS(attrs, CKA_VALUE, cert->derCert.data, 
  2197. cert->derCert.len); attrs++;
  2198.     PK11_SETATTRS(attrs, CKA_CLASS, &certClass, sizeof(certClass));
  2200.     /*
  2201.      * issue the find
  2202.      */
  2203.     if ( !PK11_IsFriendly(slot)) {
  2204. rv = PK11_Authenticate(slot, PR_TRUE, wincx);
  2205. if (rv != SECSuccess) return NULL;
  2206.     }
  2208.     certh = pk11_getcerthandle(slot,cert,theTemplate,tsize);
  2209.     if (certh == CK_INVALID_KEY) {
  2210. return NULL;
  2211.     }
  2212.     return PK11_MakeCertFromHandle(slot, certh, NULL);
  2213. } 
  2215. /*
  2216.  * return the certificate associated with a derCert 
  2217.  */
  2218. CERTCertificate *
  2219. PK11_FindCertFromDERSubjectAndNickname(PK11SlotInfo *slot, 
  2220. CERTCertificate *cert, 
  2221. char *nickname, void *wincx)
  2222. {
  2223.     CK_OBJECT_CLASS certClass = CKO_CERTIFICATE;
  2224.     CK_ATTRIBUTE theTemplate[] = {
  2225. { CKA_SUBJECT, NULL, 0 },
  2226. { CKA_LABEL, NULL, 0 },
  2227. { CKA_CLASS, NULL, 0 }
  2228.     };
  2229.     /* if you change the array, change the variable below as well */
  2230.     int tsize = sizeof(theTemplate)/sizeof(theTemplate[0]);
  2231.     CK_OBJECT_HANDLE certh;
  2232.     CK_ATTRIBUTE *attrs = theTemplate;
  2233.     SECStatus rv;
  2235.     PK11_SETATTRS(attrs, CKA_SUBJECT, cert->derSubject.data, 
  2236. cert->derSubject.len); attrs++;
  2237.     PK11_SETATTRS(attrs, CKA_LABEL, nickname, PORT_Strlen(nickname));
  2238.     PK11_SETATTRS(attrs, CKA_CLASS, &certClass, sizeof(certClass));
  2240.     /*
  2241.      * issue the find
  2242.      */
  2243.     if ( !PK11_IsFriendly(slot)) {
  2244. rv = PK11_Authenticate(slot, PR_TRUE, wincx);
  2245. if (rv != SECSuccess) return NULL;
  2246.     }
  2248.     certh = pk11_getcerthandle(slot,cert,theTemplate,tsize);
  2249.     if (certh == CK_INVALID_KEY) {
  2250. return NULL;
  2251.     }
  2253.     return PK11_MakeCertFromHandle(slot, certh, NULL);
  2254. }
  2256. /*
  2257.  * import a cert for a private key we have already generated. Set the label
  2258.  * on both to be the nickname.
  2259.  */
  2260. static CK_OBJECT_HANDLE 
  2261. pk11_findKeyObjectByDERCert(PK11SlotInfo *slot, CERTCertificate *cert, 
  2262. void *wincx)
  2263. {
  2264.     SECItem *keyID;
  2265.     CK_OBJECT_HANDLE key;
  2266.     SECStatus rv;
  2268.     if((slot == NULL) || (cert == NULL)) {
  2269. return CK_INVALID_KEY;
  2270.     }
  2272.     keyID = pk11_mkcertKeyID(cert);
  2273.     if(keyID == NULL) {
  2274. return CK_INVALID_KEY;
  2275.     }
  2277.     key = CK_INVALID_KEY;
  2279.     rv = PK11_Authenticate(slot, PR_TRUE, wincx);
  2280.     if (rv != SECSuccess) goto loser;
  2282.     key = pk11_FindPrivateKeyFromCertID(slot, keyID);
  2284. loser:
  2285.     SECITEM_ZfreeItem(keyID, PR_TRUE);
  2286.     return key;
  2287. }
  2289. SECKEYPrivateKey *
  2290. PK11_FindKeyByDERCert(PK11SlotInfo *slot, CERTCertificate *cert, 
  2291. void *wincx)
  2292. {
  2293.     CK_OBJECT_HANDLE keyHandle;
  2295.     if((slot == NULL) || (cert == NULL)) {
  2296. return NULL;
  2297.     }
  2299.     keyHandle = pk11_findKeyObjectByDERCert(slot, cert, wincx);
  2300.     if (keyHandle == CK_INVALID_KEY) {
  2301. return NULL;
  2302.     }
  2304.     return PK11_MakePrivKey(slot,nullKey,PR_TRUE,keyHandle,wincx);
  2305. }
  2307. SECStatus
  2308. PK11_ImportCertForKeyToSlot(PK11SlotInfo *slot, CERTCertificate *cert, 
  2309. char *nickname, 
  2310. PRBool addCertUsage,void *wincx)
  2311. {
  2312.     CK_OBJECT_HANDLE keyHandle;
  2314.     if((slot == NULL) || (cert == NULL) || (nickname == NULL)) {
  2315. return SECFailure;
  2316.     }
  2318.     keyHandle = pk11_findKeyObjectByDERCert(slot, cert, wincx);
  2319.     if (keyHandle == CK_INVALID_KEY) {
  2320. return SECFailure;
  2321.     }
  2323.     return PK11_ImportCert(slot, cert, keyHandle, nickname, addCertUsage);
  2324. }   
  2327. /* remove when the real version comes out */
  2328. #define SEC_OID_MISSI_KEA 300  /* until we have v3 stuff merged */
  2329. PRBool
  2330. KEAPQGCompare(CERTCertificate *server,CERTCertificate *cert) {
  2332.     if ( SECKEY_KEAParamCompare(server,cert) == SECEqual ) {
  2333.         return PR_TRUE;
  2334.     } else {
  2335. return PR_FALSE;
  2336.     }
  2337. }
  2339. PRBool
  2340. PK11_FortezzaHasKEA(CERTCertificate *cert) {
  2341.    /* look at the subject and see if it is a KEA for MISSI key */
  2342.    SECOidData *oid;
  2344.    if ((cert->trust == NULL) ||
  2345.        ((cert->trust->sslFlags & CERTDB_USER) != CERTDB_USER)) {
  2346.        return PR_FALSE;
  2347.    }
  2349.    oid = SECOID_FindOID(&cert->subjectPublicKeyInfo.algorithm.algorithm);
  2352.    return (PRBool)((oid->offset == SEC_OID_MISSI_KEA_DSS_OLD) || 
  2353. (oid->offset == SEC_OID_MISSI_KEA_DSS) ||
  2354. (oid->offset == SEC_OID_MISSI_KEA)) ;
  2355. }
  2357. /*
  2358.  * Find a kea cert on this slot that matches the domain of it's peer
  2359.  */
  2360. static CERTCertificate
  2361. *pk11_GetKEAMate(PK11SlotInfo *slot,CERTCertificate *peer)
  2362. {
  2363.     int i;
  2364.     CERTCertificate *returnedCert = NULL;
  2366.     for (i=0; i < slot->cert_count; i++) {
  2367. CERTCertificate *cert = slot->cert_array[i];
  2369. if (PK11_FortezzaHasKEA(cert) && KEAPQGCompare(peer,cert)) {
  2370. returnedCert = CERT_DupCertificate(cert);
  2371. break;
  2372. }
  2373.     }
  2374.     return returnedCert;
  2375. }
  2377. /*
  2378.  * The following is a FORTEZZA only Certificate request. We call this when we
  2379.  * are doing a non-client auth SSL connection. We are only interested in the
  2380.  * fortezza slots, and we are only interested in certs that share the same root
  2381.  * key as the server.
  2382.  */
  2383. CERTCertificate *
  2384. PK11_FindBestKEAMatch(CERTCertificate *server, void *wincx)
  2385. {
  2386.     PK11SlotList *keaList = PK11_GetAllTokens(CKM_KEA_KEY_DERIVE,
  2387. PR_FALSE,PR_TRUE,wincx);
  2388.     PK11SlotListElement *le;
  2389.     CERTCertificate *returnedCert = NULL;
  2390.     SECStatus rv;
  2392.     /* loop through all the fortezza tokens */
  2393.     for (le = keaList->head; le; le = le->next) {
  2394.         rv = PK11_Authenticate(le->slot, PR_TRUE, wincx);
  2395.         if (rv != SECSuccess) continue;
  2396. if (le->slot->session == CK_INVALID_SESSION) {
  2397.     continue;
  2398. }
  2399. returnedCert = pk11_GetKEAMate(le->slot,server);
  2400. if (returnedCert) break;
  2401.     }
  2402.     PK11_FreeSlotList(keaList);
  2404.     return returnedCert;
  2405. }
  2407. /*
  2408.  * find a matched pair of kea certs to key exchange parameters from one 
  2409.  * fortezza card to another as necessary.
  2410.  */
  2411. SECStatus
  2412. PK11_GetKEAMatchedCerts(PK11SlotInfo *slot1, PK11SlotInfo *slot2,
  2413. CERTCertificate **cert1, CERTCertificate **cert2)
  2414. {
  2415.     PK11SlotList *keaList = PK11_GetAllTokens(CKM_KEA_KEY_DERIVE,
  2416. PR_FALSE,PR_TRUE,NULL);
  2417.     CERTCertificate *returnedCert = NULL;
  2418.     int i;
  2420.     for (i=0; i < slot1->cert_count; i++) {
  2421. CERTCertificate *cert = slot1->cert_array[i];
  2423. if (PK11_FortezzaHasKEA(cert)) {
  2424.     returnedCert = pk11_GetKEAMate(slot2,cert);
  2425.     if (returnedCert != NULL) {
  2426. *cert2 = returnedCert;
  2427. *cert1 = CERT_DupCertificate(cert);
  2428. return SECSuccess;
  2429.     }
  2430. }
  2431.     }
  2432.     return SECFailure;
  2433. }
  2435. SECOidTag 
  2436. PK11_FortezzaMapSig(SECOidTag algTag)
  2437. {
  2438.     switch (algTag) {
  2439.     case SEC_OID_MISSI_KEA_DSS:
  2440.     case SEC_OID_MISSI_DSS:
  2441.     case SEC_OID_MISSI_DSS_OLD:
  2442.     case SEC_OID_MISSI_KEA_DSS_OLD:
  2443.     case SEC_OID_BOGUS_DSA_SIGNATURE_WITH_SHA1_DIGEST:
  2444. return SEC_OID_ANSIX9_DSA_SIGNATURE;
  2445.     default:
  2446. break;
  2447.     }
  2448.     return algTag;
  2449. }
  2451. /*
  2452.  * return the private key From a given Cert
  2453.  */
  2454. CK_OBJECT_HANDLE
  2455. PK11_FindCertInSlot(PK11SlotInfo *slot, CERTCertificate *cert, void *wincx)
  2456. {
  2457.     CK_OBJECT_CLASS certClass = CKO_CERTIFICATE;
  2458.     CK_ATTRIBUTE theTemplate[] = {
  2459. { CKA_VALUE, NULL, 0 },
  2460. { CKA_CLASS, NULL, 0 }
  2461.     };
  2462.     /* if you change the array, change the variable below as well */
  2463.     int tsize = sizeof(theTemplate)/sizeof(theTemplate[0]);
  2464.     CK_ATTRIBUTE *attrs = theTemplate;
  2465.     SECStatus rv;
  2467.     PK11_SETATTRS(attrs, CKA_VALUE, cert->derCert.data,
  2468. cert->derCert.len); attrs++;
  2469.     PK11_SETATTRS(attrs, CKA_CLASS, &certClass, sizeof(certClass));
  2471.     /*
  2472.      * issue the find
  2473.      */
  2474.     rv = PK11_Authenticate(slot, PR_TRUE, wincx);
  2475.     if (rv != SECSuccess) {
  2476. return CK_INVALID_KEY;
  2477.     }
  2479.     return pk11_getcerthandle(slot,cert,theTemplate,tsize);
  2480. }
  2482. SECItem *
  2483. PK11_GetKeyIDFromCert(CERTCertificate *cert, void *wincx)
  2484. {
  2485.     CK_OBJECT_HANDLE handle;
  2486.     PK11SlotInfo *slot = NULL;
  2487.     CK_ATTRIBUTE theTemplate[] = {
  2488. { CKA_ID, NULL, 0 },
  2489.     };
  2490.     int tsize = sizeof(theTemplate)/sizeof(theTemplate[0]);
  2491.     SECItem *item = NULL;
  2492.     CK_RV crv;
  2494.     handle = PK11_FindObjectForCert(cert,wincx,&slot);
  2495.     if (handle == CK_INVALID_KEY) {
  2496. goto loser;
  2497.     }
  2500.     crv = PK11_GetAttributes(NULL,slot,handle,theTemplate,tsize);
  2501.     if (crv != CKR_OK) {
  2502. PORT_SetError( PK11_MapError(crv) );
  2503. goto loser;
  2504.     }
  2506.     item = PORT_ZNew(SECItem);
  2507.     if (item) {
  2508.         item->data = theTemplate[0].pValue;
  2509.         item->len = theTemplate[0].ulValueLen;
  2510.     }
  2513. loser:
  2514.     PK11_FreeSlot(slot);
  2515.     return item;
  2516. }
  2518. SECItem *
  2519. PK11_GetKeyIDFromPrivateKey(SECKEYPrivateKey *key, void *wincx)
  2520. {
  2521.     CK_ATTRIBUTE theTemplate[] = {
  2522. { CKA_ID, NULL, 0 },
  2523.     };
  2524.     int tsize = sizeof(theTemplate)/sizeof(theTemplate[0]);
  2525.     SECItem *item = NULL;
  2526.     CK_RV crv;
  2528.     crv = PK11_GetAttributes(NULL,key->pkcs11Slot,key->pkcs11ID,
  2529. theTemplate,tsize);
  2530.     if (crv != CKR_OK) {
  2531. PORT_SetError( PK11_MapError(crv) );
  2532. goto loser;
  2533.     }
  2535.     item = PORT_ZNew(SECItem);
  2536.     if (item) {
  2537.         item->data = theTemplate[0].pValue;
  2538.         item->len = theTemplate[0].ulValueLen;
  2539.     }
  2542. loser:
  2543.     return item;
  2544. }