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

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

CA认证

开发平台：

WINDOWS

cmsutil.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. /*
  35.  * cmsutil -- A command to work with CMS data
  36.  *
  37.  * $Id: cmsutil.c,v 1.15 2000/10/11 07:21:38 wtc%netscape.com Exp $
  38.  */
  40. #include "nspr.h"
  41. #include "secutil.h"
  42. #include "plgetopt.h"
  43. #include "secpkcs7.h"
  44. #include "cert.h"
  45. #include "certdb.h"
  46. #include "cdbhdl.h"
  47. #include "secoid.h"
  48. #include "cms.h"
  49. #include "nss.h"
  50. #include "smime.h"
  52. #if defined(XP_UNIX)
  53. #include <unistd.h>
  54. #endif
  56. #include <stdio.h>
  57. #include <string.h>
  59. extern void SEC_Init(void); /* XXX */
  60. char *progName = NULL;
  62. static SECStatus
  63. DigestFile(PLArenaPool *poolp, SECItem ***digests, SECItem *input,
  64.            SECAlgorithmID **algids)
  65. {
  66.     NSSCMSDigestContext *digcx;
  68.     digcx = NSS_CMSDigestContext_StartMultiple(algids);
  69.     if (digcx == NULL)
  70. return SECFailure;
  72.     NSS_CMSDigestContext_Update(digcx, input->data, input->len);
  74.     return NSS_CMSDigestContext_FinishMultiple(digcx, poolp, digests);
  75. }
  78. static void
  79. Usage(char *progName)
  80. {
  81.     fprintf(stderr, "Usage:  %s [-D|-S|-E] [<options>] [-d dbdir] [-u certusage]n", progName);
  82.     fprintf(stderr, " -i infile     use infile as source of data (default: stdin)n");
  83.     fprintf(stderr, " -o outfile    use outfile as destination of data (default: stdout)n");
  84.     fprintf(stderr, " -d dbdir      key/cert database directory (default: ~/.netscape)n");
  85.     fprintf(stderr, " -p password   use password as key db password (default: prompt)n");
  86.     fprintf(stderr, " -u certusage  set type of certificate usage (default: certUsageEmailSigner)n");
  87.     fprintf(stderr, "n");
  88.     fprintf(stderr, " -D            decode a CMS messagen");
  89.     fprintf(stderr, "  -c content   use this detached contentn");
  90.     fprintf(stderr, "  -n           suppress output of contentn");
  91.     fprintf(stderr, "  -h num       generate email headers with info about CMS messagen");
  92.     fprintf(stderr, " -S            create a CMS signed messagen");
  93.     fprintf(stderr, "  -N nick      use certificate named "nick" for signingn");
  94.     fprintf(stderr, "  -T           do not include content in CMS messagen");
  95.     fprintf(stderr, "  -G           include a signing time attributen");
  96.     fprintf(stderr, "  -P           include a SMIMECapabilities attributen");
  97.     fprintf(stderr, "  -Y nick      include a EncryptionKeyPreference attribute with certn");
  98.     fprintf(stderr, " -E            create a CMS enveloped message (NYI)n");
  99.     fprintf(stderr, "  -r id,...    create envelope for these recipients,n");
  100.     fprintf(stderr, "               where id can be a certificate nickname or email addressn");
  101.     fprintf(stderr, "nCert usage codes:n");
  102.     fprintf(stderr, "%-25s  0 - certUsageSSLClientn", " ");
  103.     fprintf(stderr, "%-25s  1 - certUsageSSLServern", " ");
  104.     fprintf(stderr, "%-25s  2 - certUsageSSLServerWithStepUpn", " ");
  105.     fprintf(stderr, "%-25s  3 - certUsageSSLCAn", " ");
  106.     fprintf(stderr, "%-25s  4 - certUsageEmailSignern", " ");
  107.     fprintf(stderr, "%-25s  5 - certUsageEmailRecipientn", " ");
  108.     fprintf(stderr, "%-25s  6 - certUsageObjectSignern", " ");
  109.     fprintf(stderr, "%-25s  7 - certUsageUserCertImportn", " ");
  110.     fprintf(stderr, "%-25s  8 - certUsageVerifyCAn", " ");
  111.     fprintf(stderr, "%-25s  9 - certUsageProtectedObjectSignern", " ");
  112.     fprintf(stderr, "%-25s 10 - certUsageStatusRespondern", " ");
  113.     fprintf(stderr, "%-25s 11 - certUsageAnyCAn", " ");
  115.     exit(-1);
  116. }
  118. static CERTCertDBHandle certHandleStatic; /* avoid having to allocate */
  120. static CERTCertDBHandle *
  121. OpenCertDB(char *progName)
  122. {
  123.     CERTCertDBHandle *certHandle;
  124.     SECStatus rv;
  126.     certHandle = &certHandleStatic;
  127.     rv = CERT_OpenCertDB(certHandle, PR_FALSE, SECU_CertDBNameCallback, NULL);
  128.     if (rv != SECSuccess) {
  129.         SECU_PrintError(progName, "could not open cert database");
  130. return NULL;
  131.     }
  133.     return certHandle;
  134. }
  136. char *
  137. ownpw(PK11SlotInfo *info, PRBool retry, void *arg)
  138. {
  139. char * passwd = NULL;
  141. if ( (!retry) && arg ) {
  142. passwd = PL_strdup((char *)arg);
  143. }
  145. return passwd;
  146. }
  148. struct optionsStr {
  149.     char *password;
  150.     SECCertUsage certUsage;
  151.     CERTCertDBHandle *certHandle;
  152. };
  154. struct decodeOptionsStr {
  155.     struct optionsStr *options;
  156.     PRFileDesc *contentFile;
  157.     int headerLevel;
  158.     PRBool suppressContent;
  159.     NSSCMSGetDecryptKeyCallback dkcb;
  160.     PK11SymKey *bulkkey;
  161. };
  163. struct signOptionsStr {
  164.     struct optionsStr *options;
  165.     char *nickname;
  166.     char *encryptionKeyPreferenceNick;
  167.     PRBool signingTime;
  168.     PRBool smimeProfile;
  169.     PRBool detached;
  170. };
  172. struct envelopeOptionsStr {
  173.     struct optionsStr *options;
  174.     char **recipients;
  175. };
  177. struct certsonlyOptionsStr {
  178.     struct optionsStr *options;
  179.     char **recipients;
  180. };
  182. struct encryptOptionsStr {
  183.     struct optionsStr *options;
  184.     char **recipients;
  185.     NSSCMSMessage *envmsg;
  186.     SECItem *input;
  187.     FILE *outfile;
  188.     PRFileDesc *envFile;
  189.     PK11SymKey *bulkkey;
  190.     SECOidTag bulkalgtag;
  191.     int keysize;
  192. };
  194. static NSSCMSMessage *
  195. decode(FILE *out, SECItem *output, SECItem *input, 
  196.        struct decodeOptionsStr decodeOptions)
  197. {
  198.     NSSCMSDecoderContext *dcx;
  199.     NSSCMSMessage *cmsg;
  200.     NSSCMSContentInfo *cinfo;
  201.     NSSCMSSignedData *sigd = NULL;
  202.     NSSCMSEnvelopedData *envd;
  203.     NSSCMSEncryptedData *encd;
  204.     SECAlgorithmID **digestalgs;
  205.     int nlevels, i, nsigners, j;
  206.     char *signercn;
  207.     NSSCMSSignerInfo *si;
  208.     SECOidTag typetag;
  209.     SECItem **digests;
  210.     PLArenaPool *poolp;
  211.     PK11PasswordFunc pwcb;
  212.     void *pwcb_arg;
  213.     SECItem *item, sitem = { 0, 0, 0 };
  215.     pwcb     = (decodeOptions.options->password != NULL) ? ownpw : NULL;
  216.     pwcb_arg = (decodeOptions.options->password != NULL) ? 
  217.                   (void *)decodeOptions.options->password : NULL;
  219.     if (decodeOptions.contentFile) {
  220. /* detached content: grab content file */
  221. SECU_FileToItem(&sitem, decodeOptions.contentFile);
  222. item = &sitem;
  223.     }
  225.     dcx = NSS_CMSDecoder_Start(NULL, 
  226.                                NULL, NULL,         /* content callback     */
  227.                                pwcb, pwcb_arg,     /* password callback    */
  228.        decodeOptions.dkcb, /* decrypt key callback */
  229.                                decodeOptions.bulkkey);
  230.     (void)NSS_CMSDecoder_Update(dcx, input->data, input->len);
  231.     cmsg = NSS_CMSDecoder_Finish(dcx);
  232.     if (cmsg == NULL) {
  233. fprintf(stderr, "%s: failed to decode message.n", progName);
  234. return NULL;
  235.     }
  237.     if (decodeOptions.headerLevel >= 0) {
  238. /*fprintf(out, "SMIME: ", decodeOptions.headerLevel, i);*/
  239. fprintf(out, "SMIME: ");
  240.     }
  242.     nlevels = NSS_CMSMessage_ContentLevelCount(cmsg);
  243.     for (i = 0; i < nlevels; i++) {
  244. cinfo = NSS_CMSMessage_ContentLevel(cmsg, i);
  245. typetag = NSS_CMSContentInfo_GetContentTypeTag(cinfo);
  247. if (decodeOptions.headerLevel >= 0)
  248.     fprintf(out, "tlevel=%d.%d; ", decodeOptions.headerLevel, nlevels - i);
  250. switch (typetag) {
  251. case SEC_OID_PKCS7_SIGNED_DATA:
  252.     if (decodeOptions.headerLevel >= 0)
  253. fprintf(out, "type=signedData; ");
  254.     sigd = (NSSCMSSignedData *)NSS_CMSContentInfo_GetContent(cinfo);
  255.     if (sigd == NULL) {
  256. SECU_PrintError(progName, 
  257.                 "problem finding signedData component");
  258. goto loser;
  259.     }
  261.     /* if we have a content file, but no digests for this signedData */
  262.     if (decodeOptions.contentFile != NULL && !NSS_CMSSignedData_HasDigests(sigd)) {
  263. if ((poolp = PORT_NewArena(1024)) == NULL) {
  264.     fprintf(stderr, "cmsutil: Out of memory.n");
  265.     goto loser;
  266. }
  267. digestalgs = NSS_CMSSignedData_GetDigestAlgs(sigd);
  268. if (DigestFile (poolp, &digests, item, digestalgs) 
  269.       != SECSuccess) {
  270.     SECU_PrintError(progName, 
  271.                     "problem computing message digest");
  272.     goto loser;
  273. }
  274. if (NSS_CMSSignedData_SetDigests(sigd, digestalgs, digests) != SECSuccess) {
  275.     
  276.     SECU_PrintError(progName, 
  277.                     "problem setting message digests");
  278.     goto loser;
  279. }
  280. PORT_FreeArena(poolp, PR_FALSE);
  281.     }
  283.     /* import the certificates */
  284.     if (NSS_CMSSignedData_ImportCerts(sigd, 
  285.                                      decodeOptions.options->certHandle, 
  286.                                      decodeOptions.options->certUsage, 
  287.                                      PR_FALSE) 
  288.           != SECSuccess) {
  289. SECU_PrintError(progName, "cert import failed");
  290. goto loser;
  291.     }
  293.     /* find out about signers */
  294.     nsigners = NSS_CMSSignedData_SignerInfoCount(sigd);
  295.     if (decodeOptions.headerLevel >= 0)
  296. fprintf(out, "nsigners=%d; ", nsigners);
  297.     if (nsigners == 0) {
  298. /* must be a cert transport message */
  299. SECStatus rv;
  300. /* XXX workaround for bug #54014 */
  301. NSS_CMSSignedData_ImportCerts(sigd, 
  302.                                              decodeOptions.options->certHandle, 
  303.                              decodeOptions.options->certUsage, 
  304.                              PR_TRUE);
  305. rv = NSS_CMSSignedData_VerifyCertsOnly(sigd, 
  306.                              decodeOptions.options->certHandle, 
  307.                              decodeOptions.options->certUsage);
  308. if (rv != SECSuccess) {
  309.     fprintf(stderr, "cmsutil: Verify certs-only failed!n");
  310.     goto loser;
  311. }
  312. return cmsg;
  313.     }
  315.     /* still no digests? */
  316.     if (!NSS_CMSSignedData_HasDigests(sigd)) {
  317. SECU_PrintError(progName, "no message digests");
  318. goto loser;
  319.     }
  321.     for (j = 0; j < nsigners; j++) {
  322. si = NSS_CMSSignedData_GetSignerInfo(sigd, j);
  323. signercn = NSS_CMSSignerInfo_GetSignerCommonName(si);
  324. if (signercn == NULL)
  325.     signercn = "";
  326. if (decodeOptions.headerLevel >= 0)
  327.     fprintf(out, "nttsigner%d.id="%s"; ", j, signercn);
  328. (void)NSS_CMSSignedData_VerifySignerInfo(sigd, j, 
  329.                              decodeOptions.options->certHandle, 
  330.                              decodeOptions.options->certUsage);
  331. if (decodeOptions.headerLevel >= 0)
  332.     fprintf(out, "signer%d.status=%s; ", j, 
  333.             NSS_CMSUtil_VerificationStatusToString(
  334.                   NSS_CMSSignerInfo_GetVerificationStatus(si)));
  335.     /* XXX what do we do if we don't print headers? */
  336.     }
  337.     break;
  338. case SEC_OID_PKCS7_ENVELOPED_DATA:
  339.     if (decodeOptions.headerLevel >= 0)
  340. fprintf(out, "type=envelopedData; ");
  341.     envd = (NSSCMSEnvelopedData *)NSS_CMSContentInfo_GetContent(cinfo);
  342.     break;
  343. case SEC_OID_PKCS7_ENCRYPTED_DATA:
  344.     if (decodeOptions.headerLevel >= 0)
  345. fprintf(out, "type=encryptedData; ");
  346.     encd = (NSSCMSEncryptedData *)NSS_CMSContentInfo_GetContent(cinfo);
  347.     break;
  348. case SEC_OID_PKCS7_DATA:
  349.     if (decodeOptions.headerLevel >= 0)
  350. fprintf(out, "type=data; ");
  351.     break;
  352. default:
  353.     break;
  354. }
  355. if (decodeOptions.headerLevel >= 0)
  356.     fprintf(out, "n");
  357.     }
  359.     if (!decodeOptions.suppressContent) {
  360. if (!decodeOptions.contentFile) 
  361.     item = NSS_CMSMessage_GetContent(cmsg);
  362. SECITEM_CopyItem(NULL, output, item);
  363.     }
  365.     return cmsg;
  366. loser:
  367.     if (cmsg)
  368. NSS_CMSMessage_Destroy(cmsg);
  369.     return NULL;
  370. }
  372. /* example of a callback function to use with encoder */
  373. /*
  374. static void
  375. writeout(void *arg, const char *buf, unsigned long len)
  376. {
  377.     FILE *f = (FILE *)arg;
  379.     if (f != NULL && buf != NULL)
  380. (void)fwrite(buf, len, 1, f);
  381. }
  382. */
  384. static NSSCMSMessage *
  385. signed_data(struct signOptionsStr signOptions)
  386. {
  387.     NSSCMSMessage *cmsg = NULL;
  388.     NSSCMSContentInfo *cinfo;
  389.     NSSCMSSignedData *sigd;
  390.     NSSCMSSignerInfo *signerinfo;
  391.     CERTCertificate *cert, *ekpcert;
  393.     if (signOptions.nickname == NULL) {
  394. fprintf(stderr, 
  395.         "ERROR: please indicate the nickname of a certificate to sign with.n");
  396. return NULL;
  397.     }
  398.     if ((cert = CERT_FindCertByNickname(signOptions.options->certHandle, 
  399.                                         signOptions.nickname)) == NULL) {
  400. SECU_PrintError(progName, 
  401.                 "the corresponding cert for key "%s" does not exist",
  402.                 signOptions.nickname);
  403. return NULL;
  404.     }
  405.     /*
  406.      * create the message object
  407.      */
  408.     cmsg = NSS_CMSMessage_Create(NULL); /* create a message on its own pool */
  409.     if (cmsg == NULL) {
  410. fprintf(stderr, "ERROR: cannot create CMS message.n");
  411. return NULL;
  412.     }
  413.     /*
  414.      * build chain of objects: message->signedData->data
  415.      */
  416.     if ((sigd = NSS_CMSSignedData_Create(cmsg)) == NULL) {
  417. fprintf(stderr, "ERROR: cannot create CMS signedData object.n");
  418. goto loser;
  419.     }
  420.     cinfo = NSS_CMSMessage_GetContentInfo(cmsg);
  421.     if (NSS_CMSContentInfo_SetContent_SignedData(cmsg, cinfo, sigd) 
  422.           != SECSuccess) {
  423. fprintf(stderr, "ERROR: cannot attach CMS signedData object.n");
  424. goto loser;
  425.     }
  426.     cinfo = NSS_CMSSignedData_GetContentInfo(sigd);
  427.     /* we're always passing data in and detaching optionally */
  428.     if (NSS_CMSContentInfo_SetContent_Data(cmsg, cinfo, NULL, 
  429.                                            signOptions.detached) 
  430.           != SECSuccess) {
  431. fprintf(stderr, "ERROR: cannot attach CMS data object.n");
  432. goto loser;
  433.     }
  434.     /* 
  435.      * create & attach signer information
  436.      */
  437.     if ((signerinfo = NSS_CMSSignerInfo_Create(cmsg, cert, SEC_OID_SHA1)) 
  438.           == NULL) {
  439. fprintf(stderr, "ERROR: cannot create CMS signerInfo object.n");
  440. goto loser;
  441.     }
  442.     /* we want the cert chain included for this one */
  443.     if (NSS_CMSSignerInfo_IncludeCerts(signerinfo, NSSCMSCM_CertChain, 
  444.                                        signOptions.options->certUsage) 
  445.           != SECSuccess) {
  446. fprintf(stderr, "ERROR: cannot find cert chain.n");
  447. goto loser;
  448.     }
  449.     if (signOptions.signingTime) {
  450. if (NSS_CMSSignerInfo_AddSigningTime(signerinfo, PR_Now()) 
  451.       != SECSuccess) {
  452.     fprintf(stderr, "ERROR: cannot add signingTime attribute.n");
  453.     goto loser;
  454. }
  455.     }
  456.     if (signOptions.smimeProfile) {
  457. if (NSS_CMSSignerInfo_AddSMIMECaps(signerinfo) != SECSuccess) {
  458.     fprintf(stderr, "ERROR: cannot add SMIMECaps attribute.n");
  459.     goto loser;
  460. }
  461.     }
  462.     if (signOptions.encryptionKeyPreferenceNick) {
  463. /* get the cert, add it to the message */
  464. if ((ekpcert = CERT_FindCertByNickname(signOptions.options->certHandle, 
  465.                                signOptions.encryptionKeyPreferenceNick))
  466.       == NULL) {
  467.     SECU_PrintError(progName, 
  468.                  "the corresponding cert for key "%s" does not exist",
  469.                     signOptions.encryptionKeyPreferenceNick);
  470.     goto loser;
  471. }
  472. if (NSS_CMSSignerInfo_AddSMIMEEncKeyPrefs(signerinfo, ekpcert, 
  473.                                         signOptions.options->certHandle)
  474.       != SECSuccess) {
  475.     fprintf(stderr, "ERROR: cannot add SMIMEEncKeyPrefs attribute.n");
  476.     goto loser;
  477. }
  478. if (NSS_CMSSignedData_AddCertificate(sigd, ekpcert) != SECSuccess) {
  479.     fprintf(stderr, "ERROR: cannot add encryption certificate.n");
  480.     goto loser;
  481. }
  482.     } else {
  483. /* check signing cert for fitness as encryption cert */
  484. /* if yes, add signing cert as EncryptionKeyPreference */
  485. if (NSS_CMSSignerInfo_AddSMIMEEncKeyPrefs(signerinfo, cert, 
  486.                                         signOptions.options->certHandle)
  487.       != SECSuccess) {
  488.     fprintf(stderr, 
  489.             "ERROR: cannot add default SMIMEEncKeyPrefs attribute.n");
  490.     goto loser;
  491. }
  492.     }
  493.     if (NSS_CMSSignedData_AddSignerInfo(sigd, signerinfo) != SECSuccess) {
  494. fprintf(stderr, "ERROR: cannot add CMS signerInfo object.n");
  495. goto loser;
  496.     }
  497.     return cmsg;
  498. loser:
  499.     NSS_CMSMessage_Destroy(cmsg);
  500.     return NULL;
  501. }
  503. static NSSCMSMessage *
  504. enveloped_data(struct envelopeOptionsStr envelopeOptions)
  505. {
  506.     NSSCMSMessage *cmsg = NULL;
  507.     NSSCMSContentInfo *cinfo;
  508.     NSSCMSEnvelopedData *envd;
  509.     NSSCMSRecipientInfo *recipientinfo;
  510.     CERTCertificate **recipientcerts;
  511.     CERTCertDBHandle *dbhandle;
  512.     PLArenaPool *tmppoolp = NULL;
  513.     SECOidTag bulkalgtag;
  514.     int keysize, i;
  515.     int cnt;
  516.     dbhandle = envelopeOptions.options->certHandle;
  517.     /* count the recipients */
  518.     if ((cnt = NSS_CMSArray_Count(envelopeOptions.recipients)) == 0) {
  519. fprintf(stderr, "ERROR: please name at least one recipient.n");
  520. goto loser;
  521.     }
  522.     if ((tmppoolp = PORT_NewArena (1024)) == NULL) {
  523. fprintf(stderr, "ERROR: out of memory.n");
  524. goto loser;
  525.     }
  526.     /* XXX find the recipient's certs by email address or nickname */
  527.     if ((recipientcerts = 
  528.          (CERTCertificate **)PORT_ArenaZAlloc(tmppoolp, 
  529.      (cnt+1)*sizeof(CERTCertificate*)))
  530.             == NULL) {
  531. fprintf(stderr, "ERROR: out of memory.n");
  532. goto loser;
  533.     }
  534.     for (i=0; envelopeOptions.recipients[i] != NULL; i++) {
  535. if ((recipientcerts[i] = 
  536.       CERT_FindCertByNicknameOrEmailAddr(dbhandle,  
  537.                                         envelopeOptions.recipients[i]))
  538.         == NULL) {
  539.     SECU_PrintError(progName, "cannot find certificate for "%s"", 
  540.                     envelopeOptions.recipients[i]);
  541.     goto loser;
  542. }
  543.     }
  544.     recipientcerts[i] = NULL;
  545.     /* find a nice bulk algorithm */
  546.     if (NSS_SMIMEUtil_FindBulkAlgForRecipients(recipientcerts, &bulkalgtag, 
  547.                                                &keysize) != SECSuccess) {
  548. fprintf(stderr, "ERROR: cannot find common bulk algorithm.n");
  549. goto loser;
  550.     }
  551.     /*
  552.      * create the message object
  553.      */
  554.     cmsg = NSS_CMSMessage_Create(NULL); /* create a message on its own pool */
  555.     if (cmsg == NULL) {
  556. fprintf(stderr, "ERROR: cannot create CMS message.n");
  557. goto loser;
  558.     }
  559.     /*
  560.      * build chain of objects: message->envelopedData->data
  561.      */
  562.     if ((envd = NSS_CMSEnvelopedData_Create(cmsg, bulkalgtag, keysize)) 
  563.           == NULL) {
  564. fprintf(stderr, "ERROR: cannot create CMS envelopedData object.n");
  565. goto loser;
  566.     }
  567.     cinfo = NSS_CMSMessage_GetContentInfo(cmsg);
  568.     if (NSS_CMSContentInfo_SetContent_EnvelopedData(cmsg, cinfo, envd) 
  569.           != SECSuccess) {
  570. fprintf(stderr, "ERROR: cannot attach CMS envelopedData object.n");
  571. goto loser;
  572.     }
  573.     cinfo = NSS_CMSEnvelopedData_GetContentInfo(envd);
  574.     /* we're always passing data in, so the content is NULL */
  575.     if (NSS_CMSContentInfo_SetContent_Data(cmsg, cinfo, NULL, PR_FALSE) 
  576.           != SECSuccess) {
  577. fprintf(stderr, "ERROR: cannot attach CMS data object.n");
  578. goto loser;
  579.     }
  580.     /* 
  581.      * create & attach recipient information
  582.      */
  583.     for (i = 0; recipientcerts[i] != NULL; i++) {
  584. if ((recipientinfo = NSS_CMSRecipientInfo_Create(cmsg, 
  585.                                                  recipientcerts[i])) 
  586.       == NULL) {
  587.     fprintf(stderr, "ERROR: cannot create CMS recipientInfo object.n");
  588.     goto loser;
  589. }
  590. if (NSS_CMSEnvelopedData_AddRecipient(envd, recipientinfo) 
  591.       != SECSuccess) {
  592.     fprintf(stderr, "ERROR: cannot add CMS recipientInfo object.n");
  593.     goto loser;
  594. }
  595.     }
  596.     if (tmppoolp)
  597. PORT_FreeArena(tmppoolp, PR_FALSE);
  598.     return cmsg;
  599. loser:
  600.     if (cmsg)
  601. NSS_CMSMessage_Destroy(cmsg);
  602.     if (tmppoolp)
  603. PORT_FreeArena(tmppoolp, PR_FALSE);
  604.     return NULL;
  605. }
  607. PK11SymKey *dkcb(void *arg, SECAlgorithmID *algid)
  608. {
  609.     return (PK11SymKey*)arg;
  610. }
  612. static SECStatus
  613. get_enc_params(struct encryptOptionsStr *encryptOptions)
  614. {
  615.     struct envelopeOptionsStr envelopeOptions;
  616.     SECStatus rv = SECFailure;
  617.     NSSCMSMessage *env_cmsg;
  618.     NSSCMSContentInfo *cinfo;
  619.     PK11SymKey *bulkkey = NULL;
  620.     SECOidTag bulkalgtag;
  621.     int keysize;
  622.     int i, nlevels;
  623.     /*
  624.      * construct an enveloped data message to obtain bulk keys
  625.      */
  626.     if (encryptOptions->envmsg) {
  627. env_cmsg = encryptOptions->envmsg; /* get it from an old message */
  628.     } else {
  629. SECItem dummyOut = { 0, 0, 0 };
  630. SECItem dummyIn  = { 0, 0, 0 };
  631. char str[] = "Hello!";
  632. PLArenaPool *tmparena = PORT_NewArena(1024);
  633. dummyIn.data = str;
  634. dummyIn.len = strlen(str);
  635. envelopeOptions.options = encryptOptions->options;
  636. envelopeOptions.recipients = encryptOptions->recipients;
  637. env_cmsg = enveloped_data(envelopeOptions);
  638. NSS_CMSDEREncode(env_cmsg, &dummyIn, &dummyOut, tmparena);
  639. PR_Write(encryptOptions->envFile, dummyOut.data, dummyOut.len);
  640. PORT_FreeArena(tmparena, PR_FALSE);
  641.     }
  642.     /*
  643.      * get the content info for the enveloped data 
  644.      */
  645.     nlevels = NSS_CMSMessage_ContentLevelCount(env_cmsg);
  646.     for (i = 0; i < nlevels; i++) {
  647.      SECOidTag typetag;
  648. cinfo = NSS_CMSMessage_ContentLevel(env_cmsg, i);
  649. typetag = NSS_CMSContentInfo_GetContentTypeTag(cinfo);
  650. if (typetag == SEC_OID_PKCS7_DATA) {
  651.     /*
  652.      * get the symmetric key
  653.      */
  654.     bulkalgtag = NSS_CMSContentInfo_GetContentEncAlgTag(cinfo);
  655.     keysize = NSS_CMSContentInfo_GetBulkKeySize(cinfo);
  656.     bulkkey = NSS_CMSContentInfo_GetBulkKey(cinfo);
  657.     break;
  658. }
  659.     }
  660.     if (i == nlevels) {
  661. fprintf(stderr, "%s: could not retrieve enveloped data.", progName);
  662. goto loser;
  663.     }
  664.     encryptOptions->bulkalgtag = bulkalgtag;
  665.     encryptOptions->bulkkey = bulkkey;
  666.     encryptOptions->keysize = keysize;
  667.     rv = SECSuccess;
  668. loser:
  669.     if (env_cmsg)
  670. NSS_CMSMessage_Destroy(env_cmsg);
  671.     return rv;
  672. }
  674. static NSSCMSMessage *
  675. encrypted_data(struct encryptOptionsStr encryptOptions)
  676. {
  677.     SECStatus rv = SECFailure;
  678.     NSSCMSMessage *cmsg = NULL;
  679.     NSSCMSContentInfo *cinfo;
  680.     NSSCMSEncryptedData *encd;
  681.     NSSCMSEncoderContext *ecx = NULL;
  682.     PLArenaPool *tmppoolp = NULL;
  683.     SECItem derOut = { 0, 0, 0 };
  684.     /* arena for output */
  685.     tmppoolp = PORT_NewArena(1024);
  686.     if (!tmppoolp) {
  687. fprintf(stderr, "%s: out of memory.n", progName);
  688. return NULL;
  689.     }
  690.     /*
  691.      * create the message object
  692.      */
  693.     cmsg = NSS_CMSMessage_Create(NULL);
  694.     if (cmsg == NULL) {
  695. fprintf(stderr, "ERROR: cannot create CMS message.n");
  696. goto loser;
  697.     }
  698.     /*
  699.      * build chain of objects: message->encryptedData->data
  700.      */
  701.     if ((encd = NSS_CMSEncryptedData_Create(cmsg, encryptOptions.bulkalgtag, 
  702.                                                   encryptOptions.keysize)) 
  703.            == NULL) {
  704. fprintf(stderr, "ERROR: cannot create CMS encryptedData object.n");
  705. goto loser;
  706.     }
  707.     cinfo = NSS_CMSMessage_GetContentInfo(cmsg);
  708.     if (NSS_CMSContentInfo_SetContent_EncryptedData(cmsg, cinfo, encd)
  709.           != SECSuccess) {
  710. fprintf(stderr, "ERROR: cannot attach CMS encryptedData object.n");
  711. goto loser;
  712.     }
  713.     cinfo = NSS_CMSEncryptedData_GetContentInfo(encd);
  714.     /* we're always passing data in, so the content is NULL */
  715.     if (NSS_CMSContentInfo_SetContent_Data(cmsg, cinfo, NULL, PR_FALSE) 
  716.           != SECSuccess) {
  717. fprintf(stderr, "ERROR: cannot attach CMS data object.n");
  718. goto loser;
  719.     }
  720.     ecx = NSS_CMSEncoder_Start(cmsg, NULL, NULL, &derOut, tmppoolp, NULL, NULL,
  721.                                dkcb, encryptOptions.bulkkey, NULL, NULL);
  722.     if (!ecx) {
  723. fprintf(stderr, "%s: cannot create encoder context.n", progName);
  724. goto loser;
  725.     }
  726.     rv = NSS_CMSEncoder_Update(ecx, encryptOptions.input->data, 
  727.                                     encryptOptions.input->len);
  728.     if (rv) {
  729. fprintf(stderr, "%s: failed to add data to encoder.n", progName);
  730. goto loser;
  731.     }
  732.     rv = NSS_CMSEncoder_Finish(ecx);
  733.     if (rv) {
  734. fprintf(stderr, "%s: failed to encrypt data.n", progName);
  735. goto loser;
  736.     }
  737.     fwrite(derOut.data, derOut.len, 1, encryptOptions.outfile);
  738.     /*
  739.     if (bulkkey)
  740. PK11_FreeSymKey(bulkkey);
  741. */
  742.     if (tmppoolp)
  743. PORT_FreeArena(tmppoolp, PR_FALSE);
  744.     return cmsg;
  745. loser:
  746.     /*
  747.     if (bulkkey)
  748. PK11_FreeSymKey(bulkkey);
  749. */
  750.     if (tmppoolp)
  751. PORT_FreeArena(tmppoolp, PR_FALSE);
  752.     if (cmsg)
  753. NSS_CMSMessage_Destroy(cmsg);
  754.     return NULL;
  755. }
  757. static NSSCMSMessage *
  758. signed_data_certsonly(struct certsonlyOptionsStr certsonlyOptions)
  759. {
  760.     NSSCMSMessage *cmsg = NULL;
  761.     NSSCMSContentInfo *cinfo;
  762.     NSSCMSSignedData *sigd;
  763.     CERTCertificate **certs;
  764.     CERTCertDBHandle *dbhandle;
  765.     PLArenaPool *tmppoolp = NULL;
  766.     int i, cnt;
  767.     dbhandle = certsonlyOptions.options->certHandle;
  768.     if ((cnt = NSS_CMSArray_Count(certsonlyOptions.recipients)) == 0) {
  769. fprintf(stderr, 
  770.         "ERROR: please indicate the nickname of a certificate to sign with.n");
  771. goto loser;
  772.     }
  773.     if ((tmppoolp = PORT_NewArena (1024)) == NULL) {
  774. fprintf(stderr, "ERROR: out of memory.n");
  775. goto loser;
  776.     }
  777.     if ((certs = 
  778.          (CERTCertificate **)PORT_ArenaZAlloc(tmppoolp, 
  779.      (cnt+1)*sizeof(CERTCertificate*)))
  780.             == NULL) {
  781. fprintf(stderr, "ERROR: out of memory.n");
  782. goto loser;
  783.     }
  784.     for (i=0; certsonlyOptions.recipients[i] != NULL; i++) {
  785. if ((certs[i] = 
  786.       CERT_FindCertByNicknameOrEmailAddr(dbhandle,
  787.                                         certsonlyOptions.recipients[i]))
  788.         == NULL) {
  789.     SECU_PrintError(progName, "cannot find certificate for "%s"", 
  790.                     certsonlyOptions.recipients[i]);
  791.     goto loser;
  792. }
  793.     }
  794.     certs[i] = NULL;
  795.     /*
  796.      * create the message object
  797.      */
  798.     cmsg = NSS_CMSMessage_Create(NULL);
  799.     if (cmsg == NULL) {
  800. fprintf(stderr, "ERROR: cannot create CMS message.n");
  801. goto loser;
  802.     }
  803.     /*
  804.      * build chain of objects: message->signedData->data
  805.      */
  806.     if ((sigd = NSS_CMSSignedData_CreateCertsOnly(cmsg, certs[0], PR_TRUE))
  807.           == NULL) {
  808. fprintf(stderr, "ERROR: cannot create CMS signedData object.n");
  809. goto loser;
  810.     }
  811.     for (i=1; i<cnt; i++) {
  812. if (NSS_CMSSignedData_AddCertChain(sigd, certs[i])) {
  813.     fprintf(stderr, "ERROR: cannot add cert chain for "%s".n",
  814.             certsonlyOptions.recipients[i]);
  815.     goto loser;
  816. }
  817.     }
  818.     cinfo = NSS_CMSMessage_GetContentInfo(cmsg);
  819.     if (NSS_CMSContentInfo_SetContent_SignedData(cmsg, cinfo, sigd) 
  820.           != SECSuccess) {
  821. fprintf(stderr, "ERROR: cannot attach CMS signedData object.n");
  822. goto loser;
  823.     }
  824.     cinfo = NSS_CMSSignedData_GetContentInfo(sigd);
  825.     if (NSS_CMSContentInfo_SetContent_Data(cmsg, cinfo, NULL, PR_FALSE) 
  826.    != SECSuccess) {
  827. fprintf(stderr, "ERROR: cannot attach CMS data object.n");
  828. goto loser;
  829.     }
  830.     if (tmppoolp)
  831. PORT_FreeArena(tmppoolp, PR_FALSE);
  832.     return cmsg;
  833. loser:
  834.     if (cmsg)
  835. NSS_CMSMessage_Destroy(cmsg);
  836.     if (tmppoolp)
  837. PORT_FreeArena(tmppoolp, PR_FALSE);
  838.     return NULL;
  839. }
  841. typedef enum { UNKNOWN, DECODE, SIGN, ENCRYPT, ENVELOPE, CERTSONLY } Mode;
  843. #if 0
  844. void
  845. parse_message_for_recipients(PRFileDesc *inFile, 
  846.                              struct envelopeOptionsStr *envelopeOptions)
  847. {
  848.     SECItem filedata;
  849.     SECStatus rv;
  850.     rv = SECU_FileToItem(&filedata, inFile);
  851. }
  852. #endif
  854. int
  855. main(int argc, char **argv)
  856. {
  857.     FILE *outFile;
  858.     NSSCMSMessage *cmsg;
  859.     PRFileDesc *inFile;
  860.     PLOptState *optstate;
  861.     PLOptStatus status;
  862.     Mode mode = UNKNOWN;
  863.     PK11PasswordFunc pwcb;
  864.     void *pwcb_arg;
  865.     struct decodeOptionsStr decodeOptions = { 0 };
  866.     struct signOptionsStr signOptions = { 0 };
  867.     struct envelopeOptionsStr envelopeOptions = { 0 };
  868.     struct certsonlyOptionsStr certsonlyOptions = { 0 };
  869.     struct encryptOptionsStr encryptOptions = { 0 };
  870.     struct optionsStr options = { 0 };
  871.     int exitstatus;
  872.     static char *ptrarray[128] = { 0 };
  873.     int nrecipients = 0;
  874.     char *str, *tok;
  875.     char *envFileName;
  876.     SECItem input = { 0, 0, 0};
  877.     SECItem output = { 0, 0, 0};
  878.     SECItem dummy = { 0, 0, 0 };
  879.     SECItem envmsg = { 0, 0, 0 };
  880.     SECStatus rv;
  882.     progName = strrchr(argv[0], '/');
  883.     progName = progName ? progName+1 : argv[0];
  885.     inFile = PR_STDIN;
  886.     outFile = stdout;
  887.     envFileName = NULL;
  888.     mode = UNKNOWN;
  889.     decodeOptions.contentFile = NULL;
  890.     decodeOptions.suppressContent = PR_FALSE;
  891.     decodeOptions.headerLevel = -1;
  892.     options.certUsage = certUsageEmailSigner;
  893.     options.password = NULL;
  894.     signOptions.nickname = NULL;
  895.     signOptions.detached = PR_FALSE;
  896.     signOptions.signingTime = PR_FALSE;
  897.     signOptions.smimeProfile = PR_FALSE;
  898.     signOptions.encryptionKeyPreferenceNick = NULL;
  899.     envelopeOptions.recipients = NULL;
  900.     encryptOptions.recipients = NULL;
  901.     encryptOptions.envmsg = NULL;
  902.     encryptOptions.envFile = NULL;
  903.     encryptOptions.bulkalgtag = SEC_OID_UNKNOWN;
  904.     encryptOptions.bulkkey = NULL;
  905.     encryptOptions.keysize = -1;
  907.     /*
  908.      * Parse command line arguments
  909.      */
  910.     optstate = PL_CreateOptState(argc, argv, 
  911.                                  "CDSEOnN:TGPY:h:p:i:c:d:e:o:s:u:r:");
  912.     while ((status = PL_GetNextOpt(optstate)) == PL_OPT_OK) {
  913. switch (optstate->option) {
  914. case '?':
  915.     Usage(progName);
  916.     break;
  918. case 'C':
  919.     mode = ENCRYPT;
  920.     break;
  921. case 'D':
  922.     mode = DECODE;
  923.     break;
  924. case 'S':
  925.     mode = SIGN;
  926.     break;
  927. case 'E':
  928.     mode = ENVELOPE;
  929.     break;
  930. case 'O':
  931.     mode = CERTSONLY;
  932.     break;
  934. case 'n':
  935.     if (mode != DECODE) {
  936. fprintf(stderr, 
  937.         "%s: option -n only supported with option -D.n", 
  938.         progName);
  939. Usage(progName);
  940. exit(1);
  941.     }
  942.     decodeOptions.suppressContent = PR_TRUE;
  943.     break;
  945. case 'N':
  946.     if (mode != SIGN) {
  947. fprintf(stderr, 
  948.         "%s: option -N only supported with option -S.n", 
  949.         progName);
  950. Usage(progName);
  951. exit(1);
  952.     }
  953.     signOptions.nickname = strdup(optstate->value);
  954.     break;
  956. case 'Y':
  957.     if (mode != SIGN) {
  958. fprintf(stderr, 
  959.         "%s: option -Y only supported with option -S.n", 
  960.         progName);
  961. Usage(progName);
  962. exit(1);
  963.     }
  964.     signOptions.encryptionKeyPreferenceNick = strdup(optstate->value);
  965.     break;
  967. case 'T':
  968.     if (mode != SIGN) {
  969. fprintf(stderr, 
  970.         "%s: option -T only supported with option -S.n", 
  971.         progName);
  972. Usage(progName);
  973. exit(1);
  974.     }
  975.     signOptions.detached = PR_TRUE;
  976.     break;
  978. case 'G':
  979.     if (mode != SIGN) {
  980. fprintf(stderr, 
  981.         "%s: option -G only supported with option -S.n", 
  982.         progName);
  983. Usage(progName);
  984. exit(1);
  985.     }
  986.     signOptions.signingTime = PR_TRUE;
  987.     break;
  989. case 'P':
  990.     if (mode != SIGN) {
  991. fprintf(stderr, 
  992.         "%s: option -P only supported with option -S.n", 
  993.         progName);
  994. Usage(progName);
  995. exit(1);
  996.     }
  997.     signOptions.smimeProfile = PR_TRUE;
  998.     break;
  1000. case 'h':
  1001.     if (mode != DECODE) {
  1002. fprintf(stderr, 
  1003.         "%s: option -h only supported with option -D.n", 
  1004.         progName);
  1005. Usage(progName);
  1006. exit(1);
  1007.     }
  1008.     decodeOptions.headerLevel = atoi(optstate->value);
  1009.     if (decodeOptions.headerLevel < 0) {
  1010. fprintf(stderr, "option -h cannot have a negative value.n");
  1011. exit(1);
  1012.     }
  1013.     break;
  1015. case 'p':
  1016.     if (!optstate->value) {
  1017. fprintf(stderr, "%s: option -p must have a value.n", progName);
  1018. Usage(progName);
  1019. exit(1);
  1020.     }
  1022.     options.password = strdup(optstate->value);
  1023.     break;
  1025. case 'i':
  1026.     inFile = PR_Open(optstate->value, PR_RDONLY, 00660);
  1027.     if (inFile == NULL) {
  1028. fprintf(stderr, "%s: unable to open "%s" for readingn",
  1029. progName, optstate->value);
  1030. exit(1);
  1031.     }
  1032.     SECU_FileToItem(&input, inFile);
  1033.     PR_Close(inFile);
  1034.     break;
  1036. case 'c':
  1037.     if (mode != DECODE) {
  1038. fprintf(stderr, 
  1039.         "%s: option -c only supported with option -D.n", 
  1040.         progName);
  1041. Usage(progName);
  1042. exit(1);
  1043.     }
  1044.     if ((decodeOptions.contentFile = 
  1045.           PR_Open(optstate->value, PR_RDONLY, 006600)) == NULL) {
  1046. fprintf(stderr, "%s: unable to open "%s" for reading.n",
  1047. progName, optstate->value);
  1048. exit(1);
  1049.     }
  1050.     break;
  1052. case 'o':
  1053. #if 0
  1054.     if (mode == DECODE) {
  1055. outFile = fopen(optstate->value, "w");
  1056.     } else {
  1057. outFile = fopen(optstate->value, "wb");
  1058.     }
  1059. #endif
  1060.     outFile = fopen(optstate->value, "wb");
  1061.     if (outFile == NULL) {
  1062. fprintf(stderr, "%s: unable to open "%s" for writingn",
  1063. progName, optstate->value);
  1064. exit(1);
  1065.     }
  1066.     break;
  1068. case 'r':
  1069.     if (!optstate->value) {
  1070. fprintf(stderr, "%s: option -r must have a value.n", progName);
  1071. Usage(progName);
  1072. exit(1);
  1073.     }
  1074. #if 0
  1075.     fprintf(stderr, "recipient = %sn", optstate->value);
  1076. #endif
  1077.     envelopeOptions.recipients = ptrarray;
  1078.     str = optstate->value;
  1079.     do {
  1080. tok = strchr(str, ',');
  1081. if (tok) *tok = '';
  1082. envelopeOptions.recipients[nrecipients++] = strdup(str);
  1083. if (tok) str = tok + 1;
  1084.     } while (tok);
  1085.     envelopeOptions.recipients[nrecipients] = NULL;
  1086.     encryptOptions.recipients = envelopeOptions.recipients;
  1087.     certsonlyOptions.recipients = envelopeOptions.recipients;
  1088.     break;
  1090. case 'd':
  1091.     SECU_ConfigDirectory(optstate->value);
  1092.     break;
  1094. case 'e':
  1095.     envFileName = strdup(optstate->value);
  1096.     encryptOptions.envFile = PR_Open(envFileName, PR_RDONLY, 00660);
  1097.     break;
  1099. case 'u': {
  1100.     int usageType;
  1102.     usageType = atoi (strdup(optstate->value));
  1103.     if (usageType < certUsageSSLClient || usageType > certUsageAnyCA)
  1104. return -1;
  1105.     options.certUsage = (SECCertUsage)usageType;
  1106.     break;
  1107.   }
  1108.       
  1109. }
  1110.     }
  1112.     /* Call the libsec initialization routines */
  1113.     PR_Init(PR_SYSTEM_THREAD, PR_PRIORITY_NORMAL, 1);
  1114.     rv = NSS_InitReadWrite(SECU_ConfigDirectory(NULL));
  1115.     if (SECSuccess != rv) {
  1116. SECU_PrintError(progName, "NSS_Init failed");
  1117. exit(1);
  1118.     }
  1119.     options.certHandle = CERT_GetDefaultCertDB();
  1120.     if (!options.certHandle) {
  1121. SECU_PrintError(progName, "No default cert DB");
  1122. exit(1);
  1123.     }
  1125. #if defined(WIN32)
  1126.     /*if (outFile == stdout && mode != DECODE) {*/
  1127.     if (outFile == stdout) {
  1128. /* If we're going to write binary data to stdout, we must put stdout
  1129. ** into O_BINARY mode or else outgoing n's will become rn's.
  1130. */
  1131. int smrv = _setmode(_fileno(stdout), _O_BINARY);
  1132. if (smrv == -1) {
  1133.     fprintf(stderr,
  1134.     "%s: Cannot change stdout to binary mode. Use -o option instead.n",
  1135.             progName);
  1136.     return smrv;
  1137. }
  1138.     }
  1139. #endif
  1141.     exitstatus = 0;
  1142.     switch (mode) {
  1143.     case DECODE:
  1144. decodeOptions.options = &options;
  1145. if (encryptOptions.envFile) {
  1146.     /* Decoding encrypted-data, so get the bulkkey from an
  1147.      * enveloped-data message.
  1148.      */
  1149.     SECU_FileToItem(&envmsg, encryptOptions.envFile);
  1150.     decodeOptions.options = &options;
  1151.     encryptOptions.envmsg = decode(NULL, &dummy, &envmsg, 
  1152.                                    decodeOptions);
  1153.     rv = get_enc_params(&encryptOptions);
  1154.     decodeOptions.dkcb = dkcb;
  1155.     decodeOptions.bulkkey = encryptOptions.bulkkey;
  1156. }
  1157. cmsg = decode(outFile, &output, &input, decodeOptions);
  1158. if (!cmsg) {
  1159.     SECU_PrintError(progName, "problem decoding");
  1160.     exitstatus = 1;
  1161. }
  1162. fwrite(output.data, output.len, 1, outFile);
  1163. break;
  1164.     case SIGN:
  1165. signOptions.options = &options;
  1166. cmsg = signed_data(signOptions);
  1167. if (!cmsg) {
  1168.     SECU_PrintError(progName, "problem signing");
  1169.     exitstatus = 1;
  1170. }
  1171. break;
  1172.     case ENCRYPT:
  1173. if (!envFileName) {
  1174.     fprintf(stderr, "%s: you must specify an envelope file with -e.n",
  1175.             progName);
  1176.     exit(1);
  1177. }
  1178. encryptOptions.options = &options;
  1179. encryptOptions.input = &input;
  1180. encryptOptions.outfile = outFile;
  1181. if (!encryptOptions.envFile) {
  1182.     encryptOptions.envFile = PR_Open(envFileName, 
  1183.                                      PR_WRONLY|PR_CREATE_FILE, 00660);
  1184.     if (!encryptOptions.envFile) {
  1185. fprintf(stderr, "%s: failed to create file %s.n", progName,
  1186.         envFileName);
  1187. exit(1);
  1188.     }
  1189. } else {
  1190.     SECU_FileToItem(&envmsg, encryptOptions.envFile);
  1191.     decodeOptions.options = &options;
  1192.     encryptOptions.envmsg = decode(NULL, &dummy, &envmsg, 
  1193.                                    decodeOptions);
  1194. }
  1195. /* decode an enveloped-data message to get the bulkkey (create
  1196.  * a new one if neccessary)
  1197.  */
  1198. rv = get_enc_params(&encryptOptions);
  1199. /* create the encrypted-data message */
  1200. cmsg = encrypted_data(encryptOptions);
  1201. if (!cmsg) {
  1202.     SECU_PrintError(progName, "problem encrypting");
  1203.     exitstatus = 1;
  1204. }
  1205. break;
  1206.     case ENVELOPE:
  1207. envelopeOptions.options = &options;
  1208. #if 0
  1209. if (!envelopeOptions.recipients)
  1210.     parse_message_for_recipients(myIn, &envelopeOptions);
  1211. #endif
  1212. cmsg = enveloped_data(envelopeOptions);
  1213. if (!cmsg) {
  1214.     SECU_PrintError(progName, "problem enveloping");
  1215.     exitstatus = 1;
  1216. }
  1217. break;
  1218.     case CERTSONLY:
  1219. certsonlyOptions.options = &options;
  1220. cmsg = signed_data_certsonly(certsonlyOptions);
  1221. if (!cmsg) {
  1222.     SECU_PrintError(progName, "problem with certs-only");
  1223.     exitstatus = 1;
  1224. }
  1225. break;
  1226.     default:
  1227. fprintf(stderr, "One of options -D, -S or -E must be set.n");
  1228. Usage(progName);
  1229. exitstatus = 1;
  1230.     }
  1231.     if (mode == SIGN || mode == ENVELOPE || mode == CERTSONLY) {
  1232. PLArenaPool *arena = PORT_NewArena(1024);
  1233. NSSCMSEncoderContext *ecx;
  1234. SECItem output = { 0, 0, 0 };
  1235. if (!arena) {
  1236.     fprintf(stderr, "%s: out of memory.n", progName);
  1237.     exit(1);
  1238. }
  1239. pwcb     = (options.password != NULL) ? ownpw                    : NULL;
  1240. pwcb_arg = (options.password != NULL) ? (void *)options.password : NULL;
  1241. ecx = NSS_CMSEncoder_Start(cmsg, 
  1242.                                    NULL, NULL,     /* DER output callback  */
  1243.                                    &output, arena, /* destination storage  */
  1244.                                    pwcb, pwcb_arg, /* password callback    */
  1245.                                    NULL, NULL,     /* decrypt key callback */
  1246.                                    NULL, NULL );   /* detached digests    */
  1247. if (!ecx) {
  1248.     fprintf(stderr, "%s: cannot create encoder context.n", progName);
  1249.     exit(1);
  1250. }
  1251. if (input.len > 0) { /* skip if certs-only (or other zero content) */
  1252.     rv = NSS_CMSEncoder_Update(ecx, input.data, input.len);
  1253.     if (rv) {
  1254. fprintf(stderr, 
  1255.         "%s: failed to add data to encoder.n", progName);
  1256. exit(1);
  1257.     }
  1258. }
  1259. rv = NSS_CMSEncoder_Finish(ecx);
  1260. if (rv) {
  1261.     fprintf(stderr, "%s: failed to encode data.n", progName);
  1262.     exit(1);
  1263. }
  1264. /*PR_Write(output.data, output.len);*/
  1265. fwrite(output.data, output.len, 1, outFile);
  1266. PORT_FreeArena(arena, PR_FALSE);
  1267.     }
  1268.     if (cmsg)
  1269. NSS_CMSMessage_Destroy(cmsg);
  1270.     if (outFile != stdout)
  1271. fclose(outFile);
  1273.     if (decodeOptions.contentFile)
  1274. PR_Close(decodeOptions.contentFile);
  1275.     exit(exitstatus);
  1276. }