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

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

CA认证

开发平台：

WINDOWS

p12exp.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.  */
  34. #include "plarena.h"
  35. #include "secitem.h"
  36. #include "secoid.h"
  37. #include "seccomon.h"
  38. #include "secport.h"
  39. #include "cert.h"
  40. #include "pkcs12.h"
  41. #include "p12local.h"
  42. #include "secpkcs7.h"
  43. #include "secasn1.h"
  44. #include "secerr.h"
  45. #include "p12plcy.h"
  47. /* release the memory taken up by the list of nicknames */
  48. static void
  49. sec_pkcs12_destroy_nickname_list(SECItem **nicknames)
  50. {
  51.     int i = 0;
  53.     if(nicknames == NULL) {
  54. return;
  55.     }
  57.     while(nicknames[i] != NULL) {
  58. SECITEM_FreeItem(nicknames[i], PR_FALSE);
  59. i++;
  60.     }
  62.     PORT_Free(nicknames);
  63. }
  64.    
  65. /* release the memory taken up by the list of certificates */ 
  66. static void
  67. sec_pkcs12_destroy_certificate_list(CERTCertificate **ref_certs)
  68. {
  69.     int i = 0;
  71.     if(ref_certs == NULL) {
  72. return;
  73.     }
  75.     while(ref_certs[i] != NULL) {
  76. CERT_DestroyCertificate(ref_certs[i]);
  77. i++;
  78.     }
  79. }
  81. static void
  82. sec_pkcs12_destroy_cinfos_for_cert_bags(SEC_PKCS12CertAndCRLBag *certBag)
  83. {
  84.     int j = 0;
  85.     j = 0;
  86.     while(certBag->certAndCRLs[j] != NULL) {
  87. SECOidTag certType = SECOID_FindOIDTag(&certBag->certAndCRLs[j]->BagID);
  88. if(certType == SEC_OID_PKCS12_X509_CERT_CRL_BAG) {
  89.     SEC_PKCS12X509CertCRL *x509;
  90.     x509 = certBag->certAndCRLs[j]->value.x509;
  91.     SEC_PKCS7DestroyContentInfo(&x509->certOrCRL);
  92. }
  93. j++;
  94.     }
  95. }
  97. /* destroy all content infos since they were not allocated in common
  98.  * pool
  99.  */
  100. static void
  101. sec_pkcs12_destroy_cert_content_infos(SEC_PKCS12SafeContents *safe,
  102.       SEC_PKCS12Baggage *baggage)
  103. {
  104.     int i, j;
  106.     if((safe != NULL) && (safe->contents != NULL)) {
  107. i = 0;
  108. while(safe->contents[i] != NULL) {
  109.     SECOidTag bagType = SECOID_FindOIDTag(&safe->contents[i]->safeBagType);
  110.     if(bagType == SEC_OID_PKCS12_CERT_AND_CRL_BAG_ID) {
  111. SEC_PKCS12CertAndCRLBag *certBag;
  112. certBag = safe->contents[i]->safeContent.certAndCRLBag;
  113. sec_pkcs12_destroy_cinfos_for_cert_bags(certBag);
  114.     }
  115.     i++;
  116. }
  117.     }
  119.     if((baggage != NULL) && (baggage->bags != NULL)) {
  120. i = 0;
  121. while(baggage->bags[i] != NULL) { 
  122.     if(baggage->bags[i]->unencSecrets != NULL) {
  123. j = 0;
  124. while(baggage->bags[i]->unencSecrets[j] != NULL) {
  125.     SECOidTag bagType;
  126.     bagType = SECOID_FindOIDTag(&baggage->bags[i]->unencSecrets[j]->safeBagType);
  127.     if(bagType == SEC_OID_PKCS12_CERT_AND_CRL_BAG_ID) {
  128. SEC_PKCS12CertAndCRLBag *certBag;
  129. certBag = baggage->bags[i]->unencSecrets[j]->safeContent.certAndCRLBag;
  130. sec_pkcs12_destroy_cinfos_for_cert_bags(certBag);
  131.     }
  132.     j++;
  133. }
  134.     }
  135.     i++;
  136. }
  137.     }
  138. }
  140. /* convert the nickname list from a NULL termincated Char list
  141.  * to a NULL terminated SECItem list
  142.  */
  143. static SECItem **
  144. sec_pkcs12_convert_nickname_list(char **nicknames)
  145. {
  146.     SECItem **nicks;
  147.     int i, j;
  148.     PRBool error = PR_FALSE;
  150.     if(nicknames == NULL) {
  151. return NULL;
  152.     }
  154.     i = j = 0;
  155.     while(nicknames[i] != NULL) {
  156. i++;
  157.     }
  159.     /* allocate the space and copy the data */
  160.     nicks = (SECItem **)PORT_ZAlloc(sizeof(SECItem *) * (i + 1));
  161.     if(nicks != NULL) {
  162. for(j = 0; ((j < i) && (error == PR_FALSE)); j++) {
  163.     nicks[j] = (SECItem *)PORT_ZAlloc(sizeof(SECItem));
  164.     if(nicks[j] != NULL) {
  165. nicks[j]->data = 
  166.     (unsigned char *)PORT_ZAlloc(PORT_Strlen(nicknames[j])+1);
  167. if(nicks[j]->data != NULL) {
  168.     nicks[j]->len = PORT_Strlen(nicknames[j]);
  169.     PORT_Memcpy(nicks[j]->data, nicknames[j], nicks[j]->len);
  170.     nicks[j]->data[nicks[j]->len] = 0;
  171. } else {
  172.     error = PR_TRUE;
  173. }
  174.     } else {
  175.        error = PR_TRUE;
  176.     }
  177. }
  178.     }
  180.     if(error == PR_TRUE) {
  181.         for(i = 0; i < j; i++) { 
  182.     SECITEM_FreeItem(nicks[i], PR_TRUE);
  183. }
  184. PORT_Free(nicks);
  185. nicks = NULL;
  186.     }
  188.     return nicks;
  189. }
  191. /* package the certificate add_cert into PKCS12 structures,
  192.  * retrieve the certificate chain for the cert and return
  193.  * the packaged contents.
  194.  * poolp -- common memory pool;
  195.  * add_cert -- certificate to package up
  196.  * nickname for the certificate 
  197.  * a return of NULL indicates an error
  198.  */
  199. static SEC_PKCS12CertAndCRL *
  200. sec_pkcs12_get_cert(PRArenaPool *poolp,
  201.        CERTCertificate *add_cert, 
  202.        SECItem *nickname)
  203. {
  204.     SEC_PKCS12CertAndCRL *cert;
  205.     SEC_PKCS7ContentInfo *cinfo;
  206.     SGNDigestInfo *t_di;
  207.     void *mark;
  208.     SECStatus rv;
  210.     if((poolp == NULL) || (add_cert == NULL) || (nickname == NULL)) {
  211.      return NULL;
  212.     }
  213.     mark = PORT_ArenaMark(poolp);
  215.     cert = sec_pkcs12_new_cert_crl(poolp, SEC_OID_PKCS12_X509_CERT_CRL_BAG);
  216.     if(cert != NULL) {
  218. /* copy the nickname */
  219. rv = SECITEM_CopyItem(poolp, &cert->nickname, nickname);
  220. if(rv != SECSuccess) {
  221.     PORT_SetError(SEC_ERROR_NO_MEMORY);
  222.     cert = NULL;
  223. } else {
  225.     /* package the certificate and cert chain into a NULL signer
  226.      * PKCS 7 SignedData content Info and prepare it for encoding 
  227.      * since we cannot use DER_ANY_TEMPLATE
  228.      */
  229.     cinfo = SEC_PKCS7CreateCertsOnly(add_cert, PR_TRUE, NULL);
  230.     rv = SEC_PKCS7PrepareForEncode(cinfo, NULL, NULL, NULL);
  232.     /* thumbprint the certificate */
  233.     if((cinfo != NULL) && (rv == SECSuccess))
  234.     {
  235. PORT_Memcpy(&cert->value.x509->certOrCRL, cinfo, sizeof(*cinfo));
  236. t_di = sec_pkcs12_compute_thumbprint(&add_cert->derCert);
  237. if(t_di != NULL)
  238. {
  239.     /* test */
  240.     rv = SGN_CopyDigestInfo(poolp, &cert->value.x509->thumbprint,
  241.          t_di);
  242.     if(rv != SECSuccess) {
  243. cert = NULL;
  244. PORT_SetError(SEC_ERROR_NO_MEMORY);
  245.     }
  246.     SGN_DestroyDigestInfo(t_di);
  247. }
  248. else
  249.     cert = NULL;
  250.     }
  251. }
  252.     }
  254.     if (cert == NULL) {
  255. PORT_ArenaRelease(poolp, mark);
  256.     } else {
  257. PORT_ArenaUnmark(poolp, mark);
  258.     }
  260.     return cert;
  261. }
  263. /* package the private key associated with the certificate and 
  264.  * return the appropriate PKCS 12 structure 
  265.  * poolp common memory pool
  266.  * nickname key nickname
  267.  * cert -- cert to look up
  268.  * wincx -- window handle 
  269.  * an error is indicated by a return of NULL
  270.  */
  271. static SEC_PKCS12PrivateKey *
  272. sec_pkcs12_get_private_key(PRArenaPool *poolp,
  273.    SECItem *nickname,
  274.    CERTCertificate *cert,
  275.    void *wincx)
  276. {
  277.     SECKEYPrivateKeyInfo *pki;
  278.     SEC_PKCS12PrivateKey *pk;
  279.     SECStatus rv;
  280.     void *mark;
  282.     if((poolp == NULL) || (nickname == NULL)) {
  283. return NULL;
  284.     }
  286.     mark = PORT_ArenaMark(poolp);
  288.     /* retrieve key from the data base */
  289.     pki = PK11_ExportPrivateKeyInfo(nickname, cert, wincx);
  290.     if(pki == NULL) {
  291. PORT_ArenaRelease(poolp, mark);
  292. PORT_SetError(SEC_ERROR_PKCS12_UNABLE_TO_EXPORT_KEY);
  293. return NULL;
  294.     }
  296.     pk = (SEC_PKCS12PrivateKey *)PORT_ArenaZAlloc(poolp,
  297.   sizeof(SEC_PKCS12PrivateKey));
  298.     if(pk != NULL) {
  299. rv = sec_pkcs12_init_pvk_data(poolp, &pk->pvkData);
  301. if(rv == SECSuccess) {
  302.     /* copy the key into poolp memory space */
  303.     rv = SECKEY_CopyPrivateKeyInfo(poolp, &pk->pkcs8data, pki);
  304.     if(rv == SECSuccess) {
  305. rv = SECITEM_CopyItem(poolp, &pk->pvkData.nickname, nickname);
  306.     }
  307. }
  309. if(rv != SECSuccess) {
  310.     PORT_SetError(SEC_ERROR_NO_MEMORY);
  311.     pk = NULL;
  312. }
  313.     } else {
  314. PORT_SetError(SEC_ERROR_NO_MEMORY); 
  315.     }
  317.     /* destroy private key, zeroing out data */
  318.     SECKEY_DestroyPrivateKeyInfo(pki, PR_TRUE);
  319.     if (pk == NULL) {
  320. PORT_ArenaRelease(poolp, mark);
  321.     } else {
  322. PORT_ArenaUnmark(poolp, mark);
  323.     }
  325.     return pk;
  326. }
  328. /* get a shrouded key item associated with a certificate
  329.  * return the appropriate PKCS 12 structure 
  330.  * poolp common memory pool
  331.  * nickname key nickname
  332.  * cert -- cert to look up
  333.  * wincx -- window handle 
  334.  * an error is indicated by a return of NULL
  335.  */
  336. static SEC_PKCS12ESPVKItem *
  337. sec_pkcs12_get_shrouded_key(PRArenaPool *poolp,
  338.     SECItem *nickname,
  339.     CERTCertificate *cert,
  340.     SECOidTag algorithm, 
  341.     SECItem *pwitem,
  342.     PKCS12UnicodeConvertFunction unicodeFn,
  343.     void *wincx)
  344. {
  345.     SECKEYEncryptedPrivateKeyInfo *epki;
  346.     SEC_PKCS12ESPVKItem *pk;
  347.     void *mark;
  348.     SECStatus rv;
  349.     PK11SlotInfo *slot = NULL;
  350.     PRBool swapUnicodeBytes = PR_FALSE;
  352. #ifdef IS_LITTLE_ENDIAN
  353.     swapUnicodeBytes = PR_TRUE;
  354. #endif
  356.     if((poolp == NULL) || (nickname == NULL))
  357. return NULL;
  359.     mark = PORT_ArenaMark(poolp);
  361.     /* use internal key slot */
  362.     slot = PK11_GetInternalKeySlot();
  364.     /* retrieve encrypted prviate key */
  365.     epki = PK11_ExportEncryptedPrivateKeyInfo(slot, algorithm, pwitem, 
  366.            nickname, cert, 1, 0, NULL);
  367.     PK11_FreeSlot(slot);
  368.     if(epki == NULL) {
  369. PORT_SetError(SEC_ERROR_PKCS12_UNABLE_TO_EXPORT_KEY);
  370. PORT_ArenaRelease(poolp, mark);
  371. return NULL;
  372.     }
  374.     /* create a private key and store the data into the poolp memory space */
  375.     pk = sec_pkcs12_create_espvk(poolp, SEC_OID_PKCS12_PKCS8_KEY_SHROUDING);
  376.     if(pk != NULL) {
  377. rv = sec_pkcs12_init_pvk_data(poolp, &pk->espvkData);
  378. rv = SECITEM_CopyItem(poolp, &pk->espvkData.nickname, nickname);
  379. pk->espvkCipherText.pkcs8KeyShroud = 
  380.     (SECKEYEncryptedPrivateKeyInfo *)PORT_ArenaZAlloc(poolp,
  381. sizeof(SECKEYEncryptedPrivateKeyInfo));
  382. if((pk->espvkCipherText.pkcs8KeyShroud != NULL)  && (rv == SECSuccess)) {
  383.     rv = SECKEY_CopyEncryptedPrivateKeyInfo(poolp, 
  384. pk->espvkCipherText.pkcs8KeyShroud, epki);
  385.     if(rv == SECSuccess) {
  386. rv = (*unicodeFn)(poolp, &pk->espvkData.uniNickName, nickname, 
  387.   PR_TRUE, swapUnicodeBytes);
  388.     }
  389. }
  391. if(rv != SECSuccess) {
  392.     PORT_SetError(SEC_ERROR_NO_MEMORY);
  393.     pk = NULL;
  394. }
  395.     }
  397.     SECKEY_DestroyEncryptedPrivateKeyInfo(epki, PR_TRUE);
  398.     if(pk == NULL) {
  399. PORT_ArenaRelease(poolp, mark);
  400.     } else {
  401. PORT_ArenaUnmark(poolp, mark);
  402.     }
  404.     return pk;
  405. }
  407. /* add a thumbprint to a private key associated certs list 
  408.  * pvk is the area where the list is stored
  409.  * thumb is the thumbprint to copy
  410.  * a return of SECFailure indicates an error 
  411.  */
  412. static SECStatus 
  413. sec_pkcs12_add_thumbprint(SEC_PKCS12PVKSupportingData *pvk,
  414.   SGNDigestInfo *thumb)
  415. {
  416.     SGNDigestInfo **thumb_list = NULL;
  417.     int nthumbs, size;
  418.     void *mark, *dummy;
  419.     SECStatus rv = SECFailure;
  421.     if((pvk == NULL) || (thumb == NULL)) {
  422. return SECFailure;
  423.     }
  425.     mark = PORT_ArenaMark(pvk->poolp);
  427.     thumb_list = pvk->assocCerts;
  428.     nthumbs = pvk->nThumbs;
  430.     /* allocate list space needed -- either growing or allocating 
  431.      * list must be NULL terminated 
  432.      */
  433.     size = sizeof(SGNDigestInfo *);
  434.     dummy = PORT_ArenaGrow(pvk->poolp, thumb_list, (size * (nthumbs + 1)),
  435.         (size * (nthumbs + 2)));
  436.     thumb_list = dummy;
  437.     if(dummy != NULL) {
  438. thumb_list[nthumbs] = (SGNDigestInfo *)PORT_ArenaZAlloc(pvk->poolp, 
  439. sizeof(SGNDigestInfo));
  440. if(thumb_list[nthumbs] != NULL) {
  441.     SGN_CopyDigestInfo(pvk->poolp, thumb_list[nthumbs], thumb);
  442.     nthumbs += 1;
  443.     thumb_list[nthumbs] = 0;
  444. } else {
  445.     dummy = NULL;
  446. }
  447.     }
  449.     if(dummy == NULL) {
  450.      PORT_ArenaRelease(pvk->poolp, mark);
  451. return SECFailure;
  452.     } 
  454.     pvk->assocCerts = thumb_list;
  455.     pvk->nThumbs = nthumbs;
  457.     PORT_ArenaUnmark(pvk->poolp, mark);
  458.     return SECSuccess;
  459. }
  461. /* search the list of shrouded keys in the baggage for the desired
  462.  * name.  return a pointer to the item.  a return of NULL indicates
  463.  * that no match was present or that an error occurred.
  464.  */
  465. static SEC_PKCS12ESPVKItem *
  466. sec_pkcs12_get_espvk_by_name(SEC_PKCS12Baggage *luggage, 
  467.      SECItem *name)
  468. {
  469.     PRBool found = PR_FALSE;
  470.     SEC_PKCS12ESPVKItem *espvk = NULL;
  471.     int i, j;
  472.     SECComparison rv = SECEqual;
  473.     SECItem *t_name;
  474.     SEC_PKCS12BaggageItem *bag;
  476.     if((luggage == NULL) || (name == NULL)) {
  477. return NULL;
  478.     }
  480.     i = 0;
  481.     while((found == PR_FALSE) && (i < luggage->luggage_size)) {
  482. j = 0;
  483. bag = luggage->bags[i];
  484. while((found == PR_FALSE) && (j < bag->nEspvks)) {
  485.     espvk = bag->espvks[j];
  486.     if(espvk->poolp == NULL) {
  487. espvk->poolp = luggage->poolp;
  488.     }
  489.     t_name = SECITEM_DupItem(&espvk->espvkData.nickname);
  490.     if(t_name != NULL) {
  491. rv = SECITEM_CompareItem(name, t_name);
  492. if(rv == SECEqual) {
  493.     found = PR_TRUE;
  494. }
  495. SECITEM_FreeItem(t_name, PR_TRUE);
  496.     } else {
  497. PORT_SetError(SEC_ERROR_NO_MEMORY);
  498. return NULL;
  499.     }
  500.     j++;
  501. }
  502. i++;
  503.     }
  505.     if(found != PR_TRUE) {
  506. PORT_SetError(SEC_ERROR_PKCS12_UNABLE_TO_LOCATE_OBJECT_BY_NAME);
  507. return NULL;
  508.     }
  510.     return espvk;
  511. }
  513. /* locates a certificate and copies the thumbprint to the
  514.  * appropriate private key
  515.  */
  516. static SECStatus 
  517. sec_pkcs12_propagate_thumbprints(SECItem **nicknames,
  518.  CERTCertificate **ref_certs,
  519.  SEC_PKCS12SafeContents *safe,
  520.  SEC_PKCS12Baggage *baggage)
  521. {
  522.     SEC_PKCS12CertAndCRL *cert;
  523.     SEC_PKCS12PrivateKey *key;
  524.     SEC_PKCS12ESPVKItem *espvk;
  525.     int i;
  526.     PRBool error = PR_FALSE;
  527.     SECStatus rv = SECFailure;
  529.     if((nicknames == NULL) || (safe == NULL)) {
  530. return SECFailure;
  531.     }
  533.     i = 0;
  534.     while((nicknames[i] != NULL) && (error == PR_FALSE)) {
  535. /* process all certs */
  536. cert = (SEC_PKCS12CertAndCRL *)sec_pkcs12_find_object(safe, baggage,
  537. SEC_OID_PKCS12_CERT_AND_CRL_BAG_ID,
  538. nicknames[i], NULL);
  539. if(cert != NULL) {
  540.     /* locate key and copy thumbprint */
  541.     key = (SEC_PKCS12PrivateKey *)sec_pkcs12_find_object(safe, baggage,
  542.      SEC_OID_PKCS12_KEY_BAG_ID,
  543.      nicknames[i], NULL);
  544.     if(key != NULL) {
  545. key->pvkData.poolp = key->poolp;
  546. rv = sec_pkcs12_add_thumbprint(&key->pvkData, 
  547. &cert->value.x509->thumbprint);
  548. if(rv == SECFailure)
  549.     error = PR_TRUE;  /* XXX Set error? */
  550.     }
  552.     /* look in the baggage as well...*/
  553.     if((baggage != NULL) && (error == PR_FALSE)) {
  554. espvk = sec_pkcs12_get_espvk_by_name(baggage, nicknames[i]);
  555. if(espvk != NULL) {
  556.     espvk->espvkData.poolp = espvk->poolp;
  557.     rv = sec_pkcs12_add_thumbprint(&espvk->espvkData,
  558. &cert->value.x509->thumbprint);
  559.     if(rv == SECFailure)
  560. error = PR_TRUE;  /* XXX Set error? */
  561. }
  562.     }
  563. }
  564. i++;
  565.     }
  567.     if(error == PR_TRUE) {
  568. return SECFailure;
  569.     }
  571.     return SECSuccess;
  572. }
  574. /* append a safe bag to the end of the safe contents list */
  575. SECStatus 
  576. sec_pkcs12_append_safe_bag(SEC_PKCS12SafeContents *safe,
  577.    SEC_PKCS12SafeBag *bag)
  578. {
  579.     int size;
  580.     void *mark = NULL, *dummy = NULL;
  582.     if((bag == NULL) || (safe == NULL))
  583. return SECFailure;
  585.     mark = PORT_ArenaMark(safe->poolp);
  587.     size = (safe->safe_size * sizeof(SEC_PKCS12SafeBag *));
  588.     
  589.     if(safe->safe_size > 0) {
  590. dummy = (SEC_PKCS12SafeBag **)PORT_ArenaGrow(safe->poolp, 
  591.      safe->contents, 
  592.      size, 
  593.      (size + sizeof(SEC_PKCS12SafeBag *)));
  594. safe->contents = dummy;
  595.     } else {
  596. safe->contents = (SEC_PKCS12SafeBag **)PORT_ArenaZAlloc(safe->poolp, 
  597.     (2 * sizeof(SEC_PKCS12SafeBag *)));
  598. dummy = safe->contents;
  599.     }
  601.     if(dummy == NULL) {
  602. PORT_SetError(SEC_ERROR_NO_MEMORY);
  603. goto loser;
  604.     }
  606.     safe->contents[safe->safe_size] = bag;
  607.     safe->safe_size++;
  608.     safe->contents[safe->safe_size] = NULL;
  610.     PORT_ArenaUnmark(safe->poolp, mark);
  611.     return SECSuccess;
  613. loser:
  614.     PORT_ArenaRelease(safe->poolp, mark);
  615.     return SECFailure;
  616. }
  618. /* append a certificate onto the end of a cert bag */
  619. static SECStatus 
  620. sec_pkcs12_append_cert_to_bag(PRArenaPool *arena,
  621.       SEC_PKCS12SafeBag *safebag,
  622.       CERTCertificate *cert,
  623.       SECItem *nickname)
  624. {
  625.     int size;
  626.     void *dummy = NULL, *mark = NULL;
  627.     SEC_PKCS12CertAndCRL *p12cert;
  628.     SEC_PKCS12CertAndCRLBag *bag;
  630.     if((arena == NULL) || (safebag == NULL) || 
  631.      (cert == NULL) || (nickname == NULL)) {
  632. return SECFailure;
  633.     }
  635.     bag = safebag->safeContent.certAndCRLBag;
  636.     if(bag == NULL) {
  637. return SECFailure;
  638.     }
  640.     mark = PORT_ArenaMark(arena);
  642.     p12cert = sec_pkcs12_get_cert(arena, cert, nickname);
  643.     if(p12cert == NULL) {
  644. PORT_ArenaRelease(bag->poolp, mark);
  645. return SECFailure;
  646.     }
  648.     size = bag->bag_size * sizeof(SEC_PKCS12CertAndCRL *);
  649.     if(bag->bag_size > 0) {
  650. dummy = (SEC_PKCS12CertAndCRL **)PORT_ArenaGrow(bag->poolp,
  651.     bag->certAndCRLs, size, size + sizeof(SEC_PKCS12CertAndCRL *));
  652. bag->certAndCRLs = dummy;
  653.     } else {
  654. bag->certAndCRLs = (SEC_PKCS12CertAndCRL **)PORT_ArenaZAlloc(bag->poolp,
  655.     (2 * sizeof(SEC_PKCS12CertAndCRL *)));
  656. dummy = bag->certAndCRLs;
  657.     }
  659.     if(dummy == NULL) {
  660. PORT_SetError(SEC_ERROR_NO_MEMORY);
  661. goto loser;
  662.     }
  664.     bag->certAndCRLs[bag->bag_size] = p12cert;
  665.     bag->bag_size++;
  666.     bag->certAndCRLs[bag->bag_size] = NULL;
  668.     PORT_ArenaUnmark(bag->poolp, mark);
  669.     return SECSuccess;
  671. loser:
  672.     PORT_ArenaRelease(bag->poolp, mark);
  673.     return SECFailure;
  674. }
  676. /* append a key onto the end of a list of keys in a key bag */
  677. SECStatus 
  678. sec_pkcs12_append_key_to_bag(SEC_PKCS12SafeBag *safebag,
  679.      SEC_PKCS12PrivateKey *pk)
  680. {
  681.     void *mark, *dummy;
  682.     SEC_PKCS12PrivateKeyBag *bag;
  683.     int size;
  685.     if((safebag == NULL) || (pk == NULL))
  686. return SECFailure;
  688.     bag = safebag->safeContent.keyBag;
  689.     if(bag == NULL) {
  690. return SECFailure;
  691.     }
  693.     mark = PORT_ArenaMark(bag->poolp);
  695.     size = (bag->bag_size * sizeof(SEC_PKCS12PrivateKey *));
  697.     if(bag->bag_size > 0) {
  698. dummy = (SEC_PKCS12PrivateKey **)PORT_ArenaGrow(bag->poolp,
  699. bag->privateKeys, 
  700. size, 
  701. size + sizeof(SEC_PKCS12PrivateKey *));
  702. bag->privateKeys = dummy;
  703.     } else {
  704. bag->privateKeys = (SEC_PKCS12PrivateKey **)PORT_ArenaZAlloc(bag->poolp,
  705.     (2 * sizeof(SEC_PKCS12PrivateKey *)));
  706. dummy = bag->privateKeys;
  707.     }
  709.     if(dummy == NULL) {
  710. PORT_SetError(SEC_ERROR_NO_MEMORY);
  711. goto loser;
  712.     }
  714.     bag->privateKeys[bag->bag_size] = pk;
  715.     bag->bag_size++;
  716.     bag->privateKeys[bag->bag_size] = NULL;
  718.     PORT_ArenaUnmark(bag->poolp, mark);
  719.     return SECSuccess;
  721. loser:
  722.     /* XXX Free memory? */
  723.     PORT_ArenaRelease(bag->poolp, mark);
  724.     return SECFailure;
  725. }
  727. /* append a safe bag to the baggage area */
  728. static SECStatus 
  729. sec_pkcs12_append_unshrouded_bag(SEC_PKCS12BaggageItem *bag,
  730.  SEC_PKCS12SafeBag *u_bag)
  731. {
  732.     int size;
  733.     void *mark = NULL, *dummy = NULL;
  735.     if((bag == NULL) || (u_bag == NULL))
  736. return SECFailure;
  738.     mark = PORT_ArenaMark(bag->poolp);
  740.     /* dump things into the first bag */
  741.     size = (bag->nSecrets + 1) * sizeof(SEC_PKCS12SafeBag *);
  742.     dummy = PORT_ArenaGrow(bag->poolp,
  743.      bag->unencSecrets, size, 
  744.      size + sizeof(SEC_PKCS12SafeBag *));
  745.     bag->unencSecrets = dummy;
  746.     if(dummy == NULL) {
  747. PORT_SetError(SEC_ERROR_NO_MEMORY);
  748. goto loser;
  749.     }
  751.     bag->unencSecrets[bag->nSecrets] = u_bag;
  752.     bag->nSecrets++;
  753.     bag->unencSecrets[bag->nSecrets] = NULL;
  755.     PORT_ArenaUnmark(bag->poolp, mark);
  756.     return SECSuccess;
  758. loser:
  759.     PORT_ArenaRelease(bag->poolp, mark);
  760.     return SECFailure;
  761. }
  763. /* gather up all certificates and keys and package them up
  764.  * in the safe, baggage, or both.
  765.  * nicknames is the list of nicknames and corresponding certs in ref_certs
  766.  * ref_certs a null terminated list of certificates
  767.  * rSafe, rBaggage -- return areas for safe and baggage
  768.  * shroud_keys -- store keys externally
  769.  * pwitem -- password for computing integrity mac and encrypting contents
  770.  * wincx -- window handle
  771.  *
  772.  * if a failure occurs, an error is set and SECFailure returned.
  773.  */
  774. static SECStatus
  775. sec_pkcs12_package_certs_and_keys(SECItem **nicknames,
  776.   CERTCertificate **ref_certs,
  777.   PRBool unencryptedCerts,
  778.   SEC_PKCS12SafeContents **rSafe,
  779.   SEC_PKCS12Baggage **rBaggage,
  780.   PRBool shroud_keys, 
  781.   SECOidTag shroud_alg,
  782.   SECItem *pwitem,
  783.   PKCS12UnicodeConvertFunction unicodeFn,
  784.   void *wincx)
  785. {
  786.     PRArenaPool *permArena;
  787.     SEC_PKCS12SafeContents *safe = NULL;
  788.     SEC_PKCS12Baggage *baggage = NULL;
  790.     SECStatus rv = SECFailure;
  791.     PRBool problem = PR_FALSE;
  793.     SEC_PKCS12ESPVKItem *espvk = NULL;
  794.     SEC_PKCS12PrivateKey *pk = NULL;
  795.     CERTCertificate *add_cert = NULL;
  796.     SEC_PKCS12SafeBag *certbag = NULL, *keybag = NULL;
  797.     SEC_PKCS12BaggageItem *external_bag = NULL;
  798.     int ncerts = 0, nkeys = 0;
  799.     int i;
  801.     if((nicknames == NULL) || (rSafe == NULL) || (rBaggage == NULL)) {
  802. return SECFailure;
  803.     }
  805.     *rBaggage = baggage;
  806.     *rSafe = safe;
  808.     permArena = PORT_NewArena(SEC_ASN1_DEFAULT_ARENA_SIZE);
  809.     if(permArena == NULL) {
  810. PORT_SetError(SEC_ERROR_NO_MEMORY);
  811. return SECFailure;
  812.      }
  814.     /* allocate structures */
  815.     safe = sec_pkcs12_create_safe_contents(permArena);
  816.     if(safe == NULL) {
  817. PORT_SetError(SEC_ERROR_NO_MEMORY);
  818. rv = SECFailure;
  819. goto loser;
  820.     }
  822.     certbag = sec_pkcs12_create_safe_bag(permArena, 
  823.  SEC_OID_PKCS12_CERT_AND_CRL_BAG_ID);
  824.     if(certbag == NULL) {
  825. rv = SECFailure;
  826. goto loser;
  827.     }
  829.     if(shroud_keys != PR_TRUE) {
  830. keybag = sec_pkcs12_create_safe_bag(permArena, 
  831.     SEC_OID_PKCS12_KEY_BAG_ID);
  832. if(keybag == NULL) {
  833.     rv = SECFailure;
  834.     goto loser;
  835. }
  836.     }
  838.     if((shroud_keys == PR_TRUE) || (unencryptedCerts == PR_TRUE)) {
  839. baggage = sec_pkcs12_create_baggage(permArena);
  840.      if(baggage == NULL) {
  841.     rv = SECFailure;
  842.     goto loser;
  843. }
  844. external_bag = sec_pkcs12_create_external_bag(baggage);
  845.     }
  847.     /* package keys and certs */
  848.     i = 0;
  849.     while((nicknames[i] != NULL) && (problem == PR_FALSE)) {
  850. if(ref_certs[i] != NULL) {
  851.     /* append cert to bag o certs */
  852.     rv = sec_pkcs12_append_cert_to_bag(permArena, certbag, 
  853.             ref_certs[i],
  854.             nicknames[i]);
  855.     if(rv == SECFailure) {
  856. problem = PR_FALSE;
  857.     } else {
  858. ncerts++;
  859.     }
  861.     if(rv == SECSuccess) {
  862. /* package up them keys */
  863. if(shroud_keys == PR_TRUE) {
  864.          espvk = sec_pkcs12_get_shrouded_key(permArena, 
  865. nicknames[i],
  866.           ref_certs[i],
  867. shroud_alg, 
  868. pwitem, unicodeFn,
  869. wincx);
  870.     if(espvk != NULL) {
  871. rv = sec_pkcs12_append_shrouded_key(external_bag, espvk);
  872. SECITEM_CopyItem(permArena, &espvk->derCert,
  873.  &ref_certs[i]->derCert);
  874.     } else {
  875. rv = SECFailure;
  876.     }
  877. } else {
  878.     pk = sec_pkcs12_get_private_key(permArena, nicknames[i], 
  879.          ref_certs[i], wincx);
  880.     if(pk != NULL) {
  881. rv = sec_pkcs12_append_key_to_bag(keybag, pk);
  882. SECITEM_CopyItem(permArena, &espvk->derCert,
  883.  &ref_certs[i]->derCert);
  884.     } else {
  885. rv = SECFailure;
  886.     }
  887. }
  889. if(rv == SECFailure) {
  890.     problem = PR_TRUE;
  891. } else {
  892.     nkeys++;
  893. }
  894.     }
  895. } else {
  896.     /* handle only keys here ? */
  897.     problem = PR_TRUE;
  898. }
  899. i++;
  900.     }
  902.     /* let success fall through */
  903. loser:
  904.     if(problem == PR_FALSE) {
  905. /* if we have certs, we want to append the cert bag to the 
  906.  * appropriate area 
  907.  */
  908. if(ncerts > 0) {
  909.     if(unencryptedCerts != PR_TRUE) {
  910. rv = sec_pkcs12_append_safe_bag(safe, certbag);
  911.     } else {
  912. rv = sec_pkcs12_append_unshrouded_bag(external_bag, certbag);
  913.     }
  914. } else {
  915.     rv = SECSuccess;
  916. }
  918. /* append key bag, if they are stored in safe contents */
  919. if((rv == SECSuccess) && (shroud_keys == PR_FALSE) && (nkeys > 0)) {
  920.     rv = sec_pkcs12_append_safe_bag(safe, keybag);
  921. }
  922.     } else {
  923. rv = SECFailure;
  924.     }
  926.     /* if baggage not used, NULLify it */
  927.     if((shroud_keys == PR_TRUE) || (unencryptedCerts == PR_TRUE)) {
  928. if(((unencryptedCerts == PR_TRUE) && (ncerts == 0)) &&
  929.    ((shroud_keys == PR_TRUE) && (nkeys == 0)))
  930. baggage = NULL;
  931.     } else {
  932. baggage = NULL;
  933.     }
  935.     if((problem == PR_TRUE) || (rv == SECFailure)) {
  936. PORT_FreeArena(permArena, PR_TRUE);
  937. rv = SECFailure;
  938. baggage = NULL;
  939. safe = NULL;
  940.     }
  942.     *rBaggage = baggage;
  943.     *rSafe = safe;
  945.     return rv;
  946. }
  948. /* DER encode the safe contents and return a SECItem.  if an error
  949.  * occurs, NULL is returned.
  950.  */
  951. static SECItem *
  952. sec_pkcs12_encode_safe_contents(SEC_PKCS12SafeContents *safe)
  953. {
  954.     SECItem *dsafe = NULL, *tsafe;
  955.     void *dummy = NULL;
  956.     PRArenaPool *arena;
  958.     if(safe == NULL) {
  959. return NULL;
  960.     }
  962. /*    rv = sec_pkcs12_prepare_for_der_code_safe(safe, PR_TRUE);
  963.     if(rv != SECSuccess) {
  964. PORT_SetError(SEC_ERROR_NO_MEMORY);
  965. return NULL;
  966.     }*/
  968.     arena = PORT_NewArena(SEC_ASN1_DEFAULT_ARENA_SIZE);
  969.     if(arena == NULL) {
  970. PORT_SetError(SEC_ERROR_NO_MEMORY);
  971. return NULL;
  972.     }
  974.     tsafe = (SECItem *)PORT_ArenaZAlloc(arena, sizeof(SECItem));
  975.     if(tsafe != NULL) {
  976. dummy = SEC_ASN1EncodeItem(arena, tsafe, safe, 
  977.     SEC_PKCS12SafeContentsTemplate);
  978. if(dummy != NULL) {
  979.     dsafe = SECITEM_DupItem(tsafe);
  980. } else {
  981.     PORT_SetError(SEC_ERROR_NO_MEMORY);
  982. }
  983.     } else {
  984. PORT_SetError(SEC_ERROR_NO_MEMORY);
  985.     }
  987.     PORT_FreeArena(arena, PR_TRUE);
  989.     return dsafe;
  990. }
  992. /* prepare the authenicated safe for encoding and encode it.  
  993.  *   baggage is copied to the appropriate area, safe is encoded and
  994.  *   encrypted.  the version and transport mode are set on the asafe.
  995.  *   the whole ball of wax is then der encoded and packaged up into
  996.  *   data content info 
  997.  * safe -- container of certs and keys, is encrypted.
  998.  * baggage -- container of certs and keys, keys assumed to be encrypted by 
  999.  *    another method, certs are in the clear
  1000.  * algorithm -- algorithm by which to encrypt safe
  1001.  * pwitem -- password for encryption
  1002.  * wincx - window handle
  1003.  *
  1004.  * return of NULL is an error condition.
  1005.  */
  1006. static SEC_PKCS7ContentInfo *
  1007. sec_pkcs12_get_auth_safe(SEC_PKCS12SafeContents *safe, 
  1008.  SEC_PKCS12Baggage *baggage,  
  1009.  SECOidTag algorithm, 
  1010.  SECItem *pwitem,
  1011.  PKCS12UnicodeConvertFunction unicodeFn,
  1012.  void *wincx)
  1013. {
  1014.     SECItem *src = NULL, *dest = NULL, *psalt = NULL;
  1015.     PRArenaPool *poolp;
  1016.     SEC_PKCS12AuthenticatedSafe *asafe;
  1017.     SEC_PKCS7ContentInfo *safe_cinfo = NULL;
  1018.     SEC_PKCS7ContentInfo *asafe_cinfo = NULL;
  1019.     void *dummy;
  1020.     SECStatus rv = SECSuccess;
  1021.     PRBool swapUnicodeBytes = PR_FALSE;
  1023. #ifdef IS_LITTLE_ENDIAN
  1024.     swapUnicodeBytes = PR_TRUE;
  1025. #endif
  1026.     
  1027.     if(((safe != NULL) && (pwitem == NULL)) && (baggage == NULL))
  1028. return NULL;
  1030.     poolp = PORT_NewArena(SEC_ASN1_DEFAULT_ARENA_SIZE);
  1031.     if(poolp == NULL) {
  1032. PORT_SetError(SEC_ERROR_NO_MEMORY);
  1033. return NULL;
  1034.     }
  1036.     /* prepare authenticated safe for encode */
  1037.     asafe = sec_pkcs12_new_asafe(poolp);
  1038.     if(asafe != NULL) {
  1040. /* set version */
  1041. dummy = SEC_ASN1EncodeInteger(asafe->poolp, &asafe->version,
  1042.       SEC_PKCS12_PFX_VERSION);
  1043. if(dummy == NULL) {
  1044.     PORT_SetError(SEC_ERROR_NO_MEMORY);
  1045.     rv = SECFailure;
  1046.     goto loser;
  1047. }
  1049. /* generate the privacy salt used to create virtual pwd */
  1050. psalt = sec_pkcs12_generate_salt();
  1051. if(psalt != NULL) {
  1052.     rv = SECITEM_CopyItem(asafe->poolp, &asafe->privacySalt,
  1053.   psalt);
  1054.     if(rv == SECSuccess) {
  1055. asafe->privacySalt.len *= 8;
  1056.     } 
  1057.     else {
  1058. SECITEM_ZfreeItem(psalt, PR_TRUE);
  1059. PORT_SetError(SEC_ERROR_NO_MEMORY);
  1060. goto loser;
  1061.     }
  1062. } 
  1064. if((psalt == NULL) || (rv == SECFailure)) {
  1065.     PORT_SetError(SEC_ERROR_NO_MEMORY);
  1066.     rv = SECFailure;
  1067.     goto loser;
  1068. }
  1070. /* package up safe contents */
  1071. if(safe != NULL) 
  1072. {
  1073.     safe_cinfo = SEC_PKCS7CreateEncryptedData(algorithm, NULL, wincx);
  1074.     if((safe_cinfo != NULL) && (safe->safe_size > 0)) {
  1075. /* encode the safe and encrypt the contents of the 
  1076.  * content info
  1077.  */
  1078. src = sec_pkcs12_encode_safe_contents(safe);
  1080. if(src != NULL) {
  1081.     rv = SEC_PKCS7SetContent(safe_cinfo, (char *)src->data, src->len);
  1082.     SECITEM_ZfreeItem(src, PR_TRUE);
  1083.     if(rv == SECSuccess) {
  1084. SECItem *vpwd;
  1085. vpwd = sec_pkcs12_create_virtual_password(pwitem, psalt,
  1086. unicodeFn, swapUnicodeBytes);
  1087. if(vpwd != NULL) {
  1088.     rv = SEC_PKCS7EncryptContents(NULL, safe_cinfo,
  1089.   vpwd, wincx);
  1090.     SECITEM_ZfreeItem(vpwd, PR_TRUE);
  1091. } else {
  1092.     rv = SECFailure;
  1093.     PORT_SetError(SEC_ERROR_NO_MEMORY);
  1094. }
  1095.     } else {
  1096. PORT_SetError(SEC_ERROR_NO_MEMORY);
  1097.     }
  1098. } else {
  1099.     rv = SECFailure;
  1100. }
  1101.     } else if(safe->safe_size > 0) {
  1102. PORT_SetError(SEC_ERROR_NO_MEMORY);
  1103. goto loser;
  1104.     } else {
  1105.      /* case where there is NULL content in the safe contents */
  1106. rv = SEC_PKCS7SetContent(safe_cinfo, NULL, 0);
  1107. if(rv != SECFailure) {
  1108.     PORT_SetError(SEC_ERROR_NO_MEMORY);
  1109. }
  1110.     }
  1112.     if(rv != SECSuccess) {
  1113. SEC_PKCS7DestroyContentInfo(safe_cinfo);
  1114. safe_cinfo = NULL;
  1115. goto loser;
  1116.     }
  1118.     asafe->safe = safe_cinfo;
  1119.     /*
  1120.     PORT_Memcpy(&asafe->safe, safe_cinfo, sizeof(*safe_cinfo));
  1121.     */
  1122. }
  1124. /* copy the baggage to the authenticated safe baggage if present */
  1125. if(baggage != NULL) {
  1126.     PORT_Memcpy(&asafe->baggage, baggage, sizeof(*baggage));
  1127. }
  1129. /* encode authenticated safe and store it in a Data content info */
  1130. dest = (SECItem *)PORT_ArenaZAlloc(poolp, sizeof(SECItem));
  1131. if(dest != NULL) {
  1132.     dummy = SEC_ASN1EncodeItem(poolp, dest, asafe, 
  1133. SEC_PKCS12AuthenticatedSafeTemplate);
  1134.     if(dummy != NULL) {
  1135. asafe_cinfo = SEC_PKCS7CreateData();
  1136. if(asafe_cinfo != NULL) {
  1137.     rv = SEC_PKCS7SetContent(asafe_cinfo, 
  1138.   (char *)dest->data, 
  1139. dest->len);
  1140.     if(rv != SECSuccess) {
  1141. PORT_SetError(SEC_ERROR_NO_MEMORY);
  1142. SEC_PKCS7DestroyContentInfo(asafe_cinfo);
  1143. asafe_cinfo = NULL;
  1144.     }
  1145. }
  1146.     } else {
  1147. PORT_SetError(SEC_ERROR_NO_MEMORY);
  1148. rv = SECFailure;
  1149.     }
  1150. }
  1151.     }
  1153. loser:
  1154.     PORT_FreeArena(poolp, PR_TRUE);
  1155.     if(safe_cinfo != NULL) {
  1156.      SEC_PKCS7DestroyContentInfo(safe_cinfo);
  1157.     }
  1158.     if(psalt != NULL) {
  1159. SECITEM_ZfreeItem(psalt, PR_TRUE);
  1160.     }
  1162.     if(rv == SECFailure) {
  1163. return NULL;
  1164.     }
  1166.     return asafe_cinfo;
  1167. }
  1169. /* generates the PFX and computes the mac on the authenticated safe 
  1170.  * NULL implies an error
  1171.  */
  1172. static SEC_PKCS12PFXItem *
  1173. sec_pkcs12_get_pfx(SEC_PKCS7ContentInfo *cinfo, 
  1174.    PRBool do_mac, 
  1175.    SECItem *pwitem, PKCS12UnicodeConvertFunction unicodeFn)
  1176. {
  1177.     SECItem *dest = NULL, *mac = NULL, *salt = NULL, *key = NULL;
  1178.     SEC_PKCS12PFXItem *pfx;
  1179.     SECStatus rv = SECFailure;
  1180.     SGNDigestInfo *di;
  1181.     SECItem *vpwd;
  1182.     PRBool swapUnicodeBytes = PR_FALSE;
  1184. #ifdef IS_LITTLE_ENDIAN
  1185.     swapUnicodeBytes = PR_TRUE;
  1186. #endif
  1188.     if((cinfo == NULL) || ((do_mac == PR_TRUE) && (pwitem == NULL))) {
  1189. return NULL;
  1190.     }
  1192.     /* allocate new pfx structure */
  1193.     pfx = sec_pkcs12_new_pfx();
  1194.     if(pfx == NULL) {
  1195. PORT_SetError(SEC_ERROR_NO_MEMORY);
  1196. return NULL;
  1197.     }
  1199.     PORT_Memcpy(&pfx->authSafe, cinfo, sizeof(*cinfo));
  1200.     if(do_mac == PR_TRUE) {
  1202.      /* salt for computing mac */
  1203. salt = sec_pkcs12_generate_salt();
  1204. if(salt != NULL) {
  1205.     rv = SECITEM_CopyItem(pfx->poolp, &pfx->macData.macSalt, salt);
  1206.     pfx->macData.macSalt.len *= 8;
  1208.     vpwd = sec_pkcs12_create_virtual_password(pwitem, salt,
  1209. unicodeFn, swapUnicodeBytes);
  1210.     if(vpwd == NULL) {
  1211. rv = SECFailure;
  1212. key = NULL;
  1213.     } else {
  1214. key = sec_pkcs12_generate_key_from_password(SEC_OID_SHA1,
  1215. salt, vpwd);
  1216. SECITEM_ZfreeItem(vpwd, PR_TRUE);
  1217.     }
  1219.     if((key != NULL) && (rv == SECSuccess)) {
  1220. dest = SEC_PKCS7GetContent(cinfo);
  1221. if(dest != NULL) {
  1223.     /* compute mac on data -- for password integrity mode */
  1224.     mac = sec_pkcs12_generate_mac(key, dest, PR_FALSE);
  1225.     if(mac != NULL) {
  1226. di = SGN_CreateDigestInfo(SEC_OID_SHA1, 
  1227.        mac->data, mac->len);
  1228. if(di != NULL) {
  1229.     rv = SGN_CopyDigestInfo(pfx->poolp, 
  1230.     &pfx->macData.safeMac, di);
  1231.     SGN_DestroyDigestInfo(di);
  1232. } else {
  1233.     PORT_SetError(SEC_ERROR_NO_MEMORY);
  1234. }
  1235. SECITEM_ZfreeItem(mac, PR_TRUE);
  1236.     }
  1237. } else {
  1238.     rv = SECFailure;
  1239. }
  1240.     } else {
  1241. PORT_SetError(SEC_ERROR_NO_MEMORY);
  1242. rv = SECFailure;
  1243.     }
  1245.     if(key != NULL) {
  1246. SECITEM_ZfreeItem(key, PR_TRUE);
  1247.     }
  1248.     SECITEM_ZfreeItem(salt, PR_TRUE);
  1249. }
  1250.     }
  1252.     if(rv == SECFailure) {
  1253. SEC_PKCS12DestroyPFX(pfx);
  1254. pfx = NULL;
  1255.     }
  1257.     return pfx;
  1258. }
  1260. /* der encode the pfx */
  1261. static SECItem *
  1262. sec_pkcs12_encode_pfx(SEC_PKCS12PFXItem *pfx)
  1263. {
  1264.     SECItem *dest;
  1265.     void *dummy;
  1267.     if(pfx == NULL) {
  1268. return NULL;
  1269.     }
  1271.     dest = (SECItem *)PORT_ZAlloc(sizeof(SECItem));
  1272.     if(dest == NULL) {
  1273. PORT_SetError(SEC_ERROR_NO_MEMORY);
  1274. return NULL;
  1275.     }
  1277.     dummy = SEC_ASN1EncodeItem(NULL, dest, pfx, SEC_PKCS12PFXItemTemplate);
  1278.     if(dummy == NULL) {
  1279. PORT_SetError(SEC_ERROR_NO_MEMORY);
  1280. SECITEM_ZfreeItem(dest, PR_TRUE);
  1281. dest = NULL;
  1282.     }
  1284.     return dest;
  1285. }
  1287. SECItem *
  1288. SEC_PKCS12GetPFX(char **nicknames,
  1289.  CERTCertificate **ref_certs,
  1290.  PRBool shroud_keys, 
  1291.  SEC_PKCS5GetPBEPassword pbef, 
  1292.  void *pbearg,
  1293.  PKCS12UnicodeConvertFunction unicodeFn,
  1294.  void *wincx)
  1295. {
  1296.     SECItem **nicks = NULL;
  1297.     SEC_PKCS12PFXItem *pfx = NULL;
  1298.     SEC_PKCS12Baggage *baggage = NULL;
  1299.     SEC_PKCS12SafeContents *safe = NULL;
  1300.     SEC_PKCS7ContentInfo *cinfo = NULL;
  1301.     SECStatus rv = SECFailure;
  1302.     SECItem *dest = NULL, *pwitem = NULL;
  1303.     PRBool problem = PR_FALSE;
  1304.     PRBool unencryptedCerts;
  1305.     SECOidTag shroud_alg, safe_alg;
  1307.     /* how should we encrypt certs ? */
  1308.     unencryptedCerts = !SEC_PKCS12IsEncryptionAllowed();
  1309.     if(!unencryptedCerts) {
  1310. safe_alg = SEC_PKCS12GetPreferredEncryptionAlgorithm();
  1311. if(safe_alg == SEC_OID_UNKNOWN) {
  1312.     safe_alg = SEC_PKCS12GetStrongestAllowedAlgorithm();
  1313. }
  1314. if(safe_alg == SEC_OID_UNKNOWN) {
  1315.     unencryptedCerts = PR_TRUE;
  1316.     /* for export where no encryption is allowed, we still need
  1317.      * to encrypt the NULL contents per the spec.  encrypted info
  1318.      * is known plaintext, so it shouldn't be a problem.
  1319.      */
  1320.     safe_alg = SEC_OID_PKCS12_PBE_WITH_SHA1_AND_40_BIT_RC2_CBC;
  1321. }
  1322.     } else {
  1323. /* for export where no encryption is allowed, we still need
  1324.  * to encrypt the NULL contents per the spec.  encrypted info
  1325.  * is known plaintext, so it shouldn't be a problem.
  1326.  */
  1327. safe_alg = SEC_OID_PKCS12_PBE_WITH_SHA1_AND_40_BIT_RC2_CBC;
  1328.     }
  1330.     /* keys are always stored with triple DES */
  1331.     shroud_alg = SEC_OID_PKCS12_PBE_WITH_SHA1_AND_TRIPLE_DES_CBC;
  1333.     /* check for FIPS, if so, do not encrypt certs */
  1334.     if(PK11_IsFIPS() && !unencryptedCerts) {
  1335. unencryptedCerts = PR_TRUE;
  1336.     }
  1338.     if((nicknames == NULL) || (pbef == NULL) || (ref_certs == NULL)) {
  1339. problem = PR_TRUE;
  1340. goto loser;
  1341.     }
  1344.     /* get password */
  1345.     pwitem = (*pbef)(pbearg);
  1346.     if(pwitem == NULL) {
  1347. problem = PR_TRUE;
  1348. goto loser;
  1349.     }
  1350.     nicks = sec_pkcs12_convert_nickname_list(nicknames);
  1352.     /* get safe and baggage */
  1353.     rv = sec_pkcs12_package_certs_and_keys(nicks, ref_certs, unencryptedCerts,
  1354.         &safe, &baggage, shroud_keys,
  1355.         shroud_alg, pwitem, unicodeFn, wincx);
  1356.     if(rv == SECFailure) {
  1357. problem = PR_TRUE;
  1358.     }
  1360.     if((safe != NULL) && (problem == PR_FALSE)) {
  1361. /* copy thumbprints */
  1362. rv = sec_pkcs12_propagate_thumbprints(nicks, ref_certs, safe, baggage);
  1364. /* package everything up into AuthenticatedSafe */
  1365. cinfo = sec_pkcs12_get_auth_safe(safe, baggage, 
  1366.  safe_alg, pwitem, unicodeFn, wincx);
  1368. sec_pkcs12_destroy_cert_content_infos(safe, baggage);
  1370. /* get the pfx and mac it */
  1371. if(cinfo != NULL) {
  1372.     pfx = sec_pkcs12_get_pfx(cinfo, PR_TRUE, pwitem, unicodeFn);
  1373.     if(pfx != NULL) {
  1374. dest = sec_pkcs12_encode_pfx(pfx);
  1375. SEC_PKCS12DestroyPFX(pfx);
  1376.     }
  1377.     SEC_PKCS7DestroyContentInfo(cinfo);
  1378. }
  1380. if(safe != NULL) {
  1381.     PORT_FreeArena(safe->poolp, PR_TRUE);
  1382. }
  1383.     } else {
  1384. if(safe != NULL) {
  1385.     PORT_FreeArena(safe->poolp, PR_TRUE);
  1386. }
  1387.     }
  1389. loser:
  1390.     if(nicks != NULL) {
  1391. sec_pkcs12_destroy_nickname_list(nicks);
  1392.     }
  1394.     if(ref_certs != NULL) {
  1395. sec_pkcs12_destroy_certificate_list(ref_certs);
  1396.     }
  1398.     if(pwitem != NULL) {
  1399. SECITEM_ZfreeItem(pwitem, PR_TRUE);
  1400.     }
  1402.     if(problem == PR_TRUE) {
  1403. dest = NULL;
  1404.     }
  1406.     return dest;
  1407. }