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

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

CA认证

开发平台：

WINDOWS

cmmfrec.c：源码内容
  1. /* -*- Mode: C; tab-width: 8 -*-*/
  2. /*
  3.  * The contents of this file are subject to the Mozilla Public
  4.  * License Version 1.1 (the "License"); you may not use this file
  5.  * except in compliance with the License. You may obtain a copy of
  6.  * the License at http://www.mozilla.org/MPL/
  7.  * 
  8.  * Software distributed under the License is distributed on an "AS
  9.  * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
  10.  * implied. See the License for the specific language governing
  11.  * rights and limitations under the License.
  12.  * 
  13.  * The Original Code is the Netscape security libraries.
  14.  * 
  15.  * The Initial Developer of the Original Code is Netscape
  16.  * Communications Corporation.  Portions created by Netscape are 
  17.  * Copyright (C) 1994-2000 Netscape Communications Corporation.  All
  18.  * Rights Reserved.
  19.  * 
  20.  * Contributor(s):
  21.  * 
  22.  * Alternatively, the contents of this file may be used under the
  23.  * terms of the GNU General Public License Version 2 or later (the
  24.  * "GPL"), in which case the provisions of the GPL are applicable 
  25.  * instead of those above.  If you wish to allow use of your 
  26.  * version of this file only under the terms of the GPL and not to
  27.  * allow others to use your version of this file under the MPL,
  28.  * indicate your decision by deleting the provisions above and
  29.  * replace them with the notice and other provisions required by
  30.  * the GPL.  If you do not delete the provisions above, a recipient
  31.  * may use your version of this file under either the MPL or the
  32.  * GPL.
  33.  */
  35. /*
  36.  * This file will implement the functions related to key recovery in 
  37.  * CMMF
  38.  */
  40. #include "cmmf.h"
  41. #include "cmmfi.h"
  42. #include "secitem.h"
  43. #include "keyhi.h"
  45. CMMFKeyRecRepContent*
  46. CMMF_CreateKeyRecRepContent(void)
  47. {
  48.     PRArenaPool          *poolp;
  49.     CMMFKeyRecRepContent *keyRecContent;
  51.     poolp = PORT_NewArena(CRMF_DEFAULT_ARENA_SIZE);
  52.     if (poolp == NULL) {
  53.         return NULL;
  54.     }
  55.     keyRecContent = PORT_ArenaZNew(poolp, CMMFKeyRecRepContent);
  56.     if (keyRecContent == NULL) {
  57.         PORT_FreeArena(poolp, PR_FALSE);
  58. return NULL;
  59.     }
  60.     keyRecContent->poolp = poolp;
  61.     return keyRecContent;
  62. }
  64. SECStatus
  65. CMMF_DestroyKeyRecRepContent(CMMFKeyRecRepContent *inKeyRecRep)
  66. {
  67.     PORT_Assert(inKeyRecRep != NULL);
  68.     if (inKeyRecRep != NULL && inKeyRecRep->poolp != NULL) {
  69.         if (!inKeyRecRep->isDecoded) {
  70.     int i;
  72.     CERT_DestroyCertificate(inKeyRecRep->newSigCert);
  73.     if (inKeyRecRep->caCerts != NULL) {
  74.         for (i=0; inKeyRecRep->caCerts[i] != NULL; i++) {
  75.     CERT_DestroyCertificate(inKeyRecRep->caCerts[i]);
  76. }
  77.     }
  78.     if (inKeyRecRep->keyPairHist != NULL) {
  79.         for (i=0; inKeyRecRep->keyPairHist[i] != NULL; i++) {
  80.     if (inKeyRecRep->keyPairHist[i]->certOrEncCert.choice ==
  81. cmmfCertificate) {
  82.         CERT_DestroyCertificate(inKeyRecRep->keyPairHist[i]->
  83.        certOrEncCert.cert.certificate);
  84.     }
  85. }
  86.     }
  87. }
  88.         PORT_FreeArena(inKeyRecRep->poolp, PR_TRUE);
  89.     }
  90.     return SECSuccess;
  91. }
  93. SECStatus
  94. CMMF_KeyRecRepContentSetPKIStatusInfoStatus(CMMFKeyRecRepContent *inKeyRecRep,
  95.     CMMFPKIStatus         inPKIStatus)
  96. {
  97.     PORT_Assert(inKeyRecRep != NULL && inPKIStatus >= cmmfGranted &&
  98. inPKIStatus < cmmfNumPKIStatus);
  99.     if (inKeyRecRep == NULL) {
  100.         return SECFailure;
  101.     }
  102.     
  103.     return cmmf_PKIStatusInfoSetStatus(&inKeyRecRep->status, 
  104.        inKeyRecRep->poolp,
  105.        inPKIStatus);
  106. }
  108. SECStatus
  109. CMMF_KeyRecRepContentSetNewSignCert(CMMFKeyRecRepContent *inKeyRecRep,
  110.     CERTCertificate      *inNewSignCert)
  111. {
  112.     PORT_Assert (inKeyRecRep != NULL && inNewSignCert != NULL);
  113.     if (inKeyRecRep == NULL || inNewSignCert == NULL) {
  114.         return SECFailure;
  115.     }
  116.     inKeyRecRep->newSigCert = CERT_DupCertificate(inNewSignCert);
  117.     return (inKeyRecRep->newSigCert == NULL) ? SECFailure : SECSuccess;    
  118. }
  120. SECStatus
  121. CMMF_KeyRecRepContentSetCACerts(CMMFKeyRecRepContent *inKeyRecRep,
  122. CERTCertList         *inCACerts)
  123. {
  124.     SECStatus rv;
  125.     void *mark;
  127.     PORT_Assert (inKeyRecRep != NULL && inCACerts != NULL);
  128.     if (inKeyRecRep == NULL || inCACerts == NULL) {
  129.         return SECFailure;
  130.     }
  131.     mark = PORT_ArenaMark(inKeyRecRep->poolp);
  132.     rv = cmmf_ExtractCertsFromList(inCACerts, inKeyRecRep->poolp,
  133.    &inKeyRecRep->caCerts);
  134.     if (rv != SECSuccess) {
  135.         PORT_ArenaRelease(inKeyRecRep->poolp, mark);
  136.     } else {
  137.         PORT_ArenaUnmark(inKeyRecRep->poolp, mark);
  138.     }
  139.     return rv;
  140. }
  142. SECStatus
  143. CMMF_KeyRecRepContentSetCertifiedKeyPair(CMMFKeyRecRepContent *inKeyRecRep,
  144.  CERTCertificate      *inCert,
  145.  SECKEYPrivateKey     *inPrivKey,
  146.  SECKEYPublicKey      *inPubKey)
  147. {
  148.     CMMFCertifiedKeyPair *keyPair;
  149.     CRMFEncryptedValue   *dummy;
  150.     PRArenaPool          *poolp;
  151.     void                 *mark;
  152.     SECStatus             rv;
  154.     PORT_Assert (inKeyRecRep != NULL &&
  155.  inCert      != NULL &&
  156.  inPrivKey   != NULL &&
  157.  inPubKey    != NULL);
  158.     if (inKeyRecRep == NULL ||
  159. inCert      == NULL ||
  160. inPrivKey   == NULL ||
  161. inPubKey    == NULL) {
  162.         return SECFailure;
  163.     }
  164.     poolp = inKeyRecRep->poolp;
  165.     mark = PORT_ArenaMark(poolp);
  166.     if (inKeyRecRep->keyPairHist == NULL) {
  167.         inKeyRecRep->keyPairHist = PORT_ArenaNewArray(poolp, 
  168.       CMMFCertifiedKeyPair*,
  169.       (CMMF_MAX_KEY_PAIRS+1));
  170. if (inKeyRecRep->keyPairHist == NULL) {
  171.     goto loser;
  172. }
  173. inKeyRecRep->allocKeyPairs = CMMF_MAX_KEY_PAIRS;
  174. inKeyRecRep->numKeyPairs   = 0;
  175.     }
  177.     if (inKeyRecRep->allocKeyPairs == inKeyRecRep->numKeyPairs) {
  178.         goto loser;
  179.     }
  180.     
  181.     keyPair = PORT_ArenaZNew(poolp, CMMFCertifiedKeyPair);
  182.     if (keyPair == NULL) {
  183.         goto loser;
  184.     }
  185.     rv = cmmf_CertOrEncCertSetCertificate(&keyPair->certOrEncCert,
  186.   poolp, inCert);
  187.     if (rv != SECSuccess) {
  188.         goto loser;
  189.     }
  190.     keyPair->privateKey = PORT_ArenaZNew(poolp, CRMFEncryptedValue);
  191.     if (keyPair->privateKey == NULL) {
  192.         goto loser;
  193.     }
  194.     dummy = crmf_create_encrypted_value_wrapped_privkey(inPrivKey, inPubKey, 
  195. keyPair->privateKey);
  196.     PORT_Assert(dummy = keyPair->privateKey);
  197.     if (dummy != keyPair->privateKey) {
  198.         crmf_destroy_encrypted_value(dummy, PR_TRUE);
  199. goto loser;
  200.     }
  201.     inKeyRecRep->keyPairHist[inKeyRecRep->numKeyPairs] = keyPair;
  202.     inKeyRecRep->numKeyPairs++;
  203.     inKeyRecRep->keyPairHist[inKeyRecRep->numKeyPairs] = NULL;
  204.     PORT_ArenaUnmark(poolp, mark);
  205.     return SECSuccess;
  207.  loser:
  208.     PORT_ArenaRelease(poolp, mark);
  209.     return SECFailure;
  210. }
  212. CMMFPKIStatus
  213. CMMF_KeyRecRepContentGetPKIStatusInfoStatus(CMMFKeyRecRepContent *inKeyRecRep)
  214. {
  215.     PORT_Assert(inKeyRecRep != NULL);
  216.     if (inKeyRecRep == NULL) {
  217.         return cmmfNoPKIStatus;
  218.     }
  219.     return cmmf_PKIStatusInfoGetStatus(&inKeyRecRep->status);
  220. }
  222. CERTCertificate*
  223. CMMF_KeyRecRepContentGetNewSignCert(CMMFKeyRecRepContent *inKeyRecRep)
  224. {
  225.     PORT_Assert(inKeyRecRep != NULL);
  226.     if (inKeyRecRep             == NULL ||
  227. inKeyRecRep->newSigCert == NULL) {
  228.         return NULL;
  229.     }
  230.     return CERT_NewTempCertificate(CERT_GetDefaultCertDB(), 
  231.           &inKeyRecRep->newSigCert->signatureWrap.data,
  232.    NULL, PR_FALSE, PR_TRUE);
  233. }
  235. CERTCertList*
  236. CMMF_KeyRecRepContentGetCACerts(CMMFKeyRecRepContent *inKeyRecRep)
  237. {
  238.     PORT_Assert(inKeyRecRep != NULL);
  239.     if (inKeyRecRep == NULL || inKeyRecRep->caCerts == NULL) {
  240.         return NULL;
  241.     }
  242.     return cmmf_MakeCertList(inKeyRecRep->caCerts);
  243. }
  245. int 
  246. CMMF_KeyRecRepContentGetNumKeyPairs(CMMFKeyRecRepContent *inKeyRecRep)
  247. {
  248.     PORT_Assert(inKeyRecRep != NULL);
  249.     return (inKeyRecRep == NULL) ? 0 : inKeyRecRep->numKeyPairs;
  250. }
  252. PRBool
  253. cmmf_KeyRecRepContentIsValidIndex(CMMFKeyRecRepContent *inKeyRecRep,
  254.   int                   inIndex)
  255. {
  256.     int numKeyPairs = CMMF_KeyRecRepContentGetNumKeyPairs(inKeyRecRep);
  257.     
  258.     return (PRBool)(inIndex >= 0 && inIndex < numKeyPairs);
  259. }
  261. CMMFCertifiedKeyPair*
  262. CMMF_KeyRecRepContentGetCertKeyAtIndex(CMMFKeyRecRepContent *inKeyRecRep,
  263.        int                   inIndex)
  264. {
  265.     CMMFCertifiedKeyPair *newKeyPair;
  266.     SECStatus             rv;
  268.     PORT_Assert(inKeyRecRep != NULL &&
  269. cmmf_KeyRecRepContentIsValidIndex(inKeyRecRep, inIndex));
  270.     if (inKeyRecRep == NULL ||
  271. !cmmf_KeyRecRepContentIsValidIndex(inKeyRecRep, inIndex)) {
  272.         return NULL;
  273.     }
  274.     newKeyPair = PORT_ZNew(CMMFCertifiedKeyPair);
  275.     if (newKeyPair == NULL) {
  276.         return NULL;
  277.     }
  278.     rv = cmmf_CopyCertifiedKeyPair(NULL, newKeyPair, 
  279.    inKeyRecRep->keyPairHist[inIndex]);
  280.     if (rv != SECSuccess) {
  281.         CMMF_DestroyCertifiedKeyPair(newKeyPair);
  282. newKeyPair = NULL;
  283.     }
  284.     return newKeyPair;
  285. }
  287. SECStatus 
  288. CMMF_CertifiedKeyPairUnwrapPrivKey(CMMFCertifiedKeyPair *inKeyPair,
  289.    SECKEYPrivateKey     *inPrivKey,
  290.    SECItem              *inNickName,
  291.    PK11SlotInfo         *inSlot,
  292.    CERTCertDBHandle     *inCertdb,
  293.    SECKEYPrivateKey    **destPrivKey,
  294.    void                 *wincx)
  295. {
  296.     CERTCertificate *cert;
  297.     SECItem keyUsageValue = {siBuffer, NULL, 0};
  298.     unsigned char keyUsage = 0x0;
  299.     SECKEYPublicKey *pubKey;
  300.     SECStatus rv;
  302.     PORT_Assert(inKeyPair != NULL &&
  303. inPrivKey != NULL && inCertdb != NULL);
  304.     if (inKeyPair             == NULL ||
  305. inPrivKey             == NULL ||
  306. inKeyPair->privateKey == NULL ||
  307. inCertdb              == NULL) {
  308.         return SECFailure;
  309.     }
  310.     
  311.     cert = CMMF_CertifiedKeyPairGetCertificate(inKeyPair, inCertdb);
  312.     CERT_FindKeyUsageExtension(cert, &keyUsageValue);
  313.     if (keyUsageValue.data != NULL) {
  314.         keyUsage = keyUsageValue.data[3];
  315. PORT_Free(keyUsageValue.data);
  316.     }
  317.     pubKey = CERT_ExtractPublicKey(cert);
  318.     rv = crmf_encrypted_value_unwrap_priv_key(NULL, inKeyPair->privateKey,
  319.       inPrivKey, pubKey, 
  320.       inNickName, inSlot, keyUsage, 
  321.       destPrivKey, wincx);
  322.     SECKEY_DestroyPublicKey(pubKey);
  323.     CERT_DestroyCertificate(cert);
  324.     return rv;
  325. }
  328. PRBool 
  329. CMMF_KeyRecRepContentHasCACerts(CMMFKeyRecRepContent *inKeyRecRep)
  330. {
  331.     PORT_Assert(inKeyRecRep != NULL);
  332.     if (inKeyRecRep == NULL) {
  333.         return PR_FALSE;
  334.     }
  335.     return (PRBool)(inKeyRecRep->caCerts    != NULL && 
  336.     inKeyRecRep->caCerts[0] != NULL);
  337. }