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

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

CA认证

开发平台：

WINDOWS

certutil.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. ** certutil.c
  36. **
  37. ** utility for managing certificates and the cert database
  38. **
  39. */
  40. #include <stdio.h>
  41. #include <string.h>
  43. #if defined(WIN32)
  44. #include "fcntl.h"
  45. #include "io.h"
  46. #endif
  48. #include "secutil.h"
  50. #if defined(XP_UNIX)
  51. #include <unistd.h>
  52. #endif
  54. #include "nspr.h"
  55. #include "prtypes.h"
  56. #include "prtime.h"
  57. #include "prlong.h"
  59. #include "pk11func.h"
  60. #include "secasn1.h"
  61. #include "cert.h"
  62. #include "cryptohi.h"
  63. #include "secoid.h"
  64. #include "certdb.h"
  65. #include "cdbhdl.h"
  67. /* SEC_Init is now declared in secutil.h */
  68. /* We really should convert to using NSS, but it doesn't provide all
  69.  * of the functionality we need (like opening the databases writeable). */
  71. #define MIN_KEY_BITS 512
  72. #define MAX_KEY_BITS 2048
  73. #define DEFAULT_KEY_BITS 1024
  75. #define GEN_BREAK(e) rv=e; break;
  78. extern SECKEYPrivateKey *CERTUTIL_GeneratePrivateKey(KeyType keytype,
  79.      PK11SlotInfo *slot, 
  80.                                                      int rsasize,
  81.      int publicExponent,
  82.      char *noise,
  83.      SECKEYPublicKey **pubkeyp,
  84.      char *pqgFile,
  85.                                                      char *passFile);
  87. static char *progName;
  89. static CERTGeneralName *
  90. GetGeneralName (PRArenaPool *arena)
  91. {
  92.     CERTGeneralName *namesList = NULL;
  93.     CERTGeneralName *current;
  94.     CERTGeneralName *tail = NULL;
  95.     SECStatus rv = SECSuccess;
  96.     int intValue;
  97.     char buffer[512];
  98.     void *mark;
  100.     PORT_Assert (arena);
  101.     mark = PORT_ArenaMark (arena);
  102.     do {
  103. puts ("nSelect one of the following general name type: n");
  104. puts ("t1 - instance of other nament2 - rfc822Nament3 - dnsNamen");
  105. puts ("t4 - x400Addressnt5 - directoryNament6 - ediPartyNamen");
  106. puts ("t7 - uniformResourceidentifiernt8 - ipAddressnt9 - registerIDn");
  107. puts ("tOther - omitnttChoice:");
  108. scanf ("%d", &intValue);
  109. if (intValue >= certOtherName || intValue <= certRegisterID) {
  110.     if (namesList == NULL) {
  111. namesList = current = tail = (CERTGeneralName *) PORT_ArenaAlloc 
  112.                                   (arena, sizeof (CERTGeneralName));
  113.     } else {
  114. current = (CERTGeneralName *) PORT_ArenaAlloc(arena, 
  115.       sizeof (CERTGeneralName));
  116.     }
  117.     if (current == NULL) {
  118. GEN_BREAK (SECFailure);
  119.     }
  120. } else {
  121.     break;
  122. }
  123. current->type = intValue;
  124. puts ("nEnter data:");
  125. fflush (stdout);
  126. gets (buffer);
  127. switch (current->type) {
  128.     case certURI:
  129.     case certDNSName:
  130.     case certRFC822Name:
  131. current->name.other.data = PORT_ArenaAlloc (arena, strlen (buffer));
  132. if (current->name.other.data == NULL) {
  133.     GEN_BREAK (SECFailure);
  134. }
  135. PORT_Memcpy
  136.   (current->name.other.data, buffer, current->name.other.len = strlen(buffer));
  137. break;
  139.     case certEDIPartyName:
  140.     case certIPAddress:
  141.     case certOtherName:
  142.     case certRegisterID:
  143.     case certX400Address: {
  145. current->name.other.data = PORT_ArenaAlloc (arena, strlen (buffer) + 2);
  146. if (current->name.other.data == NULL) {
  147.     GEN_BREAK (SECFailure);
  148. }
  150. PORT_Memcpy (current->name.other.data + 2, buffer, strlen (buffer));
  151. /* This may not be accurate for all cases.  For now, use this tag type */
  152. current->name.other.data[0] = (char)(((current->type - 1) & 0x1f)| 0x80);
  153. current->name.other.data[1] = (char)strlen (buffer);
  154. current->name.other.len = strlen (buffer) + 2;
  155. break;
  156.     }
  158.     case certDirectoryName: {
  159. CERTName *directoryName = NULL;
  161. directoryName = CERT_AsciiToName (buffer);
  162. if (!directoryName) {
  163.     fprintf(stderr, "certutil: improperly formatted name: "%s"n", buffer);
  164.     break;
  165. }
  166.     
  167. rv = CERT_CopyName (arena, &current->name.directoryName, directoryName);
  168. CERT_DestroyName (directoryName);
  170. break;
  171.     }
  172. }
  173. if (rv != SECSuccess)
  174.     break;
  175. current->l.next = &(namesList->l);
  176. current->l.prev = &(tail->l);
  177. tail->l.next = &(current->l);
  178. tail = current;
  180.     }while (1);
  182.     if (rv != SECSuccess) {
  183. PORT_SetError (rv);
  184. PORT_ArenaRelease (arena, mark);
  185. namesList = NULL;
  186.     }
  187.     return (namesList);
  188. }
  190. static SECStatus 
  191. GetString(PRArenaPool *arena, char *prompt, SECItem *value)
  192. {
  193.     char buffer[251];
  195.     value->data = NULL;
  196.     value->len = 0;
  197.     
  198.     puts (prompt);
  199.     gets (buffer);
  200.     if (strlen (buffer) > 0) {
  201. value->data = PORT_ArenaAlloc (arena, strlen (buffer));
  202. if (value->data == NULL) {
  203.     PORT_SetError (SEC_ERROR_NO_MEMORY);
  204.     return (SECFailure);
  205. }
  206. PORT_Memcpy (value->data, buffer, value->len = strlen(buffer));
  207.     }
  208.     return (SECSuccess);
  209. }
  211. static CERTCertificateRequest *
  212. GetCertRequest(PRFileDesc *inFile)
  213. {
  214.     CERTCertificateRequest *certReq = NULL;
  215.     CERTSignedData signedData;
  216.     PRArenaPool *arena = NULL;
  217.     SECItem reqDER;
  218.     SECStatus rv;
  220.     reqDER.data = NULL;
  221.     do {
  222. arena = PORT_NewArena(DER_DEFAULT_CHUNKSIZE);
  223. if (arena == NULL) {
  224.     GEN_BREAK (SEC_ERROR_NO_MEMORY);
  225. }
  227.   rv = SECU_ReadDERFromFile(&reqDER, inFile, PR_FALSE);
  228. if (rv) 
  229.     break;
  230.         certReq = (CERTCertificateRequest*) PORT_ArenaZAlloc
  231.   (arena, sizeof(CERTCertificateRequest));
  232.         if (!certReq) 
  233.     break;
  234. certReq->arena = arena;
  236. /* Since cert request is a signed data, must decode to get the inner
  237.    data
  238.  */
  239. PORT_Memset(&signedData, 0, sizeof(signedData));
  240. rv = SEC_ASN1DecodeItem(arena, &signedData, CERT_SignedDataTemplate, 
  241. &reqDER);
  242. if (rv)
  243.     break;
  245.         rv = SEC_ASN1DecodeItem(arena, certReq, CERT_CertificateRequestTemplate,
  246. &signedData.data);
  247.    } while (0);
  249.    if (rv) {
  250.        PRErrorCode  perr = PR_GetError();
  251.        fprintf(stderr, "%s: unable to decode DER cert request (%s)n", progName,
  252.                SECU_Strerror(perr));
  253.    }
  254.    return (certReq);
  255. }
  257. static PRBool 
  258. GetYesNo(char *prompt) 
  259. {
  260.     char buf[3];
  262.     PR_Sync(PR_STDIN);
  263.     PR_Write(PR_STDOUT, prompt, strlen(prompt)+1);
  264.     PR_Read(PR_STDIN, buf, sizeof(buf));
  265.     return (buf[0] == 'y' || buf[0] == 'Y') ? PR_TRUE : PR_FALSE;
  266. #if 0
  267.     char charValue;
  269.     puts (prompt);
  270.     scanf ("%c", &charValue);
  271.     if (charValue != 'y' && charValue != 'Y')
  272. return (0);
  273.     return (1);
  274. #endif
  275. }
  277. static SECStatus
  278. AddCert(PK11SlotInfo *slot, CERTCertDBHandle *handle, char *name, char *trusts, 
  279.         PRFileDesc *inFile, PRBool ascii, PRBool emailcert)
  280. {
  281.     CERTCertTrust *trust = NULL;
  282.     CERTCertificate *cert = NULL, *tempCert = NULL;
  283.     SECItem certDER;
  284.     SECStatus rv;
  286.     certDER.data = NULL;
  287.     do {
  288. /* Read in the entire file specified with the -i argument */
  289. rv = SECU_ReadDERFromFile(&certDER, inFile, ascii);
  290. if (rv != SECSuccess) {
  291.     SECU_PrintError(progName, "unable to read input file");
  292.     break;
  293. }
  295. /* Read in an ASCII cert and return a CERTCertificate */
  296. cert = CERT_DecodeCertFromPackage((char *)certDER.data, certDER.len);
  297. if (!cert) {
  298.     SECU_PrintError(progName, "could not obtain certificate from file"); 
  299.     GEN_BREAK(SECFailure);
  300. }
  302. /* Create a cert trust to pass to SEC_AddPermCertificate */
  303. trust = (CERTCertTrust *)PORT_ZAlloc(sizeof(CERTCertTrust));
  304. if (!trust) {
  305.     SECU_PrintError(progName, "unable to allocate cert trust");
  306.     GEN_BREAK(SECFailure);
  307. }
  309. rv = CERT_DecodeTrustString(trust, trusts);
  310. if (rv) {
  311.     SECU_PrintError(progName, "unable to decode trust string");
  312.     GEN_BREAK(SECFailure);
  313. }
  315. /* CERT_ImportCert only collects certificates and returns the
  316. * first certficate.  It does not insert these certificates into
  317. * the dbase.  For now, just call CERT_NewTempCertificate.
  318. * This will result in decoding the der twice.  This have to
  319. * be handle properly.
  320. */
  322. tempCert = CERT_NewTempCertificate(handle, &cert->derCert, NULL,
  323.                                    PR_FALSE, PR_TRUE);
  325. if (!PK11_IsInternal(slot)) {
  326.     tempCert->trust = trust;
  327.     rv = PK11_ImportCertForKeyToSlot(slot, tempCert, name,
  328.                                      PR_FALSE, NULL);
  329. }
  331. if (tempCert == NULL) {
  332.     SECU_PrintError(progName,"unable to add cert to the temp database");
  333.     GEN_BREAK(SECFailure);
  334. }
  336. rv = CERT_AddTempCertToPerm(tempCert, name, trust);
  337. if (rv) {
  338.     SECU_PrintError(progName, "could not add certificate to database");
  339.     GEN_BREAK(SECFailure);
  340. }
  342. if ( emailcert )
  343.     CERT_SaveSMimeProfile(tempCert, NULL, NULL);
  344.     } while (0);
  346.     CERT_DestroyCertificate (tempCert);
  347.     CERT_DestroyCertificate (cert);
  348.     PORT_Free(trust);
  349.     PORT_Free(certDER.data);
  351.     return rv;
  352. }
  354. static SECStatus
  355. CertReq(SECKEYPrivateKey *privk, SECKEYPublicKey *pubk, KeyType keyType,
  356. CERTName *subject, char *phone, int ascii, PRFileDesc *outFile)
  357. {
  358.     CERTSubjectPublicKeyInfo *spki;
  359.     CERTCertificateRequest *cr;
  360.     SECItem *encoding;
  361.     SECItem result;
  362.     SECStatus rv;
  363.     PRArenaPool *arena;
  364.     PRInt32 numBytes;
  366.     /* Create info about public key */
  367.     spki = SECKEY_CreateSubjectPublicKeyInfo(pubk);
  368.     if (!spki) {
  369. SECU_PrintError(progName, "unable to create subject public key");
  370. return SECFailure;
  371.     }
  373.     /* Generate certificate request */
  374.     cr = CERT_CreateCertificateRequest(subject, spki, 0);
  375.     if (!cr) {
  376. SECU_PrintError(progName, "unable to make certificate request");
  377. return SECFailure;
  378.     }
  380.     arena = PORT_NewArena(DER_DEFAULT_CHUNKSIZE);
  381.     if ( !arena ) {
  382. SECU_PrintError(progName, "out of memory");
  383. return SECFailure;
  384.     }
  385.     
  386.     /* Der encode the request */
  387.     encoding = SEC_ASN1EncodeItem(arena, NULL, cr,
  388.   CERT_CertificateRequestTemplate);
  389.     if (encoding == NULL) {
  390. SECU_PrintError(progName, "der encoding of request failed");
  391. return SECFailure;
  392.     }
  394.     /* Sign the request */
  395.     switch (keyType) {
  396.     case rsaKey:
  397. rv = SEC_DerSignData(arena, &result, encoding->data, encoding->len, 
  398.                      privk, SEC_OID_PKCS1_MD5_WITH_RSA_ENCRYPTION);
  399. break;
  400.     case dsaKey:
  401. rv = SEC_DerSignData(arena, &result, encoding->data, encoding->len, 
  402.                  privk, SEC_OID_ANSIX9_DSA_SIGNATURE_WITH_SHA1_DIGEST);
  403. break;
  404.     default:
  405. SECU_PrintError(progName, "Must use rsa or dsa key type");
  406. return SECFailure;
  407.     }
  409.     if (rv) {
  410. SECU_PrintError(progName, "signing of data failed");
  411. return SECFailure;
  412.     }
  414.     /* Encode request in specified format */
  415.     if (ascii) {
  416. char *obuf;
  417. char *name, *email, *org, *state, *country;
  418. SECItem *it;
  419. int total;
  421. it = &result;
  423. obuf = BTOA_ConvertItemToAscii(it);
  424. total = PL_strlen(obuf);
  426. name = CERT_GetCommonName(subject);
  427. if (!name) {
  428.     fprintf(stderr, "You must specify a common namen");
  429.     return SECFailure;
  430. }
  432. if (!phone)
  433.     phone = strdup("(not specified)");
  435. email = CERT_GetCertEmailAddress(subject);
  436. if (!email)
  437.     email = strdup("(not specified)");
  439. org = CERT_GetOrgName(subject);
  440. if (!org)
  441.     org = strdup("(not specified)");
  443. state = CERT_GetStateName(subject);
  444. if (!state)
  445.     state = strdup("(not specified)");
  447. country = CERT_GetCountryName(subject);
  448. if (!country)
  449.     country = strdup("(not specified)");
  451. PR_fprintf(outFile, 
  452.            "nCertificate request generated by Netscape certutiln");
  453. PR_fprintf(outFile, "Phone: %snn", phone);
  454. PR_fprintf(outFile, "Common Name: %sn", name);
  455. PR_fprintf(outFile, "Email: %sn", email);
  456. PR_fprintf(outFile, "Organization: %sn", org);
  457. PR_fprintf(outFile, "State: %sn", state);
  458. PR_fprintf(outFile, "Country: %snn", country);
  460. PR_fprintf(outFile, "%sn", NS_CERTREQ_HEADER);
  461. numBytes = PR_Write(outFile, obuf, total);
  462. if (numBytes != total) {
  463.     SECU_PrintSystemError(progName, "write error");
  464.     return SECFailure;
  465. }
  466. PR_fprintf(outFile, "%sn", NS_CERTREQ_TRAILER);
  467.     } else {
  468. numBytes = PR_Write(outFile, result.data, result.len);
  469. if (numBytes != (int)result.len) {
  470.     SECU_PrintSystemError(progName, "write error");
  471.     return SECFailure;
  472. }
  473.     }
  474.     return SECSuccess;
  475. }
  477. static SECStatus 
  478. ChangeTrustAttributes(CERTCertDBHandle *handle, char *name, char *trusts)
  479. {
  480.     SECStatus rv;
  481.     CERTCertificate *cert;
  482.     CERTCertTrust *trust;
  483.     
  484.     cert = CERT_FindCertByNicknameOrEmailAddr(handle, name);
  485.     if (!cert) {
  486. SECU_PrintError(progName, "could not find certificate named "%s"",
  487. name);
  488. return SECFailure;
  489.     }
  491.     trust = (CERTCertTrust *)PORT_ZAlloc(sizeof(CERTCertTrust));
  492.     if (!trust) {
  493. SECU_PrintError(progName, "unable to allocate cert trust");
  494. return SECFailure;
  495.     }
  497.     /* This function only decodes these characters: pPwcTCu, */
  498.     rv = CERT_DecodeTrustString(trust, trusts);
  499.     if (rv) {
  500. SECU_PrintError(progName, "unable to decode trust string");
  501. return SECFailure;
  502.     }
  504.     rv = CERT_ChangeCertTrust(handle, cert, trust);
  505.     if (rv) {
  506. SECU_PrintError(progName, "unable to modify trust attributes");
  507. return SECFailure;
  508.     }
  510.     return SECSuccess;
  511. }
  513. static SECStatus
  514. printCertCB(CERTCertificate *cert, void *arg)
  515. {
  516.     SECStatus rv;
  517.     SECItem data;
  518.     
  519.     data.data = cert->derCert.data;
  520.     data.len = cert->derCert.len;
  522.     rv = SECU_PrintSignedData(stdout, &data, "Certificate", 0,
  523.       SECU_PrintCertificate);
  524.     if (rv) {
  525. SECU_PrintError(progName, "problem printing certificate");
  526. return(SECFailure);
  527.     }
  528.     SECU_PrintTrustFlags(stdout, &cert->dbEntry->trust,
  529.  "Certificate Trust Flags", 1);
  531.     printf("n");
  533.     return(SECSuccess);
  534. }
  536. static SECStatus
  537. listCerts(CERTCertDBHandle *handle, char *name, PK11SlotInfo *slot,
  538.           PRBool raw, PRBool ascii, PRFileDesc *outfile, void *pwarg)
  539. {
  540.     CERTCertificate *cert;
  541.     SECItem data;
  542.     PRInt32 numBytes;
  543.     SECStatus rv;
  545.     /* For now, split handling of slot to internal vs. other.  slot should
  546.      * probably be allowed to be NULL so that all slots can be listed.
  547.      * In that case, need to add a call to PK11_TraverseSlotCerts().
  548.      */
  549.     if (PK11_IsInternal(slot)) {
  550. if (name == NULL) {
  551.     /* Print all certs in internal slot db. */
  552.     rv = SECU_PrintCertificateNames(handle, PR_STDOUT, 
  553.                                     PR_FALSE, PR_TRUE);
  554.     if (rv) {
  555. SECU_PrintError(progName, 
  556.                 "problem printing certificate nicknames");
  557. return SECFailure;
  558.     }
  559. } else if (raw || ascii) {
  560.     /* Dump binary or ascii DER for the cert to stdout. */
  561.     cert = CERT_FindCertByNicknameOrEmailAddr(handle, name);
  562.     if (!cert) {
  563. SECU_PrintError(progName,
  564.                "could not find certificate named "%s"", name);
  565. return SECFailure;
  566.     }
  567.     data.data = cert->derCert.data;
  568.     data.len = cert->derCert.len;
  569.     if (ascii) {
  570. PR_fprintf(outfile, "%sn%sn%sn", NS_CERT_HEADER, 
  571.         BTOA_DataToAscii(data.data, data.len), NS_CERT_TRAILER);
  572.     } else if (raw) {
  573.         numBytes = PR_Write(outfile, data.data, data.len);
  574.         if (numBytes != data.len) {
  575.     SECU_PrintSystemError(progName, "error writing raw cert");
  576.     return SECFailure;
  577. }
  578.     }
  579. } else {
  580.     /* Pretty-print cert. */
  581.     rv = CERT_TraversePermCertsForNickname(handle, name, printCertCB,
  582.                                            NULL);
  583. }
  584.     } else {
  585. /* List certs on a non-internal slot. */
  586. if (PK11_NeedLogin(slot))
  587.     PK11_Authenticate(slot, PR_TRUE, pwarg);
  588. rv = PK11_TraverseCertsInSlot(slot, SECU_PrintCertNickname, stdout);
  589. if (rv) {
  590.     SECU_PrintError(progName, "problem printing certificate nicknames");
  591.     return SECFailure;
  592. }
  593.     }
  595.     return SECSuccess; /* not rv ?? */
  596. }
  598. static SECStatus
  599. ListCerts(CERTCertDBHandle *handle, char *name, PK11SlotInfo *slot,
  600.           PRBool raw, PRBool ascii, PRFileDesc *outfile, char *passFile)
  601. {
  602.     SECStatus rv;
  603.     secuPWData pwdata = { PW_NONE, 0 };
  605.     if (passFile) {
  606.         pwdata.source = PW_FROMFILE;
  607.         pwdata.data = passFile;
  608.     }
  610.     if (slot == NULL) {
  611. PK11SlotList *list;
  612. PK11SlotListElement *le;
  614. list= PK11_GetAllTokens(CKM_INVALID_MECHANISM,
  615. PR_FALSE,PR_FALSE,&pwdata);
  616. if (list) for (le = list->head; le; le = le->next) {
  617.     rv = listCerts(handle,name,le->slot,raw,ascii,outfile,&pwdata);
  618. }
  619.     } else {
  620. rv = listCerts(handle,name,slot,raw,ascii,outfile,&pwdata);
  621.     }
  622.     return rv;
  623. }
  626. static SECStatus 
  627. DeleteCert(CERTCertDBHandle *handle, char *name)
  628. {
  629.     SECStatus rv;
  630.     CERTCertificate *cert;
  632.     cert = CERT_FindCertByNicknameOrEmailAddr(handle, name);
  633.     if (!cert) {
  634. SECU_PrintError(progName, "could not find certificate named "%s"",
  635. name);
  636. return SECFailure;
  637.     }
  639.     rv = SEC_DeletePermCertificate(cert);
  640.     if (rv) {
  641. SECU_PrintError(progName, "unable to delete certificate");
  642. return SECFailure;
  643.     }
  645.     return SECSuccess;
  646. }
  648. static SECStatus
  649. ValidateCert(CERTCertDBHandle *handle, char *name, char *date,
  650.      char *certUsage, PRBool checkSig, PRBool logit)
  651. {
  652.     SECStatus rv;
  653.     CERTCertificate *cert;
  654.     int64 timeBoundary;
  655.     SECCertUsage usage;
  656.     CERTVerifyLog reallog;
  657.     CERTVerifyLog *log = NULL;
  658.     
  659.     switch (*certUsage) {
  660. case 'C':
  661.     usage = certUsageSSLClient;
  662.     break;
  663. case 'V':
  664.     usage = certUsageSSLServer;
  665.     break;
  666. case 'S':
  667.     usage = certUsageEmailSigner;
  668.     break;
  669. case 'R':
  670.     usage = certUsageEmailRecipient;
  671.     break;
  672. default:
  673.     PORT_SetError (SEC_ERROR_INVALID_ARGS);
  674.     return (SECFailure);
  675.     }
  676.     do {
  677. cert = CERT_FindCertByNicknameOrEmailAddr(handle, name);
  678. if (!cert) {
  679.     SECU_PrintError(progName, "could not find certificate named "%s"",
  680.     name);
  681.     GEN_BREAK (SECFailure)
  682. }
  684. if (date != NULL) {
  685.     rv = DER_AsciiToTime(&timeBoundary, date);
  686.     if (rv) {
  687. SECU_PrintError(progName, "invalid input date");
  688. GEN_BREAK (SECFailure)
  689.     }
  690. } else {
  691.     timeBoundary = PR_Now();
  692. }
  694. if ( logit ) {
  695.     log = &reallog;
  696.     
  697.     log->count = 0;
  698.     log->head = NULL;
  699.     log->tail = NULL;
  700.     log->arena = PORT_NewArena(DER_DEFAULT_CHUNKSIZE);
  701.     if ( log->arena == NULL ) {
  702. SECU_PrintError(progName, "out of memory");
  703. GEN_BREAK (SECFailure)
  704.     }
  705. }
  706.  
  707. rv = CERT_VerifyCert(handle, cert, checkSig, usage,
  708.      timeBoundary, NULL, log);
  709. if ( log ) {
  710.     if ( log->head == NULL ) {
  711. fprintf(stdout, "%s: certificate is validn", progName);
  712. GEN_BREAK (SECSuccess)
  713.     } else {
  714. char *name;
  715. CERTVerifyLogNode *node;
  717. node = log->head;
  718. while ( node ) {
  719.     if ( node->cert->nickname != NULL ) {
  720. name = node->cert->nickname;
  721.     } else {
  722. name = node->cert->subjectName;
  723.     }
  724.     fprintf(stderr, "%s : %sn", name, 
  725.      SECU_Strerror(node->error));
  726.     CERT_DestroyCertificate(node->cert);
  727.     node = node->next;
  728. }
  729.     }
  730. } else {
  731.     if (rv != SECSuccess) {
  732. PRErrorCode perr = PORT_GetError();
  733. fprintf(stdout, "%s: certificate is invalid: %sn",
  734. progName, SECU_Strerror(perr));
  735. GEN_BREAK (SECFailure)
  736.     }
  737.     fprintf(stdout, "%s: certificate is validn", progName);
  738.     GEN_BREAK (SECSuccess)
  739. }
  740.     } while (0);
  742.     return (rv);
  743. }
  745. SECKEYLowPrivateKey*
  746. GetPrivKeyFromNickname(char *nickname)
  747. {
  748.     /* check if key actually exists */
  749.     if (SECU_CheckKeyNameExists(NULL, nickname) == PR_FALSE) {
  750. SECU_PrintError(progName, "the key "%s" does not exist", nickname);
  751. return NULL;
  752.     }
  754.     /* Read in key */
  755.     return SECU_GetPrivateKey(NULL, nickname);
  756. }
  758. static SECStatus
  759. DumpPublicKey(int dbindex, char *nickname, FILE *out)
  760. {
  761.     SECKEYLowPrivateKey *privKey;
  762.     SECKEYLowPublicKey *publicKey;
  764.     if (dbindex) {
  765. /*privKey = secu_GetPrivKeyFromIndex(dbindex);*/
  766.     } else {
  767. privKey = GetPrivKeyFromNickname(nickname);
  768.     }
  769.     publicKey = SECKEY_LowConvertToPublicKey(privKey);
  771.     /* Output public key (in the clear) */
  772.     switch(publicKey->keyType) {
  773.       case rsaKey:
  774. fprintf(out, "RSA Public-Key:n");
  775. SECU_PrintInteger(out, &publicKey->u.rsa.modulus, "modulus", 1);
  776. SECU_PrintInteger(out, &publicKey->u.rsa.publicExponent,
  777.   "publicExponent", 1);
  778. break;
  779.       case dsaKey:
  780. fprintf(out, "DSA Public-Key:n");
  781. SECU_PrintInteger(out, &publicKey->u.dsa.params.prime, "prime", 1);
  782. SECU_PrintInteger(out, &publicKey->u.dsa.params.subPrime,
  783.   "subPrime", 1);
  784. SECU_PrintInteger(out, &publicKey->u.dsa.params.base, "base", 1);
  785. SECU_PrintInteger(out, &publicKey->u.dsa.publicValue, "publicValue", 1);
  786. break;
  787.       default:
  788. fprintf(out, "unknown key typen");
  789. break;
  790.     }
  791.     return SECSuccess;
  792. }
  794. static SECStatus
  795. DumpPrivateKey(int dbindex, char *nickname, FILE *out)
  796. {
  797.     SECKEYLowPrivateKey *key;
  798.     if (dbindex) {
  799. /*key = secu_GetPrivKeyFromIndex(dbindex);*/
  800.     } else {
  801. key = GetPrivKeyFromNickname(nickname);
  802.     }
  804.     switch(key->keyType) {
  805.       case rsaKey:
  806. fprintf(out, "RSA Private-Key:n");
  807. SECU_PrintInteger(out, &key->u.rsa.modulus, "modulus", 1);
  808. SECU_PrintInteger(out, &key->u.rsa.publicExponent, "publicExponent", 1);
  809. SECU_PrintInteger(out, &key->u.rsa.privateExponent,
  810.   "privateExponent", 1);
  811. SECU_PrintInteger(out, &key->u.rsa.prime1, "prime1", 1);
  812. SECU_PrintInteger(out, &key->u.rsa.prime2, "prime2", 1);
  813. SECU_PrintInteger(out, &key->u.rsa.exponent1, "exponent2", 1);
  814. SECU_PrintInteger(out, &key->u.rsa.exponent2, "exponent2", 1);
  815. SECU_PrintInteger(out, &key->u.rsa.coefficient, "coefficient", 1);
  816. break;
  817.       case dsaKey:
  818. fprintf(out, "DSA Private-Key:n");
  819. SECU_PrintInteger(out, &key->u.dsa.params.prime, "prime", 1);
  820. SECU_PrintInteger(out, &key->u.dsa.params.subPrime, "subPrime", 1);
  821. SECU_PrintInteger(out, &key->u.dsa.params.base, "base", 1);
  822. SECU_PrintInteger(out, &key->u.dsa.publicValue, "publicValue", 1);
  823. SECU_PrintInteger(out, &key->u.dsa.privateValue, "privateValue", 1);
  824. break;
  825.       default:
  826. fprintf(out, "unknown key typen");
  827. break;
  828.     }
  829.     return SECSuccess;
  830. }
  832. static SECStatus
  833. printKeyCB(SECKEYPublicKey *key, SECItem *data, void *arg)
  834. {
  835.     if (key->keyType == rsaKey) {
  836. fprintf(stdout, "RSA Public-Key:n");
  837. SECU_PrintInteger(stdout, &key->u.rsa.modulus, "modulus", 1);
  838.     } else {
  839. fprintf(stdout, "DSA Public-Key:n");
  840. SECU_PrintInteger(stdout, &key->u.dsa.publicValue, "publicValue", 1);
  841.     }
  842.     return SECSuccess;
  843. }
  845. /* callback for listing certs through pkcs11 */
  846. SECStatus
  847. secu_PrintKeyFromCert(CERTCertificate *cert, void *data)
  848. {
  849.     FILE *out;
  850.     char *name;
  851.     SECKEYPublicKey *key;
  853.     out = (FILE *)data;
  854.     key = CERT_ExtractPublicKey(cert);
  855.     if (!key) {
  856. fprintf(out, "XXX could not extract key for %s.n", cert->nickname);
  857. return SECFailure;
  858.     }
  859.     /* XXX should have a type field also */
  860.     fprintf(out, "<%d> %sn", 0, cert->nickname);
  862.     return SECSuccess;
  863. }
  865. static SECStatus
  866. listKeys(PK11SlotInfo *slot, KeyType keyType, void *pwarg)
  867. {
  868.     SECStatus rv = SECSuccess;
  870.     if (PK11_IsInternal(slot)) {
  871. /* Print all certs in internal slot db. */
  872. rv = SECU_PrintKeyNames(SECKEY_GetDefaultKeyDB(), stdout);
  873. if (rv) {
  874.     SECU_PrintError(progName, "problem listing keys");
  875.     return SECFailure;
  876. }
  877.     } else {
  878. /* XXX need a function as below */
  879. /* could iterate over certs on slot and print keys */
  880. /* this would miss stranded keys */
  881.     /*rv = PK11_TraverseSlotKeys(slotname, keyType, printKeyCB, NULL, NULL);*/
  882. if (PK11_NeedLogin(slot))
  883.     PK11_Authenticate(slot, PR_TRUE, pwarg);
  884. rv = PK11_TraverseCertsInSlot(slot, secu_PrintKeyFromCert, stdout);
  885. if (rv) {
  886.     SECU_PrintError(progName, "problem listing keys");
  887.     return SECFailure;
  888. }
  889. return SECFailure;
  890.     }
  891.     return rv;
  892. }
  894. static SECStatus
  895. ListKeys(PK11SlotInfo *slot, char *keyname, int index, 
  896.          KeyType keyType, PRBool dopriv, char *passFile)
  897. {
  898.     SECStatus rv = SECSuccess;
  899.     secuPWData pwdata = { PW_NONE, 0 };
  901.     if (passFile) {
  902.         pwdata.source = PW_FROMFILE;
  903.         pwdata.data = passFile;
  904.     }
  906.     if (keyname) {
  907. if (dopriv) {
  908.     return DumpPrivateKey(index, keyname, stdout);
  909. } else {
  910.     return DumpPublicKey(index, keyname, stdout);
  911. }
  912.     }
  913.     /* For now, split handling of slot to internal vs. other.  slot should
  914.      * probably be allowed to be NULL so that all slots can be listed.
  915.      * In that case, need to add a call to PK11_TraverseSlotCerts().
  916.      */
  917.     if (slot == NULL) {
  918. PK11SlotList *list;
  919. PK11SlotListElement *le;
  921. list= PK11_GetAllTokens(CKM_INVALID_MECHANISM,PR_FALSE,PR_FALSE,&pwdata);
  922. if (list) for (le = list->head; le; le = le->next) {
  923.     rv = listKeys(le->slot,keyType,&pwdata);
  924. }
  925.     } else {
  926. rv = listKeys(slot,keyType,&pwdata);
  927.     }
  928.     return rv;
  929. }
  931. static SECStatus
  932. DeleteKey(SECKEYKeyDBHandle *handle, char *nickname)
  933. {
  934.     SECStatus rv;
  936.     rv = SECU_DeleteKeyByName(handle, nickname);
  937.     if (rv != SECSuccess) {
  938. SECU_PrintError("problem deleting private key "%s"n", nickname);
  939.     }
  940.     return rv;
  941. }
  944. /*
  945.  *  L i s t M o d u l e s
  946.  *
  947.  *  Print a list of the PKCS11 modules that are
  948.  *  available. This is useful for smartcard people to
  949.  *  make sure they have the drivers loaded.
  950.  *
  951.  */
  952. static SECStatus
  953. ListModules(void)
  954. {
  955.     PK11SlotList *list;
  956.     PK11SlotListElement *le;
  958.     /* get them all! */
  959.     list = PK11_GetAllTokens(CKM_INVALID_MECHANISM,PR_FALSE,PR_FALSE,NULL);
  960.     if (list == NULL) return SECFailure;
  962.     /* look at each slot*/
  963.     for (le = list->head ; le; le = le->next) {
  964.       printf ("n");
  965.       printf ("    slot: %sn", PK11_GetSlotName(le->slot));
  966.       printf ("   token: %sn", PK11_GetTokenName(le->slot));
  967.     }
  968.     PK11_FreeSlotList(list);
  970.     return SECSuccess;
  971. }
  973. static void 
  974. Usage(char *progName)
  975. {
  976. #define FPS fprintf(stderr, 
  977.     FPS "Type %s -H for more detailed descriptionsn", progName);
  978.     FPS "Usage:  %s -N [-d certdir] [-f pwfile]n", progName);
  979.     FPS "t%s -A -n cert-name -t trustargs [-d certdir] [-a] [-i input]n", 
  980.      progName);
  981.     FPS "t%s -C [-c issuer-name | -x] -i cert-request-file -o cert-filen"
  982. "tt [-m serial-number] [-w warp-months] [-v months-valid]n"
  983.         "tt [-f pwfile] [-d certdir] [-1] [-2] [-3] [-4] [-5] [-6]n",
  984. progName);
  985.     FPS "t%s -D -n cert-name [-d certdir]n", progName);
  986.     FPS "t%s -E -n cert-name -t trustargs [-d certdir] [-a] [-i input]n", 
  987. progName);
  988.     FPS "t%s -G -n key-name [-h token-name] [-k rsa] [-g key-size] [-y exp]n" 
  989. "tt [-f pwfile] [-z noisefile] [-d certdir]n", progName);
  990.     FPS "t%s -G [-h token-name] -k dsa [-q pqgfile -g key-size] [-f pwfile]n"
  991. "tt [-z noisefile] [-d certdir]n", progName);
  992.     FPS "t%s -K [-n key-name] [-h token-name] [-k dsa|rsa|all]n", 
  993. progName);
  994.     FPS "tt [-f pwfile] [-d certdir]n");
  995.     FPS "t%s -L [-n cert-name] [-d certdir] [-r] [-a]n", progName);
  996.     FPS "t%s -M -n cert-name -t trustargs [-d certdir]n",
  997. progName);
  998.     FPS "t%s -R -s subj -o cert-request-file [-d certdir] [-p phone] [-a]n"
  999. "tt [-k key-type] [-h token-name] [-f pwfile] [-g key-size]n",
  1000. progName);
  1001.     FPS "t%s -V -n cert-name -u usage [-b time] [-e] [-d certdir]n",
  1002. progName);
  1003.     FPS "t%s -S -n cert-name -s subj [-c issuer-name | -x]  -t trustargsn"
  1004. "tt [-k key-type] [-h token-name] [-g key-size]n"
  1005.         "tt [-m serial-number] [-w warp-months] [-v months-valid]n"
  1006. "tt [-f pwfile] [-d certdir]n"
  1007.         "tt [-p phone] [-1] [-2] [-3] [-4] [-5] [-6]n",
  1008. progName);
  1009.     FPS "t%s -U [-d certdir]n", progName);
  1010.     exit(-1);
  1011. }
  1013. static void LongUsage(char *progName)
  1014. {
  1016.     FPS "%-15s Add a certificate to the database        (create if needed)n",
  1017. "-A");
  1018.     FPS "%-15s Add an Email certificate to the database (create if needed)n",
  1019. "-E");
  1020.     FPS "%-20s Specify the nickname of the certificate to addn",
  1021. "   -n cert-name");
  1022.     FPS "%-20s Set the certificate trust attributes:n",
  1023. "   -t trustargs");
  1024.     FPS "%-25s p t valid peern", "");
  1025.     FPS "%-25s P t trusted peer (implies p)n", "");
  1026.     FPS "%-25s c t valid CAn", "");
  1027.     FPS "%-25s T t trusted CA to issue client certs (implies c)n", "");
  1028.     FPS "%-25s C t trusted CA to issue server certs (implies c)n", "");
  1029.     FPS "%-25s u t user certn", "");
  1030.     FPS "%-25s w t send warningn", "");
  1031. #ifdef DEBUG_NSSTEAM_ONLY
  1032.     FPS "%-25s g t make step-up certn", "");
  1033. #endif /* DEBUG_NSSTEAM_ONLY */
  1034.     FPS "%-20s Specify the password filen",
  1035. "   -f pwfile");
  1036.     FPS "%-20s Cert database directory (default is ~/.netscape)n",
  1037. "   -d certdir");
  1038.     FPS "%-20s The input certificate is encoded in ASCII (RFC1113)n",
  1039. "   -a");
  1040.     FPS "%-20s Specify the certificate file (default is stdin)n",
  1041. "   -i input");
  1042.     FPS "n");
  1044.     FPS "%-15s Create a new binary certificate from a BINARY cert requestn",
  1045. "-C");
  1046.     FPS "%-20s The nickname of the issuer certn",
  1047. "   -c issuer-name");
  1048.     FPS "%-20s The BINARY certificate request filen",
  1049. "   -i cert-request ");
  1050.     FPS "%-20s Output binary cert to this file (default is stdout)n",
  1051. "   -o output-cert");
  1052.     FPS "%-20s Self signn",
  1053. "   -x");
  1054.     FPS "%-20s Cert serial numbern",
  1055. "   -m serial-number");
  1056.     FPS "%-20s Time Warpn",
  1057. "   -w warp-months");
  1058.     FPS "%-20s Months valid (default is 3)n",
  1059.         "   -v months-valid");
  1060.     FPS "%-20s Specify the password filen",
  1061. "   -f pwfile");
  1062.     FPS "%-20s Cert database directory (default is ~/.netscape)n",
  1063. "   -d certdir");
  1064.     FPS "%-20s Create key usage extensionn",
  1065. "   -1 ");
  1066.     FPS "%-20s Create basic constraint extensionn",
  1067. "   -2 ");
  1068.     FPS "%-20s Create authority key ID extensionn",
  1069. "   -3 ");
  1070.     FPS "%-20s Create crl distribution point extensionn",
  1071. "   -4 ");
  1072.     FPS "%-20s Create netscape cert type extensionn",
  1073. "   -5 ");
  1074.     FPS "%-20s Create extended key usage extensionn",
  1075. "   -6 ");
  1076.     FPS "n");
  1078.     FPS "%-15s Generate a new key pairn",
  1079. "-G");
  1080.     FPS "%-20s Name of token in which to generate key (default is internal)n",
  1081. "   -h token-name");
  1082.     FPS "%-20s Type of key pair to generate ("dsa", "rsa" (default))n",
  1083. "   -k key-type");
  1084.     FPS "%-20s Key size in bits, (min %d, max %d, default %d)n",
  1085. "   -g key-size", MIN_KEY_BITS, MAX_KEY_BITS, DEFAULT_KEY_BITS);
  1086.     FPS "%-20s Set the public exponent value (3, 17, 65537) (rsa only)n",
  1087. "   -y exp");
  1088.     FPS "%-20s Specify the password filen",
  1089.         "   -f password-file");
  1090.     FPS "%-20s Specify the noise file to be usedn",
  1091. "   -z noisefile");
  1092.     FPS "%-20s read PQG value from pqgfile (dsa only)n",
  1093. "   -q pqgfile");
  1094.     FPS "%-20s Key database directory (default is ~/.netscape)n",
  1095. "   -d keydir");
  1096.     FPS "n");
  1098.     FPS "%-15s Delete a certificate from the databasen",
  1099. "-D");
  1100.     FPS "%-20s The nickname of the cert to deleten",
  1101. "   -n cert-name");
  1102.     FPS "%-20s Cert database directory (default is ~/.netscape)n",
  1103. "   -d certdir");
  1104.     FPS "n");
  1106.     FPS "%-15s List all modulesn", /*, or print out a single named modulen",*/
  1107.         "-U");
  1108.     FPS "%-20s Module database directory (default is '~/.netscape')n",
  1109.         "   -d moddir");
  1111.     FPS "%-15s List all keysn", /*, or print out a single named keyn",*/
  1112.         "-K");
  1113.     FPS "%-20s Name of token in which to look for keys (default is internal,"
  1114. " use "all" to list keys on all tokens)n",
  1115. "   -h token-name ");
  1116.     FPS "%-20s Type of key pair to list ("all", "dsa", "rsa" (default))n",
  1117. "   -k key-type");
  1118.     FPS "%-20s Specify the password filen",
  1119.         "   -f password-file");
  1120.     FPS "%-20s Key database directory (default is ~/.netscape)n",
  1121. "   -d keydir");
  1122.     FPS "n");
  1124.     FPS "%-15s List all certs, or print out a single named certn",
  1125. "-L");
  1126.     FPS "%-20s Pretty print named cert (list all if unspecified)n",
  1127. "   -n cert-name");
  1128.     FPS "%-20s Cert database directory (default is ~/.netscape)n",
  1129. "   -d certdir");
  1130.     FPS "%-20s For single cert, print binary DER encodingn",
  1131. "   -r");
  1132.     FPS "%-20s For single cert, print ASCII encoding (RFC1113)n",
  1133. "   -a");
  1134.     FPS "n");
  1136.     FPS "%-15s Modify trust attributes of certificaten",
  1137. "-M");
  1138.     FPS "%-20s The nickname of the cert to modifyn",
  1139. "   -n cert-name");
  1140.     FPS "%-20s Set the certificate trust attributes (see -A above)n",
  1141. "   -t trustargs");
  1142.     FPS "%-20s Cert database directory (default is ~/.netscape)n",
  1143. "   -d certdir");
  1144.     FPS "n");
  1146.     FPS "%-15s Create a new certificate databasen",
  1147. "-N");
  1148.     FPS "%-20s Cert database directory (default is ~/.netscape)n",
  1149. "   -d certdir");
  1150.     FPS "n");
  1152.     FPS "%-15s Generate a certificate request (stdout)n",
  1153. "-R");
  1154.     FPS "%-20s Specify the subject name (using RFC1485)n",
  1155. "   -s subject");
  1156.     FPS "%-20s Output the cert request to this filen",
  1157. "   -o output-req");
  1158.     FPS "%-20s Type of key pair to generate ("dsa", "rsa" (default))n",
  1159. "   -k key-type");
  1160.     FPS "%-20s Name of token in which to generate key (default is internal)n",
  1161. "   -h token-name");
  1162.     FPS "%-20s Key size in bits, RSA keys only (min %d, max %d, default %d)n",
  1163. "   -g key-size", MIN_KEY_BITS, MAX_KEY_BITS, DEFAULT_KEY_BITS);
  1164.     FPS "%-20s Specify the password filen",
  1165. "   -f pwfile");
  1166.     FPS "%-20s Key database directory (default is ~/.netscape)n",
  1167. "   -d keydir");
  1168.     FPS "%-20s Specify the contact phone number ("123-456-7890")n",
  1169. "   -p phone");
  1170.     FPS "%-20s Output the cert request in ASCII (RFC1113); default is binaryn",
  1171. "   -a");
  1172.     FPS "n");
  1174.     FPS "%-15s Validate a certificaten",
  1175. "-V");
  1176.     FPS "%-20s The nickname of the cert to Validaten",
  1177. "   -n cert-name");
  1178.     FPS "%-20s validity time ("YYMMDDHHMMSS[+HHMM|-HHMM|Z]")n",
  1179. "   -b time");
  1180.     FPS "%-20s Check certificate signature n",
  1181. "   -e ");   
  1182.     FPS "%-20s Specify certificate usage:n", "   -u certusage");
  1183.     FPS "%-25s C t SSL Clientn", "");
  1184.     FPS "%-25s V t SSL Servern", "");
  1185.     FPS "%-25s S t Email signern", "");
  1186.     FPS "%-25s R t Email Recipientn", "");   
  1187.     FPS "%-20s Cert database directory (default is ~/.netscape)n",
  1188. "   -d certdir");
  1189.     FPS "n");
  1191.     FPS "%-15s Make a certificate and add to databasen",
  1192.         "-S");
  1193.     FPS "%-20s Specify the nickname of the certn",
  1194.         "   -n key-name");
  1195.     FPS "%-20s Specify the subject name (using RFC1485)n",
  1196.         "   -s subject");
  1197.     FPS "%-20s The nickname of the issuer certn",
  1198. "   -c issuer-name");
  1199.     FPS "%-20s Set the certificate trust attributes (see -A above)n",
  1200. "   -t trustargs");
  1201.     FPS "%-20s Type of key pair to generate ("dsa", "rsa" (default))n",
  1202. "   -k key-type");
  1203.     FPS "%-20s Name of token in which to generate key (default is internal)n",
  1204. "   -h token-name");
  1205.     FPS "%-20s Key size in bits, RSA keys only (min %d, max %d, default %d)n",
  1206. "   -g key-size", MIN_KEY_BITS, MAX_KEY_BITS, DEFAULT_KEY_BITS);
  1207.     FPS "%-20s Self signn",
  1208. "   -x");
  1209.     FPS "%-20s Cert serial numbern",
  1210. "   -m serial-number");
  1211.     FPS "%-20s Time Warpn",
  1212. "   -w warp-months");
  1213.     FPS "%-20s Months valid (default is 3)n",
  1214.         "   -v months-valid");
  1215.     FPS "%-20s Specify the password filen",
  1216. "   -f pwfile");
  1217.     FPS "%-20s Cert database directory (default is ~/.netscape)n",
  1218. "   -d certdir");
  1219.     FPS "%-20s Specify the contact phone number ("123-456-7890")n",
  1220. "   -p phone");
  1221.     FPS "%-20s Create key usage extensionn",
  1222. "   -1 ");
  1223.     FPS "%-20s Create basic constraint extensionn",
  1224. "   -2 ");
  1225.     FPS "%-20s Create authority key ID extensionn",
  1226. "   -3 ");
  1227.     FPS "%-20s Create crl distribution point extensionn",
  1228. "   -4 ");
  1229.     FPS "%-20s Create netscape cert type extensionn",
  1230. "   -5 ");
  1231.     FPS "%-20s Create extended key usage extensionn",
  1232. "   -6 ");
  1233.     FPS "n");
  1235.     exit(-1);
  1236. #undef FPS
  1237. }
  1240. static CERTCertificate *
  1241. MakeV1Cert( CERTCertDBHandle * handle, 
  1242. CERTCertificateRequest *req,
  1243.      char * issuerNickName, 
  1244. PRBool  selfsign, 
  1245. int  serialNumber,
  1246. int  warpmonths,
  1247.                 int                     validitylength)
  1248. {
  1249.     CERTCertificate *issuerCert = NULL;
  1250.     CERTValidity *validity;
  1251.     CERTCertificate *cert = NULL;
  1252. #ifndef NSPR20    
  1253.     PRTime printableTime;
  1254.     int64 now, after;
  1255. #else
  1256.     PRExplodedTime printableTime;
  1257.     PRTime now, after;
  1258. #endif    
  1259.    
  1260.     
  1262.     if ( !selfsign ) {
  1263. issuerCert = CERT_FindCertByNicknameOrEmailAddr(handle, issuerNickName);
  1264. if (!issuerCert) {
  1265.     SECU_PrintError(progName, "could not find certificate named "%s"",
  1266.     issuerNickName);
  1267.     return NULL;
  1268. }
  1269.     }
  1271.     now = PR_Now();
  1272. #ifndef NSPR20
  1273.     PR_ExplodeGMTTime (&printableTime, now);
  1274. #else    
  1275.     PR_ExplodeTime (now, PR_GMTParameters, &printableTime);
  1276. #endif
  1277.     if ( warpmonths ) {
  1278. #ifndef NSPR20    
  1279. printableTime.tm_mon += warpmonths;
  1280. now = PR_ImplodeTime (&printableTime, 0, 0);
  1281. PR_ExplodeGMTTime (&printableTime, now);
  1282. #else
  1283. printableTime.tm_month += warpmonths;
  1284. now = PR_ImplodeTime (&printableTime);
  1285. PR_ExplodeTime (now, PR_GMTParameters, &printableTime);
  1286. #endif
  1287.     }
  1288. #ifndef NSPR20  
  1289.     printableTime.tm_mon += validitylength;  
  1290.     printableTime.tm_mon += 3;
  1291.     after = PR_ImplodeTime (&printableTime, 0, 0);
  1293. #else
  1294.     printableTime.tm_month += validitylength;
  1295.     printableTime.tm_month += 3;
  1296.     after = PR_ImplodeTime (&printableTime);
  1297. #endif    
  1299.     /* note that the time is now in micro-second unit */
  1300.     validity = CERT_CreateValidity (now, after);
  1302.     if ( selfsign ) {
  1303. cert = CERT_CreateCertificate
  1304.     (serialNumber,&(req->subject), validity, req);
  1305.     } else {
  1306. cert = CERT_CreateCertificate
  1307.     (serialNumber,&(issuerCert->subject), validity, req);
  1308.     }
  1309.     
  1310.     CERT_DestroyValidity(validity);
  1311.     if ( issuerCert ) {
  1312. CERT_DestroyCertificate (issuerCert);
  1313.     }
  1314.     
  1315.     return(cert);
  1316. }
  1318. static SECStatus 
  1319. AddKeyUsage (void *extHandle)
  1320. {
  1321.     SECItem bitStringValue;
  1322.     unsigned char keyUsage = 0x0;
  1323.     char buffer[5];
  1324.     int value;
  1326.     while (1) {
  1327. fprintf(stdout, "%-25s 0 - Digital Signaturen", "");
  1328. fprintf(stdout, "%-25s 1 - Non-repudiationn", "");
  1329. fprintf(stdout, "%-25s 2 - Key enciphermentn", "");
  1330. fprintf(stdout, "%-25s 3 - Data enciphermentn", "");   
  1331. fprintf(stdout, "%-25s 4 - Key agreementn", "");
  1332. fprintf(stdout, "%-25s 5 - Cert signning keyn", "");   
  1333. fprintf(stdout, "%-25s 6 - CRL signning keyn", "");
  1334. fprintf(stdout, "%-25s Other to finishn", "");
  1335. gets (buffer);
  1336. value = atoi (buffer);
  1337. if (value < 0 || value > 6)
  1338.     break;
  1339. keyUsage |= (0x80 >> value);
  1340.     }
  1342.     bitStringValue.data = &keyUsage;
  1343.     bitStringValue.len = 1;
  1344.     buffer[0] = 'n';
  1345.     puts ("Is this a critical extension [y/n]? ");
  1346.     gets (buffer);
  1348.     return (CERT_EncodeAndAddBitStrExtension
  1349.     (extHandle, SEC_OID_X509_KEY_USAGE, &bitStringValue,
  1350.      (buffer[0] == 'y' || buffer[0] == 'Y') ? PR_TRUE : PR_FALSE));
  1352. }
  1355. static CERTOidSequence *
  1356. CreateOidSequence(void)
  1357. {
  1358.   CERTOidSequence *rv = (CERTOidSequence *)NULL;
  1359.   PRArenaPool *arena = (PRArenaPool *)NULL;
  1361.   arena = PORT_NewArena(DER_DEFAULT_CHUNKSIZE);
  1362.   if( (PRArenaPool *)NULL == arena ) {
  1363.     goto loser;
  1364.   }
  1366.   rv = (CERTOidSequence *)PORT_ArenaZAlloc(arena, sizeof(CERTOidSequence));
  1367.   if( (CERTOidSequence *)NULL == rv ) {
  1368.     goto loser;
  1369.   }
  1371.   rv->oids = (SECItem **)PORT_ArenaZAlloc(arena, sizeof(SECItem *));
  1372.   if( (SECItem **)NULL == rv->oids ) {
  1373.     goto loser;
  1374.   }
  1376.   rv->arena = arena;
  1377.   return rv;
  1379.  loser:
  1380.   if( (PRArenaPool *)NULL != arena ) {
  1381.     PORT_FreeArena(arena, PR_FALSE);
  1382.   }
  1384.   return (CERTOidSequence *)NULL;
  1385. }
  1387. static SECStatus
  1388. AddOidToSequence(CERTOidSequence *os, SECOidTag oidTag)
  1389. {
  1390.   SECItem **oids;
  1391.   PRUint32 count = 0;
  1392.   SECOidData *od;
  1394.   od = SECOID_FindOIDByTag(oidTag);
  1395.   if( (SECOidData *)NULL == od ) {
  1396.     return SECFailure;
  1397.   }
  1399.   for( oids = os->oids; (SECItem *)NULL != *oids; oids++ ) {
  1400.     count++;
  1401.   }
  1403.   /* ArenaZRealloc */
  1405.   {
  1406.     PRUint32 i;
  1408.     oids = (SECItem **)PORT_ArenaZAlloc(os->arena, sizeof(SECItem *) * (count+2));
  1409.     if( (SECItem **)NULL == oids ) {
  1410.       return SECFailure;
  1411.     }
  1412.     
  1413.     for( i = 0; i < count; i++ ) {
  1414.       oids[i] = os->oids[i];
  1415.     }
  1417.     /* ArenaZFree(os->oids); */
  1418.   }
  1420.   os->oids = oids;
  1421.   os->oids[count] = &od->oid;
  1423.   return SECSuccess;
  1424. }
  1426. static SECItem *
  1427. EncodeOidSequence(CERTOidSequence *os)
  1428. {
  1429.   SECItem *rv;
  1430.   extern const SEC_ASN1Template CERT_OidSeqTemplate[];
  1432.   rv = (SECItem *)PORT_ArenaZAlloc(os->arena, sizeof(SECItem));
  1433.   if( (SECItem *)NULL == rv ) {
  1434.     goto loser;
  1435.   }
  1437.   if( !SEC_ASN1EncodeItem(os->arena, rv, os, CERT_OidSeqTemplate) ) {
  1438.     goto loser;
  1439.   }
  1441.   return rv;
  1443.  loser:
  1444.   return (SECItem *)NULL;
  1445. }
  1447. static SECStatus 
  1448. AddExtKeyUsage (void *extHandle)
  1449. {
  1450.   char buffer[5];
  1451.   int value;
  1452.   CERTOidSequence *os;
  1453.   SECStatus rv;
  1454.   SECItem *item;
  1456.   os = CreateOidSequence();
  1457.   if( (CERTOidSequence *)NULL == os ) {
  1458.     return SECFailure;
  1459.   }
  1461.   while (1) {
  1462.     fprintf(stdout, "%-25s 0 - Server Authn", "");
  1463.     fprintf(stdout, "%-25s 1 - Client Authn", "");
  1464.     fprintf(stdout, "%-25s 2 - Code Signingn", "");
  1465.     fprintf(stdout, "%-25s 3 - Email Protectionn", "");
  1466.     fprintf(stdout, "%-25s 4 - Timestampn", "");
  1467.     fprintf(stdout, "%-25s 5 - OSCP Respondern", "");
  1468. #ifdef DEBUG_NSSTEAM_ONLY
  1469.     fprintf(stdout, "%-25s 6 - Step-upn", "");
  1470. #endif /* DEBUG_NSSTEAM_ONLY */
  1471.     fprintf(stdout, "%-25s Other to finishn", "");
  1473.     gets(buffer);
  1474.     value = atoi(buffer);
  1476.     switch( value ) {
  1477.     case 0:
  1478.       rv = AddOidToSequence(os, SEC_OID_EXT_KEY_USAGE_SERVER_AUTH);
  1479.       break;
  1480.     case 1:
  1481.       rv = AddOidToSequence(os, SEC_OID_EXT_KEY_USAGE_CLIENT_AUTH);
  1482.       break;
  1483.     case 2:
  1484.       rv = AddOidToSequence(os, SEC_OID_EXT_KEY_USAGE_CODE_SIGN);
  1485.       break;
  1486.     case 3:
  1487.       rv = AddOidToSequence(os, SEC_OID_EXT_KEY_USAGE_EMAIL_PROTECT);
  1488.       break;
  1489.     case 4:
  1490.       rv = AddOidToSequence(os, SEC_OID_EXT_KEY_USAGE_TIME_STAMP);
  1491.       break;
  1492.     case 5:
  1493.       rv = AddOidToSequence(os, SEC_OID_OCSP_RESPONDER);
  1494.       break;
  1495. #ifdef DEBUG_NSSTEAM_ONLY
  1496.     case 6:
  1497.       rv = AddOidToSequence(os, SEC_OID_NS_KEY_USAGE_GOVT_APPROVED);
  1498.       break;
  1499. #endif /* DEBUG_NSSTEAM_ONLY */
  1500.     default:
  1501.       goto endloop;
  1502.     }
  1504.     if( SECSuccess != rv ) goto loser;
  1505.   }
  1507.  endloop:;
  1508.   item = EncodeOidSequence(os);
  1510.   buffer[0] = 'n';
  1511.   puts ("Is this a critical extension [y/n]? ");
  1512.   gets (buffer);
  1514.   rv = CERT_AddExtension(extHandle, SEC_OID_X509_EXT_KEY_USAGE, item,
  1515.                          ((buffer[0] == 'y' || buffer[0] == 'Y')
  1516.                           ? PR_TRUE : PR_FALSE), PR_TRUE);
  1517.   /*FALLTHROUGH*/
  1518.  loser:
  1519.   CERT_DestroyOidSequence(os);
  1520.   return rv;
  1521. }
  1523. static SECStatus 
  1524. AddNscpCertType (void *extHandle)
  1525. {
  1526.     SECItem bitStringValue;
  1527.     unsigned char keyUsage = 0x0;
  1528.     char buffer[5];
  1529.     int value;
  1531.     while (1) {
  1532. fprintf(stdout, "%-25s 0 - SSL Clientn", "");
  1533. fprintf(stdout, "%-25s 1 - SSL Servern", "");
  1534. fprintf(stdout, "%-25s 2 - S/MIMEn", "");
  1535. fprintf(stdout, "%-25s 3 - Object Signingn", "");   
  1536. fprintf(stdout, "%-25s 4 - Reserved for futuer usen", "");
  1537. fprintf(stdout, "%-25s 5 - SSL CAn", "");   
  1538. fprintf(stdout, "%-25s 6 - S/MIME CAn", "");
  1539. fprintf(stdout, "%-25s 7 - Object Signing CAn", "");
  1540. fprintf(stdout, "%-25s Other to finishn", "");
  1541. gets (buffer);
  1542. value = atoi (buffer);
  1543. if (value < 0 || value > 7)
  1544.     break;
  1545. keyUsage |= (0x80 >> value);
  1546.     }
  1548.     bitStringValue.data = &keyUsage;
  1549.     bitStringValue.len = 1;
  1550.     buffer[0] = 'n';
  1551.     puts ("Is this a critical extension [y/n]? ");
  1552.     gets (buffer);
  1554.     return (CERT_EncodeAndAddBitStrExtension
  1555.     (extHandle, SEC_OID_NS_CERT_EXT_CERT_TYPE, &bitStringValue,
  1556.      (buffer[0] == 'y' || buffer[0] == 'Y') ? PR_TRUE : PR_FALSE));
  1558. }
  1560. typedef SECStatus (* EXTEN_VALUE_ENCODER)
  1561. (PRArenaPool *extHandle, void *value, SECItem *encodedValue);
  1563. static SECStatus 
  1564. EncodeAndAddExtensionValue(
  1565. PRArenaPool * arena, 
  1566. void * extHandle, 
  1567. void * value, 
  1568. PRBool  criticality,
  1569. int  extenType, 
  1570. EXTEN_VALUE_ENCODER EncodeValueFn)
  1571. {
  1572.     SECItem encodedValue;
  1573.     SECStatus rv;
  1576.     encodedValue.data = NULL;
  1577.     encodedValue.len = 0;
  1578.     do {
  1579. rv = (*EncodeValueFn)(arena, value, &encodedValue);
  1580. if (rv != SECSuccess)
  1581. break;
  1583. rv = CERT_AddExtension
  1584.      (extHandle, extenType, &encodedValue, criticality,PR_TRUE);
  1585.     } while (0);
  1587.     return (rv);
  1588. }
  1590. static SECStatus 
  1591. AddBasicConstraint(void *extHandle)
  1592. {
  1593.     CERTBasicConstraints basicConstraint;    
  1594.     SECItem encodedValue;
  1595.     SECStatus rv;
  1596.     char buffer[10];
  1598.     encodedValue.data = NULL;
  1599.     encodedValue.len = 0;
  1600.     do {
  1601. basicConstraint.pathLenConstraint = CERT_UNLIMITED_PATH_CONSTRAINT;
  1602. puts ("Is this a CA certificate [y/n]?");
  1603. gets (buffer);
  1604. basicConstraint.isCA = (buffer[0] == 'Y' || buffer[0] == 'y') ?
  1605.                                 PR_TRUE : PR_FALSE;
  1607. puts ("Enter the path length constraint, enter to skip [<0 for unlimited path]:");
  1608. gets (buffer);
  1609. if (PORT_Strlen (buffer) > 0)
  1610.     basicConstraint.pathLenConstraint = atoi (buffer);
  1612. rv = CERT_EncodeBasicConstraintValue (NULL, &basicConstraint, &encodedValue);
  1613. if (rv)
  1614.     return (rv);
  1616. buffer[0] = 'n';
  1617. puts ("Is this a critical extension [y/n]? ");
  1618. gets (buffer);
  1619. rv = CERT_AddExtension
  1620.      (extHandle, SEC_OID_X509_BASIC_CONSTRAINTS,
  1621.       &encodedValue, (buffer[0] == 'y' || buffer[0] == 'Y') ?
  1622.               PR_TRUE : PR_FALSE ,PR_TRUE);
  1623.     } while (0);
  1624.     PORT_Free (encodedValue.data);
  1625.     return (rv);
  1626. }
  1628. static SECItem *
  1629. SignCert(CERTCertDBHandle *handle, 
  1630. CERTCertificate *cert, PRBool selfsign, 
  1631. SECKEYPrivateKey *selfsignprivkey, char *issuerNickName, void *pwarg)
  1632. {
  1633.     SECItem der;
  1634.     SECItem *result = NULL;
  1635.     SECKEYPrivateKey *caPrivateKey = NULL;    
  1636.     SECStatus rv;
  1637.     PRArenaPool *arena;
  1638.     SECOidTag algID;
  1639.     void *dummy;
  1641.     if( selfsign ) {
  1642.       caPrivateKey = selfsignprivkey;
  1643.     } else {
  1644.       /*CERTCertificate *issuer = CERT_FindCertByNickname(handle, issuerNickName);*/
  1645.       CERTCertificate *issuer = PK11_FindCertFromNickname(issuerNickName, pwarg);
  1646.       if( (CERTCertificate *)NULL == issuer ) {
  1647.         SECU_PrintError(progName, "unable to find issuer with nickname %s", 
  1648.                 issuerNickName);
  1649.         return (SECItem *)NULL;
  1650.       }
  1652.       caPrivateKey = PK11_FindKeyByAnyCert(issuer, pwarg);
  1653.     if (caPrivateKey == NULL) {
  1654. SECU_PrintError(progName, "unable to retrieve key %s", issuerNickName);
  1655. return NULL;
  1656.     }
  1657.     }
  1659.     arena = cert->arena;
  1661.     switch(caPrivateKey->keyType) {
  1662.       case rsaKey:
  1663. algID = SEC_OID_PKCS1_MD5_WITH_RSA_ENCRYPTION;
  1664. break;
  1665.       case dsaKey:
  1666. algID = SEC_OID_ANSIX9_DSA_SIGNATURE_WITH_SHA1_DIGEST;
  1667. break;
  1668.       default:
  1669. fprintf(stderr, "Unknown key type for issuer.");
  1670. goto done;
  1671. break;
  1672.     }
  1674.     rv = SECOID_SetAlgorithmID(arena, &cert->signature, algID, 0);
  1675.     if (rv != SECSuccess) {
  1676. fprintf(stderr, "Could not set signature algorithm id.");
  1677. goto done;
  1678.     }
  1680.     /* we only deal with cert v3 here */
  1681.     *(cert->version.data) = 2;
  1682.     cert->version.len = 1;
  1684.     der.len = 0;
  1685.     der.data = NULL;
  1686.     dummy = SEC_ASN1EncodeItem (arena, &der, cert, CERT_CertificateTemplate);
  1687.     if (!dummy) {
  1688. fprintf (stderr, "Could not encode certificate.n");
  1689. goto done;
  1690.     }
  1692.     result = (SECItem *) PORT_ArenaZAlloc (arena, sizeof (SECItem));
  1693.     if (result == NULL) {
  1694. fprintf (stderr, "Could not allocate item for certificate data.n");
  1695. goto done;
  1696.     }
  1698.     rv = SEC_DerSignData (arena, result, der.data, der.len, caPrivateKey,
  1699.   algID);
  1700.     if (rv != SECSuccess) {
  1701. fprintf (stderr, "Could not sign encoded certificate data.n");
  1702. PORT_Free(result);
  1703. result = NULL;
  1704. goto done;
  1705.     }
  1706.     cert->derCert = *result;
  1707. done:
  1708.     SECKEY_DestroyPrivateKey(caPrivateKey);
  1709.     return result;
  1710. }
  1712. static SECStatus 
  1713. AddAuthKeyID (void *extHandle)
  1714. {
  1715.     CERTAuthKeyID *authKeyID = NULL;    
  1716.     PRArenaPool *arena = NULL;
  1717.     SECStatus rv = SECSuccess;
  1718.     char buffer[512];
  1720.     do {
  1721. arena = PORT_NewArena(DER_DEFAULT_CHUNKSIZE);
  1722. if ( !arena ) {
  1723.     SECU_PrintError(progName, "out of memory");
  1724.     GEN_BREAK (SECFailure);
  1725. }
  1727. if (GetYesNo ("Enter value for the authKeyID extension [y/n]?n") == 0)
  1728.     break;
  1730. authKeyID = PORT_ArenaZAlloc (arena, sizeof (CERTAuthKeyID));
  1731. if (authKeyID == NULL) {
  1732.     GEN_BREAK (SECFailure);
  1733. }
  1735. rv = GetString (arena, "Enter value for the key identifier fields, enter to omit:",
  1736. &authKeyID->keyID);
  1737. if (rv != SECSuccess)
  1738.     break;
  1739. authKeyID->authCertIssuer = GetGeneralName (arena);
  1740. if (authKeyID->authCertIssuer == NULL && SECFailure == PORT_GetError ())
  1741. break;
  1744. rv = GetString (arena, "Enter value for the authCertSerial field, enter to omit:",
  1745. &authKeyID->authCertSerialNumber);
  1747. buffer[0] = 'n';
  1748. puts ("Is this a critical extension [y/n]? ");
  1749. gets (buffer);
  1751. rv = EncodeAndAddExtensionValue
  1752.     (arena, extHandle, authKeyID,
  1753.      (buffer[0] == 'y' || buffer[0] == 'Y') ? PR_TRUE : PR_FALSE,
  1754.      SEC_OID_X509_AUTH_KEY_ID, 
  1755.      (EXTEN_VALUE_ENCODER) CERT_EncodeAuthKeyID);
  1756. if (rv)
  1757.     break;
  1759.     } while (0);
  1760.     if (arena)
  1761. PORT_FreeArena (arena, PR_FALSE);
  1762.     return (rv);
  1763. }   
  1764.     
  1765. static SECStatus 
  1766. AddCrlDistPoint(void *extHandle)
  1767. {
  1768.     PRArenaPool *arena = NULL;
  1769.     CERTCrlDistributionPoints *crlDistPoints = NULL;
  1770.     CRLDistributionPoint *current;
  1771.     SECStatus rv = SECSuccess;
  1772.     int count = 0, intValue;
  1773.     char buffer[5];
  1775.     arena = PORT_NewArena(DER_DEFAULT_CHUNKSIZE);
  1776.     if ( !arena )
  1777. return (SECFailure);
  1779.     do {
  1780. current = NULL;
  1781. current = PORT_ArenaZAlloc (arena, sizeof (*current));
  1782.         if (current == NULL) {
  1783.     GEN_BREAK (SECFailure);
  1784. }   
  1786. /* Get the distributionPointName fields - this field is optional */
  1787. puts ("Enter the type of the distribution point name:n");
  1788. puts ("t1 - Full Nament2 - Relative NamentOther - omitnttChoice: ");
  1789. scanf ("%d", &intValue);
  1790. switch (intValue) {
  1791.     case generalName:
  1792. current->distPointType = intValue;
  1793. current->distPoint.fullName = GetGeneralName (arena);
  1794. rv = PORT_GetError();
  1795. break;
  1797.     case relativeDistinguishedName: {
  1798. CERTName *name;
  1799. char buffer[512];
  1801. current->distPointType = intValue;
  1802. puts ("Enter the relative name: ");
  1803. fflush (stdout);
  1804. gets (buffer);
  1805. /* For simplicity, use CERT_AsciiToName to converse from a string
  1806.    to NAME, but we only interest in the first RDN */
  1807. name = CERT_AsciiToName (buffer);
  1808. if (!name) {
  1809.     GEN_BREAK (SECFailure);
  1810. }
  1811. rv = CERT_CopyRDN (arena, &current->distPoint.relativeName, name->rdns[0]);
  1812. CERT_DestroyName (name);
  1813. break;
  1814.     }
  1815. }
  1816. if (rv != SECSuccess)
  1817.     break;
  1819. /* Get the reason flags */
  1820. puts ("nSelect one of the following for the reason flagsn");
  1821. puts ("t0 - unusednt1 - keyCompromisent2 - caCompromisent3 - affiliationChangedn");
  1822. puts ("t4 - supersedednt5 - cessationOfOperationnt6 - certificateHoldn");
  1823. puts ("tother - omitttChoice: ");
  1825. scanf ("%d", &intValue);
  1826. if (intValue >= 0 && intValue <8) {
  1827.     current->reasons.data = PORT_ArenaAlloc (arena, sizeof(char));
  1828.     if (current->reasons.data == NULL) {
  1829. GEN_BREAK (SECFailure);
  1830.     }
  1831.     *current->reasons.data = (char)(0x80 >> intValue);
  1832.     current->reasons.len = 1;
  1833. }
  1834. puts ("Enter value for the CRL Issuer name:n");
  1835.         current->crlIssuer = GetGeneralName (arena);
  1836. if (current->crlIssuer == NULL && (rv = PORT_GetError()) == SECFailure)
  1837.     break;
  1839. if (crlDistPoints == NULL) {
  1840.     crlDistPoints = PORT_ArenaZAlloc (arena, sizeof (*crlDistPoints));
  1841.     if (crlDistPoints == NULL) {
  1842. GEN_BREAK (SECFailure);
  1843.     }
  1844. }
  1845.     
  1846. crlDistPoints->distPoints = PORT_ArenaGrow (arena, 
  1847.      crlDistPoints->distPoints,
  1848.      sizeof (*crlDistPoints->distPoints) * count,
  1849.      sizeof (*crlDistPoints->distPoints) *(count + 1));
  1850. if (crlDistPoints->distPoints == NULL) {
  1851.     GEN_BREAK (SECFailure);
  1852. }
  1854. crlDistPoints->distPoints[count] = current;
  1855. ++count;
  1856. if (GetYesNo ("Enter more value for the CRL distribution point extension [y/n]n") == 0) {
  1857.     /* Add null to the end of the crlDistPoints to mark end of data */
  1858.     crlDistPoints->distPoints = PORT_ArenaGrow(arena, 
  1859.  crlDistPoints->distPoints,
  1860.  sizeof (*crlDistPoints->distPoints) * count,
  1861.  sizeof (*crlDistPoints->distPoints) *(count + 1));
  1862.     crlDistPoints->distPoints[count] = NULL;     
  1863.     break;
  1864. }
  1867.     } while (1);
  1868.     
  1869.     if (rv == SECSuccess) {
  1870. buffer[0] = 'n';
  1871. puts ("Is this a critical extension [y/n]? ");
  1872. gets (buffer);
  1874. rv = EncodeAndAddExtensionValue(arena, extHandle, crlDistPoints,
  1875.       (buffer[0] == 'Y' || buffer[0] == 'y') ? PR_TRUE : PR_FALSE,
  1876.       SEC_OID_X509_CRL_DIST_POINTS,
  1877.       (EXTEN_VALUE_ENCODER)  CERT_EncodeCRLDistributionPoints);
  1878.     }
  1879.     if (arena)
  1880. PORT_FreeArena (arena, PR_FALSE);
  1881.     return (rv);
  1882. }
  1884. static SECStatus
  1885. CreateCert(
  1886. CERTCertDBHandle *handle, 
  1887. char *  issuerNickName, 
  1888. PRFileDesc *inFile,
  1889. PRFileDesc *outFile, 
  1890. SECKEYPrivateKey *selfsignprivkey,
  1891. void  *pwarg,
  1892. int     serialNumber, 
  1893. int     warpmonths,
  1894. int     validitylength,
  1895. PRBool  selfsign,
  1896. PRBool keyUsage, 
  1897. PRBool  extKeyUsage,
  1898. PRBool  basicConstraint, 
  1899. PRBool  authKeyID,
  1900. PRBool  crlDistPoints, 
  1901. PRBool  nscpCertType)
  1902. {
  1903.     void * extHandle;
  1904.     SECItem * certDER;
  1905.     PRArenaPool *arena = NULL;
  1906.     CERTCertificate *subjectCert  = NULL;
  1907.     /*CERTCertificate *issuerCert  = NULL;*/
  1908.     CERTCertificateRequest *certReq = NULL;
  1909.     SECStatus  rv  = SECSuccess;
  1910.     SECItem  reqDER;
  1912.     reqDER.data = NULL;
  1913.     do {
  1914. arena = PORT_NewArena(DER_DEFAULT_CHUNKSIZE);
  1915. if (!arena) {
  1916.     GEN_BREAK (SEC_ERROR_NO_MEMORY);
  1917. }
  1919. /* Create a certrequest object from the input cert request der */
  1920. certReq = GetCertRequest(inFile);
  1921. if (certReq == NULL) {
  1922.     GEN_BREAK (SECFailure)
  1923. }
  1925. subjectCert = MakeV1Cert (handle, certReq, issuerNickName, selfsign,
  1926.   serialNumber, warpmonths, validitylength);
  1927. if (subjectCert == NULL) {
  1928.     GEN_BREAK (SECFailure)
  1929. }
  1931. extHandle = CERT_StartCertExtensions (subjectCert);
  1932. if (extHandle == NULL) {
  1933.     GEN_BREAK (SECFailure)
  1934. }
  1936. /* Add key usage extension */
  1937. if (keyUsage) {
  1938.     rv = AddKeyUsage(extHandle);
  1939.     if (rv)
  1940. break;
  1941. }
  1943. /* Add extended key usage extension */
  1944. if (extKeyUsage) {
  1945.     rv = AddExtKeyUsage(extHandle);
  1946.     if (rv)
  1947. break;
  1948. }
  1950. /* Add basic constraint extension */
  1951. if (basicConstraint) {
  1952.     rv = AddBasicConstraint(extHandle);
  1953.     if (rv)
  1954. break;
  1955. }
  1957. if (authKeyID) {
  1958.     rv = AddAuthKeyID (extHandle);
  1959.     if (rv)
  1960. break;
  1961. }    
  1964. if (crlDistPoints) {
  1965.     rv = AddCrlDistPoint (extHandle);
  1966.     if (rv)
  1967. break;
  1968. }
  1970. if (nscpCertType) {
  1971.     rv = AddNscpCertType(extHandle);
  1972.     if (rv)
  1973. break;
  1974. }
  1975.        
  1977. CERT_FinishExtensions(extHandle);
  1979. certDER = SignCert (handle, subjectCert, selfsign, selfsignprivkey, issuerNickName,pwarg);
  1981. if (certDER)
  1982.    PR_Write(outFile, certDER->data, certDER->len);
  1983.        /*fwrite (certDER->data, 1, certDER->len, outFile);*/
  1985.     } while (0);
  1986.     CERT_DestroyCertificateRequest (certReq);
  1987.     CERT_DestroyCertificate (subjectCert);
  1988.     PORT_FreeArena (arena, PR_FALSE);
  1989.     if (rv != SECSuccess) {
  1990. PRErrorCode  perr = PR_GetError();
  1991.         fprintf(stderr, "%s: unable to create cert (%s)n", progName,
  1992.                SECU_Strerror(perr));
  1993.     }
  1994.     return (rv);
  1995. }
  1997. /*  Certutil commands  */
  1998. enum {
  1999.     cmd_AddCert = 0,
  2000.     cmd_CreateNewCert,
  2001.     cmd_DeleteCert,
  2002.     cmd_AddEmailCert,
  2003.     cmd_DeleteKey,
  2004.     cmd_GenKeyPair,
  2005.     cmd_PrintHelp,
  2006.     cmd_ListKeys,
  2007.     cmd_ListCerts,
  2008.     cmd_ModifyCertTrust,
  2009.     cmd_NewDBs,
  2010.     cmd_CertReq,
  2011.     cmd_CreateAndAddCert,
  2012.     cmd_ListModules,
  2013.     cmd_CheckCertValidity,
  2014.     cmd_ChangePassword
  2015. };
  2017. /*  Certutil options */
  2018. enum {
  2019.     opt_AddKeyUsageExt = 0,
  2020.     opt_AddBasicConstraintExt,
  2021.     opt_AddAuthorityKeyIDExt,
  2022.     opt_AddCRLDistPtsExt,
  2023.     opt_AddNSCertTypeExt,
  2024.     opt_AddExtKeyUsageExt,
  2025.     opt_ASCIIForIO,
  2026.     opt_ValidityTime,
  2027.     opt_IssuerName,
  2028.     opt_CertDir,
  2029.     opt_VerifySig,
  2030.     opt_PasswordFile,
  2031.     opt_KeySize,
  2032.     opt_TokenName,
  2033.     opt_InputFile,
  2034.     opt_KeyIndex,
  2035.     opt_KeyType,
  2036.     opt_DetailedInfo,
  2037.     opt_SerialNumber,
  2038.     opt_Nickname,
  2039.     opt_OutputFile,
  2040.     opt_PhoneNumber,
  2041.     opt_PQGFile,
  2042.     opt_BinaryDER,
  2043.     opt_Subject,
  2044.     opt_Trust,
  2045.     opt_Usage,
  2046.     opt_Validity,
  2047.     opt_OffsetMonths,
  2048.     opt_SelfSign,
  2049.     opt_Exponent,
  2050.     opt_NoiseFile
  2051. };
  2053. static secuCommandFlag certutil_commands[] =
  2054. {
  2055. { /* cmd_AddCert             */  'A', PR_FALSE, 0, PR_FALSE },
  2056. { /* cmd_CreateNewCert       */  'C', PR_FALSE, 0, PR_FALSE },
  2057. { /* cmd_DeleteCert          */  'D', PR_FALSE, 0, PR_FALSE },
  2058. { /* cmd_AddEmailCert        */  'E', PR_FALSE, 0, PR_FALSE },
  2059. { /* cmd_DeleteKey           */  'F', PR_FALSE, 0, PR_FALSE },
  2060. { /* cmd_GenKeyPair          */  'G', PR_FALSE, 0, PR_FALSE },
  2061. { /* cmd_PrintHelp           */  'H', PR_FALSE, 0, PR_FALSE },
  2062. { /* cmd_ListKeys            */  'K', PR_FALSE, 0, PR_FALSE },
  2063. { /* cmd_ListCerts           */  'L', PR_FALSE, 0, PR_FALSE },
  2064. { /* cmd_ModifyCertTrust     */  'M', PR_FALSE, 0, PR_FALSE },
  2065. { /* cmd_NewDBs              */  'N', PR_FALSE, 0, PR_FALSE },
  2066. { /* cmd_CertReq             */  'R', PR_FALSE, 0, PR_FALSE },
  2067. { /* cmd_CreateAndAddCert    */  'S', PR_FALSE, 0, PR_FALSE },
  2068. { /* cmd_ListModules         */  'U', PR_FALSE, 0, PR_FALSE },
  2069. { /* cmd_CheckCertValidity   */  'V', PR_FALSE, 0, PR_FALSE },
  2070. { /* cmd_ChangePassword      */  'W', PR_FALSE, 0, PR_FALSE }
  2071. };
  2073. static secuCommandFlag certutil_options[] =
  2074. {
  2075. { /* opt_AddKeyUsageExt      */  '1', PR_FALSE, 0, PR_FALSE },
  2076. { /* opt_AddBasicConstraintExt*/ '2', PR_FALSE, 0, PR_FALSE },
  2077. { /* opt_AddAuthorityKeyIDExt*/  '3', PR_FALSE, 0, PR_FALSE },
  2078. { /* opt_AddCRLDistPtsExt    */  '4', PR_FALSE, 0, PR_FALSE },
  2079. { /* opt_AddNSCertTypeExt    */  '5', PR_FALSE, 0, PR_FALSE },
  2080. { /* opt_AddExtKeyUsageExt   */  '6', PR_FALSE, 0, PR_FALSE },
  2081. { /* opt_ASCIIForIO          */  'a', PR_FALSE, 0, PR_FALSE },
  2082. { /* opt_ValidityTime        */  'b', PR_TRUE,  0, PR_FALSE },
  2083. { /* opt_IssuerName          */  'c', PR_TRUE,  0, PR_FALSE },
  2084. { /* opt_CertDir             */  'd', PR_TRUE,  0, PR_FALSE },
  2085. { /* opt_VerifySig           */  'e', PR_FALSE, 0, PR_FALSE },
  2086. { /* opt_PasswordFile        */  'f', PR_TRUE,  0, PR_FALSE },
  2087. { /* opt_KeySize             */  'g', PR_TRUE,  0, PR_FALSE },
  2088. { /* opt_TokenName           */  'h', PR_TRUE,  0, PR_FALSE },
  2089. { /* opt_InputFile           */  'i', PR_TRUE,  0, PR_FALSE },
  2090. { /* opt_KeyIndex            */  'j', PR_TRUE,  0, PR_FALSE },
  2091. { /* opt_KeyType             */  'k', PR_TRUE,  0, PR_FALSE },
  2092. { /* opt_DetailedInfo        */  'l', PR_FALSE, 0, PR_FALSE },
  2093. { /* opt_SerialNumber        */  'm', PR_TRUE,  0, PR_FALSE },
  2094. { /* opt_Nickname            */  'n', PR_TRUE,  0, PR_FALSE },
  2095. { /* opt_OutputFile          */  'o', PR_TRUE,  0, PR_FALSE },
  2096. { /* opt_PhoneNumber         */  'p', PR_TRUE,  0, PR_FALSE },
  2097. { /* opt_PQGFile             */  'q', PR_TRUE,  0, PR_FALSE },
  2098. { /* opt_BinaryDER           */  'r', PR_FALSE, 0, PR_FALSE },
  2099. { /* opt_Subject             */  's', PR_TRUE,  0, PR_FALSE },
  2100. { /* opt_Trust               */  't', PR_TRUE,  0, PR_FALSE },
  2101. { /* opt_Usage               */  'u', PR_TRUE,  0, PR_FALSE },
  2102. { /* opt_Validity            */  'v', PR_TRUE,  0, PR_FALSE },
  2103. { /* opt_OffsetMonths        */  'w', PR_TRUE,  0, PR_FALSE },
  2104. { /* opt_SelfSign            */  'x', PR_FALSE, 0, PR_FALSE },
  2105. { /* opt_Exponent            */  'y', PR_TRUE,  0, PR_FALSE },
  2106. { /* opt_NoiseFile           */  'z', PR_TRUE,  0, PR_FALSE }
  2107. };
  2109. int 
  2110. main(int argc, char **argv)
  2111. {
  2112.     CERTCertDBHandle *certHandle;
  2113.     SECKEYKeyDBHandle *keyHandle;
  2114.     PK11SlotInfo *slot = NULL;
  2115.     CERTName *  subject         = 0;
  2116.     PRFileDesc *inFile          = 0;
  2117.     PRFileDesc *outFile         = 0;
  2118.     char *      certfile        = "tempcert";
  2119.     char *      certreqfile     = "tempcertreq";
  2120.     char *      slotname        = "internal";
  2121.     KeyType     keytype         = rsaKey;
  2122.     /*char * keyslot         = NULL;*/
  2123.     /*char *      keynickname     = NULL;*/
  2124.     char *      name            = NULL;
  2125.     int         keysize         = DEFAULT_KEY_BITS;
  2126.     int         publicExponent  = 0x010001;
  2127.     int         serialNumber    = 0;
  2128.     int         warpmonths      = 0;
  2129.     int         validitylength  = 0;
  2130.     int         commandsEntered = 0;
  2131.     char        commandToRun    = '';
  2132.     secuPWData  pwdata          = { PW_NONE, 0 };
  2134.     SECKEYPrivateKey *privkey;
  2135.     SECKEYPublicKey *pubkey = NULL;
  2137.     int i;
  2138.     SECStatus rv;
  2140.     secuCommand certutil;
  2141.     certutil.numCommands = sizeof(certutil_commands) / sizeof(secuCommandFlag);
  2142.     certutil.numOptions = sizeof(certutil_options) / sizeof(secuCommandFlag);
  2143.     certutil.commands = certutil_commands;
  2144.     certutil.options = certutil_options;
  2146.     progName = strrchr(argv[0], '/');
  2147.     progName = progName ? progName+1 : argv[0];
  2149.     rv = SECU_ParseCommandLine(argc, argv, progName, &certutil);
  2151.     if (rv != SECSuccess)
  2152. Usage(progName);
  2154.     if (certutil.commands[cmd_PrintHelp].activated)
  2155. LongUsage(progName);
  2157.     if (certutil.options[opt_PasswordFile].arg) {
  2158. pwdata.source = PW_FROMFILE;
  2159. pwdata.data = certutil.options[opt_PasswordFile].arg;
  2160.     }
  2162.     if (certutil.options[opt_CertDir].activated)
  2163. SECU_ConfigDirectory(certutil.options[opt_CertDir].arg);
  2165.     if (certutil.options[opt_KeySize].activated) {
  2166. keysize = PORT_Atoi(certutil.options[opt_KeySize].arg);
  2167. if ((keysize < MIN_KEY_BITS) || (keysize > MAX_KEY_BITS)) {
  2168.     PR_fprintf(PR_STDERR, 
  2169.                        "%s -g:  Keysize must be between %d and %d.n",
  2170.                MIN_KEY_BITS, MAX_KEY_BITS);
  2171.     return -1;
  2172. }
  2173.     }
  2175.     /*  -h specify token name  */
  2176.     if (certutil.options[opt_TokenName].activated) {
  2177. if (PL_strcmp(certutil.options[opt_TokenName].arg, "all") == 0)
  2178.     slotname = NULL;
  2179. else
  2180.     slotname = PL_strdup(certutil.options[opt_TokenName].arg);
  2181.     }
  2183.     /*  -k key type  */
  2184.     if (certutil.options[opt_KeyType].activated) {
  2185. if (PL_strcmp(certutil.options[opt_KeyType].arg, "rsa") == 0) {
  2186.     keytype = rsaKey;
  2187. } else if (PL_strcmp(certutil.options[opt_KeyType].arg, "dsa") == 0) {
  2188.     keytype = dsaKey;
  2189. } else if (PL_strcmp(certutil.options[opt_KeyType].arg, "all") == 0) {
  2190.     keytype = nullKey;
  2191. } else {
  2192.     PR_fprintf(PR_STDERR, "%s -k:  %s is not a recognized type.n",
  2193.                progName, certutil.options[opt_KeyType].arg);
  2194.     return -1;
  2195. }
  2196.     }
  2198.     /*  -m serial number */
  2199.     if (certutil.options[opt_SerialNumber].activated) {
  2200. serialNumber = PORT_Atoi(certutil.options[opt_SerialNumber].arg);
  2201. if (serialNumber < 0) {
  2202.     PR_fprintf(PR_STDERR, "%s -m:  %s is not a valid serial number.n",
  2203.                progName, certutil.options[opt_SerialNumber].arg);
  2204.     return -1;
  2205. }
  2206.     }
  2208.     /*  -q PQG file  */
  2209.     if (certutil.options[opt_PQGFile].activated) {
  2210. if (keytype != dsaKey) {
  2211.     PR_fprintf(PR_STDERR, "%s -q: PQG file is for DSA key (-k dsa).n)",
  2212.                progName);
  2213.     return -1;
  2214. }
  2215.     }
  2217.     /*  -s subject name  */
  2218.     if (certutil.options[opt_Subject].activated) {
  2219. subject = CERT_AsciiToName(certutil.options[opt_Subject].arg);
  2220. if (!subject) {
  2221.     PR_fprintf(PR_STDERR, "%s -s: improperly formatted name: "%s"n",
  2222.                progName, certutil.options[opt_Subject].arg);
  2223.     return -1;
  2224. }
  2225.     }
  2227.     /*  -v validity period  */
  2228.     if (certutil.options[opt_Validity].activated) {
  2229. validitylength = PORT_Atoi(certutil.options[opt_Validity].arg);
  2230. if (validitylength < 0) {
  2231.     PR_fprintf(PR_STDERR, "%s -v: incorrect validity period: "%s"n",
  2232.                progName, certutil.options[opt_Validity].arg);
  2233.     return -1;
  2234. }
  2235.     }
  2237.     /*  -w warp months  */
  2238.     if (certutil.options[opt_OffsetMonths].activated)
  2239. warpmonths = PORT_Atoi(certutil.options[opt_OffsetMonths].arg);
  2241.     /*  -y public exponent (for RSA)  */
  2242.     if (certutil.options[opt_Exponent].activated) {
  2243. publicExponent = PORT_Atoi(certutil.options[opt_Exponent].arg);
  2244. if ((publicExponent != 3) &&
  2245.     (publicExponent != 17) &&
  2246.     (publicExponent != 65537)) {
  2247.     PR_fprintf(PR_STDERR, "%s -y: incorrect public exponent %d.", 
  2248.                            progName, publicExponent);
  2249.     PR_fprintf(PR_STDERR, "Must be 3, 17, or 65537.n");
  2250.     return -1;
  2251. }
  2252.     }
  2254.     /*  Check number of commands entered.  */
  2255.     commandsEntered = 0;
  2256.     for (i=0; i< certutil.numCommands; i++) {
  2257. if (certutil.commands[i].activated) {
  2258.     commandToRun = certutil.commands[i].flag;
  2259.     commandsEntered++;
  2260. }
  2261. if (commandsEntered > 1)
  2262.     break;
  2263.     }
  2264.     if (commandsEntered > 1) {
  2265. PR_fprintf(PR_STDERR, "%s: only one command at a time!n", progName);
  2266. PR_fprintf(PR_STDERR, "You entered: ");
  2267. for (i=0; i< certutil.numCommands; i++) {
  2268.     if (certutil.commands[i].activated)
  2269. PR_fprintf(PR_STDERR, " -%c", certutil.commands[i].flag);
  2270. }
  2271. PR_fprintf(PR_STDERR, "n");
  2272. return -1;
  2273.     }
  2274.     if (commandsEntered == 0) {
  2275. PR_fprintf(PR_STDERR, "%s: you must enter a command!n", progName);
  2276. Usage(progName);
  2277.     }
  2279.     /*  -A, -D, -F, -M, -S, -V, and all require -n  */
  2280.     if ((certutil.commands[cmd_AddCert].activated ||
  2281.          certutil.commands[cmd_DeleteCert].activated ||
  2282.          certutil.commands[cmd_DeleteKey].activated ||
  2283.          certutil.commands[cmd_ModifyCertTrust].activated ||
  2284.          certutil.commands[cmd_CreateAndAddCert].activated ||
  2285.          certutil.commands[cmd_CheckCertValidity].activated) &&
  2286.         !certutil.options[opt_Nickname].activated) {
  2287. PR_fprintf(PR_STDERR, 
  2288.           "%s -%c: nickname is required for this command (-n).n",
  2289.            progName, commandToRun);
  2290. return -1;
  2291.     }
  2293.     /*  -A, -E, -M, -S require trust  */
  2294.     if ((certutil.commands[cmd_AddCert].activated ||
  2295.          certutil.commands[cmd_AddEmailCert].activated ||
  2296.          certutil.commands[cmd_ModifyCertTrust].activated ||
  2297.          certutil.commands[cmd_CreateAndAddCert].activated) &&
  2298.         !certutil.options[opt_Trust].activated) {
  2299. PR_fprintf(PR_STDERR, 
  2300.           "%s -%c: trust is required for this command (-t).n",
  2301.            progName, commandToRun);
  2302. return -1;
  2303.     }
  2305.     /*  if -L is given raw or ascii mode, it must be for only one cert.  */
  2306.     if (certutil.commands[cmd_ListCerts].activated &&
  2307.         (certutil.options[opt_ASCIIForIO].activated ||
  2308.          certutil.options[opt_BinaryDER].activated) &&
  2309.         !certutil.options[opt_Nickname].activated) {
  2310. PR_fprintf(PR_STDERR, 
  2311.         "%s: nickname is required to dump cert in raw or ascii mode.n",
  2312.            progName);
  2313. return -1;
  2314.     }
  2315.     
  2316.     /*  -L can only be in (raw || ascii).  */
  2317.     if (certutil.commands[cmd_ListCerts].activated &&
  2318.         certutil.options[opt_ASCIIForIO].activated &&
  2319.         certutil.options[opt_BinaryDER].activated) {
  2320. PR_fprintf(PR_STDERR, 
  2321.            "%s: cannot specify both -r and -a when dumping cert.n",
  2322.            progName);
  2323. return -1;
  2324.     }
  2326.     /*  If making a cert request, need a subject.  */
  2327.     if ((certutil.commands[cmd_CertReq].activated ||
  2328.          certutil.commands[cmd_CreateAndAddCert].activated) &&
  2329.         !certutil.options[opt_Subject].activated) {
  2330. PR_fprintf(PR_STDERR, 
  2331.            "%s -%c: subject is required to create a cert request.n",
  2332.            progName, commandToRun);
  2333. return -1;
  2334.     }
  2336.     /*  If making a cert, need a serial number.  */
  2337.     if ((certutil.commands[cmd_CreateNewCert].activated ||
  2338.          certutil.commands[cmd_CreateAndAddCert].activated) &&
  2339.          !certutil.options[opt_SerialNumber].activated) {
  2340. /*  Make a default serial number from the current time.  */
  2341. PRTime now = PR_Now();
  2342. serialNumber = LL_L2UI(serialNumber, now);
  2343.     }
  2345.     /*  Validation needs the usage to validate for.  */
  2346.     if (certutil.commands[cmd_CheckCertValidity].activated &&
  2347.         !certutil.options[opt_Usage].activated) {
  2348. PR_fprintf(PR_STDERR, 
  2349.            "%s -V: specify a usage to validate the cert for (-u).n",
  2350.            progName);
  2351. return -1;
  2352.     }
  2353.     
  2354.     /*  To make a cert, need either a issuer or to self-sign it.  */
  2355.     if (certutil.commands[cmd_CreateAndAddCert].activated &&
  2356. !(certutil.options[opt_IssuerName].activated ||
  2357.           certutil.options[opt_SelfSign].activated)) {
  2358. PR_fprintf(PR_STDERR,
  2359.            "%s -S: must specify issuer (-c) or self-sign (-x).n",
  2360.            progName);
  2361. return -1;
  2362.     }
  2364.     /*  Using slotname == NULL for listing keys and certs on all slots, 
  2365.      *  but only that. */
  2366.     if (!(certutil.commands[cmd_ListKeys].activated ||
  2367.        certutil.commands[cmd_ListCerts].activated) && slotname == NULL) {
  2368. PR_fprintf(PR_STDERR,
  2369.            "%s -%c: cannot use "-h all" for this command.n",
  2370.            progName, commandToRun);
  2371. return -1;
  2372.     }
  2374.     /*  Using keytype == nullKey for list all key types, but only that.  */
  2375.     if (!certutil.commands[cmd_ListKeys].activated && keytype == nullKey) {
  2376. PR_fprintf(PR_STDERR,
  2377.            "%s -%c: cannot use "-k all" for this command.n",
  2378.            progName, commandToRun);
  2379. return -1;
  2380.     }
  2382.     /*  -S  open outFile, temporary file for cert request.  */
  2383.     if (certutil.commands[cmd_CreateAndAddCert].activated) {
  2384. outFile = PR_Open(certreqfile, PR_RDWR | PR_CREATE_FILE, 00660);
  2385. if (!outFile) {
  2386.     PR_fprintf(PR_STDERR, "%s -o: unable to open "%s" for writing (%ld, %ld)n",
  2387.                           progName, certreqfile,
  2388.                           PR_GetError(), PR_GetOSError());
  2389.     return -1;
  2390. }
  2391.     }
  2393.     /*  Open the input file.  */
  2394.     if (certutil.options[opt_InputFile].activated) {
  2395. inFile = PR_Open(certutil.options[opt_InputFile].arg, PR_RDONLY, 0);
  2396. if (!inFile) {
  2397.     PR_fprintf(PR_STDERR,
  2398.                "%s:  unable to open "%s" for reading (%ld, %ld).n",
  2399.                progName, certutil.options[opt_InputFile].arg,
  2400.                PR_GetError(), PR_GetOSError());
  2401.     return -1;
  2402. }
  2403.     }
  2405.     /*  Open the output file.  */
  2406.     if (certutil.options[opt_OutputFile].activated && !outFile) {
  2407. outFile = PR_Open(certutil.options[opt_OutputFile].arg, 
  2408.                           PR_CREATE_FILE | PR_RDWR, 00660);
  2409. if (!outFile) {
  2410.     PR_fprintf(PR_STDERR,
  2411.                "%s:  unable to open "%s" for writing (%ld, %ld).n",
  2412.                progName, certutil.options[opt_OutputFile].arg,
  2413.                PR_GetError(), PR_GetOSError());
  2414.     return -1;
  2415. }
  2416.     }
  2418.     name = SECU_GetOptionArg(&certutil, opt_Nickname);
  2420.     PK11_SetPasswordFunc(SECU_GetModulePassword);
  2422.     /*  Initialize NSPR and NSS.  */
  2423.     PR_Init(PR_SYSTEM_THREAD, PR_PRIORITY_NORMAL, 1);
  2424.     SEC_Init();
  2425.     certHandle = SECU_OpenCertDB(PR_FALSE);
  2426.     if (certHandle == NULL) {
  2427. SECU_PrintError(progName, "unable to open cert database");
  2428. return -1;
  2429.     }
  2430.     CERT_SetDefaultCertDB(certHandle);
  2431.     keyHandle = SECKEY_GetDefaultKeyDB();
  2432.     SECU_PKCS11Init(PR_FALSE);
  2434.     if (PL_strcmp(slotname, "internal") == 0)
  2435. slot = PK11_GetInternalKeySlot();
  2436.     else if (slotname != NULL)
  2437. slot = PK11_FindSlotByName(slotname);
  2439.     /*  If creating new database, initialize the password.  */
  2440.     if (certutil.commands[cmd_NewDBs].activated) {
  2441. SECU_ChangePW(slot, 0, certutil.options[opt_PasswordFile].arg);
  2442.     }
  2444.     /* The following 8 options are mutually exclusive with all others. */
  2446.     /*  List certs (-L)  */
  2447.     if (certutil.commands[cmd_ListCerts].activated) {
  2448. rv = ListCerts(certHandle, name, slot,
  2449.                certutil.options[opt_BinaryDER].activated,
  2450.                certutil.options[opt_ASCIIForIO].activated, 
  2451.                        (outFile) ? outFile : PR_STDOUT,
  2452.        certutil.options[opt_PasswordFile].arg);
  2453. return !rv - 1;
  2454.     }
  2455.     /*  XXX needs work  */
  2456.     /*  List keys (-K)  */
  2457.     if (certutil.commands[cmd_ListKeys].activated) {
  2458. rv = ListKeys(slot, name, 0 /*keyindex*/, keytype, PR_FALSE /*dopriv*/,
  2459.        certutil.options[opt_PasswordFile].arg);
  2460. return !rv - 1;
  2461.     }
  2462.     /*  List modules (-U)  */
  2463.     if (certutil.commands[cmd_ListModules].activated) {
  2464. rv = ListModules();
  2465. return !rv - 1;
  2466.     }
  2467.     /*  Delete cert (-D)  */
  2468.     if (certutil.commands[cmd_DeleteCert].activated) {
  2469. rv = DeleteCert(certHandle, name);
  2470. return !rv - 1;
  2471.     }
  2472.     /*  Delete key (-F)  */
  2473.     if (certutil.commands[cmd_DeleteKey].activated) {
  2474. rv = DeleteKey(keyHandle, name);
  2475. return !rv - 1;
  2476.     }
  2477.     /*  Modify trust attribute for cert (-M)  */
  2478.     if (certutil.commands[cmd_ModifyCertTrust].activated) {
  2479. rv = ChangeTrustAttributes(certHandle, name, 
  2480.                            certutil.options[opt_Trust].arg);
  2481. return !rv - 1;
  2482.     }
  2483.     /*  Change key db password (-W) (future - change pw to slot?)  */
  2484.     if (certutil.commands[cmd_ChangePassword].activated) {
  2485. rv = SECU_ChangePW(slot, 0, certutil.options[opt_PasswordFile].arg);
  2486. return !rv - 1;
  2487.     }
  2488.     /*  Check cert validity against current time (-V)  */
  2489.     if (certutil.commands[cmd_CheckCertValidity].activated) {
  2490. rv = ValidateCert(certHandle, name, 
  2491.                   certutil.options[opt_ValidityTime].arg,
  2492.   certutil.options[opt_Usage].arg,
  2493.   certutil.options[opt_VerifySig].activated,
  2494.   certutil.options[opt_DetailedInfo].activated);
  2495. return !rv - 1;
  2496.     }
  2498.     /*
  2499.      *  Key generation
  2500.      */
  2502.     /*  These commands require keygen.  */
  2503.     if (certutil.commands[cmd_CertReq].activated ||
  2504.         certutil.commands[cmd_CreateAndAddCert].activated ||
  2505. certutil.commands[cmd_GenKeyPair].activated) {
  2506. /*  XXX Give it a nickname.  */
  2507. privkey = 
  2508.     CERTUTIL_GeneratePrivateKey(keytype, slot, keysize,
  2509.                                 publicExponent, 
  2510.                                 certutil.options[opt_NoiseFile].arg,
  2511.                                 &pubkey, 
  2512.                                 certutil.options[opt_PQGFile].arg,
  2513.                                 certutil.options[opt_PasswordFile].arg);
  2514. if (privkey == NULL) {
  2515.     SECU_PrintError(progName, "unable to generate key(s)n");
  2516.     return -1;
  2517. }
  2518. PORT_Assert(pubkey != NULL);
  2520. /*  If all that was needed was keygen, exit.  */
  2521. if (certutil.commands[cmd_GenKeyPair].activated) {
  2522.     return SECSuccess;
  2523. }
  2524.     }
  2526.     /*
  2527.      *  Certificate request
  2528.      */
  2530.     /*  Make a cert request (-R or -S).  */
  2531.     if (certutil.commands[cmd_CreateAndAddCert].activated ||
  2532.          certutil.commands[cmd_CertReq].activated) {
  2533. rv = CertReq(privkey, pubkey, keytype, subject,
  2534.              certutil.options[opt_PhoneNumber].arg,
  2535.              certutil.options[opt_ASCIIForIO].activated,
  2536.      outFile ? outFile : PR_STDOUT);
  2537. if (rv) 
  2538.     return -1;
  2539.     }
  2541.     /*
  2542.      *  Certificate creation
  2543.      */
  2545.     /*  If making and adding a cert, load the cert request file
  2546.      *  and output the cert to another file.
  2547.      */
  2548.     if (certutil.commands[cmd_CreateAndAddCert].activated) {
  2549. PR_Close(outFile);
  2550. inFile  = PR_Open(certreqfile, PR_RDONLY, 0);
  2551. if (!inFile) {
  2552.     PR_fprintf(PR_STDERR, "Failed to open file "%s" (%ld, %ld).n",
  2553.                        certreqfile, PR_GetError(), PR_GetOSError());
  2554.     return -1;
  2555. }
  2556. outFile = PR_Open(certfile, PR_RDWR | PR_CREATE_FILE, 00660);
  2557. if (!outFile) {
  2558.     PR_fprintf(PR_STDERR, "Failed to open file "%s" (%ld, %ld).n",
  2559.                        certfile, PR_GetError(), PR_GetOSError());
  2560.     return -1;
  2561. }
  2562.     }
  2564.     /*  Create a certificate (-C or -S).  */
  2565.     if (certutil.commands[cmd_CreateAndAddCert].activated ||
  2566.          certutil.commands[cmd_CreateNewCert].activated) {
  2567. rv = CreateCert(certHandle, 
  2568.                 certutil.options[opt_IssuerName].arg,
  2569.                 inFile, outFile, privkey, &pwdata,
  2570.                 serialNumber, warpmonths, validitylength,
  2571.                 certutil.options[opt_SelfSign].activated,
  2572.                 certutil.options[opt_AddKeyUsageExt].activated,
  2573.                 certutil.options[opt_AddExtKeyUsageExt].activated,
  2574.                 certutil.options[opt_AddBasicConstraintExt].activated,
  2575.                 certutil.options[opt_AddAuthorityKeyIDExt].activated,
  2576.                 certutil.options[opt_AddCRLDistPtsExt].activated,
  2577.                 certutil.options[opt_AddNSCertTypeExt].activated);
  2578. if (rv) 
  2579.     return -1;
  2580.     }
  2582.     /* 
  2583.      * Adding a cert to the database (or slot)
  2584.      */
  2585.  
  2586.     if (certutil.commands[cmd_CreateAndAddCert].activated) { 
  2587. PR_Close(inFile);
  2588. PR_Close(outFile);
  2589. inFile = PR_Open(certfile, PR_RDONLY, 0);
  2590. if (!inFile) {
  2591.     PR_fprintf(PR_STDERR, "Failed to open file "%s" (%ld, %ld).n",
  2592.                        certfile, PR_GetError(), PR_GetOSError());
  2593.     return -1;
  2594. }
  2595.     }
  2597.     if (certutil.commands[cmd_CreateAndAddCert].activated ||
  2598.          certutil.commands[cmd_AddCert].activated ||
  2599.  certutil.commands[cmd_AddEmailCert].activated) {
  2600. rv = AddCert(slot, certHandle, name, 
  2601.              certutil.options[opt_Trust].arg,
  2602.              inFile, 
  2603.              certutil.options[opt_ASCIIForIO].activated,
  2604.              certutil.commands[cmd_AddEmailCert].activated);
  2605. if (rv) 
  2606.     return -1;
  2607.     }
  2609.     if (certutil.commands[cmd_CreateAndAddCert].activated) {
  2610. PR_Close(inFile);
  2611. PR_Delete(certfile);
  2612. PR_Delete(certreqfile);
  2613.     }
  2615.     if ( certHandle ) {
  2616. CERT_ClosePermCertDB(certHandle);
  2617.     }
  2619.     return rv;  
  2620. }