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

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

CA认证

开发平台：

WINDOWS

respcmn.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.  */
  36. #include "cmmf.h"
  37. #include "cmmfi.h"
  38. #include "secitem.h"
  40. SECStatus 
  41. cmmf_DestroyPKIStatusInfo (CMMFPKIStatusInfo *info, PRBool freeit)
  42. {
  43.     if (info->status.data != NULL) {
  44.         PORT_Free(info->status.data);
  45.     }
  46.     if (info->statusString.data != NULL) {
  47.         PORT_Free(info->statusString.data);
  48.     }
  49.     if (info->failInfo.data != NULL) {
  50.         PORT_Free(info->failInfo.data);
  51.     }
  52.     if (freeit) {
  53.         PORT_Free(info);
  54.     }
  55.     return SECSuccess;
  56. }
  58. SECStatus
  59. CMMF_DestroyCertResponse(CMMFCertResponse *inCertResp)
  60. {
  61.     PORT_Assert(inCertResp != NULL);
  62.     if (inCertResp != NULL) {
  63.         if (inCertResp->certReqId.data != NULL) {
  64.     PORT_Free(inCertResp->certReqId.data);
  65. }
  66. cmmf_DestroyPKIStatusInfo(&inCertResp->status, PR_FALSE);
  67. if (inCertResp->certifiedKeyPair != NULL) {
  68.     CMMF_DestroyCertifiedKeyPair(inCertResp->certifiedKeyPair);
  69. }
  70. PORT_Free(inCertResp);
  71.     }
  72.     return SECSuccess;
  73. }
  75. SECStatus
  76. CMMF_DestroyCertRepContent(CMMFCertRepContent *inCertRepContent)
  77. {
  78.     CMMFCertifiedKeyPair *certKeyPair;
  79.     int i;
  81.     PORT_Assert(inCertRepContent != NULL);
  82.     if (inCertRepContent != NULL && inCertRepContent->poolp != NULL) {
  83. if (!inCertRepContent->isDecoded) {
  84.   if (inCertRepContent->response != NULL) {
  85.     for (i=0; inCertRepContent->response[i] != NULL; i++) {
  86.         certKeyPair = inCertRepContent->response[i]->certifiedKeyPair;
  87. if (certKeyPair != NULL                    &&
  88.     certKeyPair->certOrEncCert.choice == cmmfCertificate &&
  89.     certKeyPair->certOrEncCert.cert.certificate != NULL) {
  90.     CERT_DestroyCertificate
  91.                  (certKeyPair->certOrEncCert.cert.certificate);
  92. }
  93.     }
  94.   }
  95.   if (inCertRepContent->caPubs != NULL) {
  96.     for (i=0; inCertRepContent->caPubs[i] != NULL; i++) {
  97.         CERT_DestroyCertificate(inCertRepContent->caPubs[i]);
  98.     }
  99.   }
  100. }
  101.         PORT_FreeArena(inCertRepContent->poolp, PR_TRUE);
  102.     }
  103.     return SECSuccess;
  104. }
  106. SECStatus
  107. CMMF_DestroyPOPODecKeyChallContent(CMMFPOPODecKeyChallContent *inDecKeyCont)
  108. {
  109.     PORT_Assert(inDecKeyCont != NULL);
  110.     if (inDecKeyCont != NULL && inDecKeyCont->poolp) {
  111.         PORT_FreeArena(inDecKeyCont->poolp, PR_FALSE);
  112.     }
  113.     return SECSuccess;
  114. }
  116. SECStatus
  117. crmf_create_prtime(SECItem *src, PRTime **dest)
  118. {
  119.    *dest = PORT_ZNew(PRTime);
  120.     return DER_UTCTimeToTime(*dest, src);
  121. }
  123. CRMFCertExtension*
  124. crmf_copy_cert_extension(PRArenaPool *poolp, CRMFCertExtension *inExtension)
  125. {
  126.     PRBool             isCritical;
  127.     SECOidTag          id;
  128.     SECItem           *data;
  129.     CRMFCertExtension *newExt;
  131.     PORT_Assert(inExtension != NULL);
  132.     if (inExtension == NULL) {
  133.         return NULL;
  134.     }
  135.     id         = CRMF_CertExtensionGetOidTag(inExtension);
  136.     isCritical = CRMF_CertExtensionGetIsCritical(inExtension);
  137.     data       = CRMF_CertExtensionGetValue(inExtension);
  138.     newExt = crmf_create_cert_extension(poolp, id, 
  139. isCritical,
  140. data);
  141.     SECITEM_FreeItem(data, PR_TRUE);
  142.     return newExt;    
  143. }
  145. static SECItem*
  146. cmmf_encode_certificate(CERTCertificate *inCert)
  147. {
  148.     return SEC_ASN1EncodeItem(NULL, NULL, inCert, 
  149.       SEC_SignedCertificateTemplate);
  150. }
  152. CERTCertList*
  153. cmmf_MakeCertList(CERTCertificate **inCerts)
  154. {
  155.     CERTCertList    *certList;
  156.     CERTCertificate *currCert;
  157.     SECItem         *derCert, *freeCert = NULL;
  158.     SECStatus        rv;
  159.     int              i;
  161.     certList = CERT_NewCertList();
  162.     if (certList == NULL) {
  163.         return NULL;
  164.     }
  165.     for (i=0; inCerts[i] != NULL; i++) {
  166.         derCert = &inCerts[i]->derCert;
  167. if (derCert->data == NULL) {
  168.     derCert = freeCert = cmmf_encode_certificate(inCerts[i]);
  169. }
  170. currCert=CERT_DecodeDERCertificate(derCert, PR_TRUE, NULL);
  171. if (freeCert != NULL) {
  172.     SECITEM_FreeItem(freeCert, PR_TRUE);
  173.     freeCert = NULL;
  174. }
  175. if (currCert == NULL) {
  176.     goto loser;
  177. }
  178. rv = CERT_AddCertToListTail(certList, currCert);
  179. if (rv != SECSuccess) {
  180.     goto loser;
  181. }
  182.     }
  183.     return certList;
  184.  loser:
  185.     CERT_DestroyCertList(certList);
  186.     return NULL;
  187. }
  189. CMMFPKIStatus
  190. cmmf_PKIStatusInfoGetStatus(CMMFPKIStatusInfo *inStatus)
  191. {
  192.     long derVal;
  194.     derVal = DER_GetInteger(&inStatus->status);
  195.     if (derVal == -1 || derVal < cmmfGranted || derVal >= cmmfNumPKIStatus) {
  196.         return cmmfNoPKIStatus;
  197.     }
  198.     return (CMMFPKIStatus)derVal;
  199. }
  201. int
  202. CMMF_CertRepContentGetNumResponses(CMMFCertRepContent *inCertRepContent)
  203. {
  204.     int numResponses = 0;
  205.     PORT_Assert (inCertRepContent != NULL);
  206.     if (inCertRepContent != NULL && inCertRepContent->response != NULL) {
  207.         while (inCertRepContent->response[numResponses] != NULL) {
  208.     numResponses++;
  209. }
  210.     }
  211.     return numResponses;
  212. }
  215. SECStatus
  216. cmmf_DestroyCertOrEncCert(CMMFCertOrEncCert *certOrEncCert, PRBool freeit)
  217. {
  218.     switch (certOrEncCert->choice) {
  219.     case cmmfCertificate:
  220.         CERT_DestroyCertificate(certOrEncCert->cert.certificate);
  221. break;
  222.     case cmmfEncryptedCert:
  223.         crmf_destroy_encrypted_value(certOrEncCert->cert.encryptedCert,
  224.      PR_TRUE);
  225. break;
  226.     default:
  227.         break;
  228.     }
  229.     if (freeit) {
  230.         PORT_Free(certOrEncCert);
  231.     }
  232.     return SECSuccess;
  233. }
  235. SECStatus
  236. cmmf_copy_secitem (PRArenaPool *poolp, SECItem *dest, SECItem *src)
  237. {
  238.     SECStatus rv;
  240.     if (src->data != NULL) {
  241.         rv = SECITEM_CopyItem(poolp, dest, src);
  242.     } else {
  243.         dest->data = NULL;
  244. dest->len  = 0;
  245. rv = SECSuccess;
  246.     }
  247.     return rv;
  248. }
  250. SECStatus
  251. CMMF_DestroyCertifiedKeyPair(CMMFCertifiedKeyPair *inCertKeyPair)
  252. {
  253.     PORT_Assert(inCertKeyPair != NULL);
  254.     if (inCertKeyPair != NULL) {
  255.         cmmf_DestroyCertOrEncCert(&inCertKeyPair->certOrEncCert, PR_FALSE);
  256.     }
  257.     if (inCertKeyPair->privateKey) {
  258.         crmf_destroy_encrypted_value(inCertKeyPair->privateKey, PR_TRUE);
  259.     }
  260.     if (inCertKeyPair->derPublicationInfo.data) {
  261.         PORT_Free(inCertKeyPair->derPublicationInfo.data);
  262.     }
  263.     PORT_Free(inCertKeyPair);
  264.     return SECSuccess;
  265. }
  267. SECStatus
  268. cmmf_CopyCertResponse(PRArenaPool      *poolp, 
  269.       CMMFCertResponse *dest,
  270.       CMMFCertResponse *src)
  271. {
  272.     SECStatus rv;
  274.     if (src->certReqId.data != NULL) {
  275.         rv = SECITEM_CopyItem(poolp, &dest->certReqId, &src->certReqId);
  276. if (rv != SECSuccess) {
  277.     return rv;
  278. }
  279.     }
  280.     rv = cmmf_CopyPKIStatusInfo(poolp, &dest->status, &src->status);
  281.     if (rv != SECSuccess) {
  282.         return rv;
  283.     }
  284.     if (src->certifiedKeyPair != NULL) {
  285.         dest->certifiedKeyPair = (poolp == NULL) ?
  286.                                   PORT_ZNew(CMMFCertifiedKeyPair) :
  287.                           PORT_ArenaZNew(poolp, CMMFCertifiedKeyPair);
  288. if (dest->certifiedKeyPair == NULL) {
  289.     return SECFailure;
  290. }
  291.         rv = cmmf_CopyCertifiedKeyPair(poolp, dest->certifiedKeyPair,
  292.        src->certifiedKeyPair);
  293. if (rv != SECSuccess) {
  294.     return rv;
  295. }
  296.     }
  297.     return SECSuccess;
  298. }
  300. static SECStatus
  301. cmmf_CopyCertOrEncCert(PRArenaPool *poolp, CMMFCertOrEncCert *dest,
  302.        CMMFCertOrEncCert *src)
  303. {
  304.     SECStatus           rv = SECSuccess;
  305.     CRMFEncryptedValue *encVal;
  307.     dest->choice = src->choice;
  308.     rv = cmmf_copy_secitem(poolp, &dest->derValue, &src->derValue);
  309.     switch (src->choice) {
  310.     case cmmfCertificate:
  311.         dest->cert.certificate = CERT_DupCertificate(src->cert.certificate);
  312. break;
  313.     case cmmfEncryptedCert:
  314.         dest->cert.encryptedCert = encVal = (poolp == NULL) ?
  315.                              PORT_ZNew(CRMFEncryptedValue) :
  316.      PORT_ArenaZNew(poolp, CRMFEncryptedValue);
  317. if (encVal == NULL) {
  318.     return SECFailure;
  319. }
  320.         rv = crmf_copy_encryptedvalue(poolp, src->cert.encryptedCert, encVal);
  321. if (rv != SECSuccess) {
  322.     return rv;
  323. }
  324. break;
  325.     default:
  326.         rv = SECFailure;
  327.     }
  328.     return rv;
  329. }
  331. SECStatus
  332. cmmf_CopyCertifiedKeyPair(PRArenaPool *poolp, CMMFCertifiedKeyPair *dest,
  333.   CMMFCertifiedKeyPair *src)
  334. {
  335.     SECStatus rv;
  337.     rv = cmmf_CopyCertOrEncCert(poolp, &dest->certOrEncCert, 
  338. &src->certOrEncCert);
  339.     if (rv != SECSuccess) {
  340.         return rv;
  341.     }
  343.     if (src->privateKey != NULL) {
  344.         CRMFEncryptedValue *encVal;
  346. encVal = dest->privateKey = (poolp == NULL) ?
  347.                              PORT_ZNew(CRMFEncryptedValue) :
  348.                                      PORT_ArenaZNew(poolp, CRMFEncryptedValue);
  349. if (encVal == NULL) {
  350.     return SECFailure;
  351. }
  352.         rv = crmf_copy_encryptedvalue(poolp, src->privateKey, 
  353.       dest->privateKey);
  354. if (rv != SECSuccess) {
  355.     return rv;
  356. }
  357.     }
  358.     rv = cmmf_copy_secitem(poolp, &dest->derPublicationInfo, 
  359.    &src->derPublicationInfo);
  360.     return rv;
  361. }
  363. SECStatus
  364. cmmf_CopyPKIStatusInfo(PRArenaPool *poolp, CMMFPKIStatusInfo *dest,
  365.        CMMFPKIStatusInfo *src)
  366. {
  367.     SECStatus rv;
  369.     rv = cmmf_copy_secitem (poolp, &dest->status, &src->status);
  370.     if (rv != SECSuccess) {
  371.         return rv;
  372.     }
  373.     rv = cmmf_copy_secitem (poolp, &dest->statusString, &src->statusString);
  374.     if (rv != SECSuccess) {
  375.         return rv;
  376.     }
  377.     rv = cmmf_copy_secitem (poolp, &dest->failInfo, &src->failInfo);
  378.     return rv;
  379. }
  381. CERTCertificate*
  382. cmmf_CertOrEncCertGetCertificate(CMMFCertOrEncCert *certOrEncCert,
  383.  CERTCertDBHandle  *certdb)
  384. {
  385.     if (certOrEncCert->choice           != cmmfCertificate || 
  386. certOrEncCert->cert.certificate == NULL) {
  387.         return NULL;
  388.     }
  389.     return CERT_NewTempCertificate(certdb,
  390.    &certOrEncCert->cert.certificate->derCert,
  391.    NULL, PR_FALSE, PR_TRUE);
  392. }
  394. SECStatus 
  395. cmmf_PKIStatusInfoSetStatus(CMMFPKIStatusInfo    *statusInfo,
  396.     PRArenaPool          *poolp,
  397.     CMMFPKIStatus         inStatus)
  398. {
  399.     SECItem *dummy;
  400.     
  401.     if (inStatus <cmmfGranted || inStatus >= cmmfNumPKIStatus) {
  402.         return SECFailure;
  403.     }
  405.     dummy = SEC_ASN1EncodeInteger(poolp, &statusInfo->status, inStatus); 
  406.     PORT_Assert(dummy == &statusInfo->status);
  407.     if (dummy != &statusInfo->status) {
  408.         SECITEM_FreeItem(dummy, PR_TRUE);
  409. return SECFailure;
  410.     }
  411.     return SECSuccess;
  412. }