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

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

CA认证

开发平台：

WINDOWS

keyutil.c：源码内容
  1. /*
  2.  * The contents of this file are subject to the Mozilla Public
  3.  * License Version 1.1 (the "License"); you may not use this file
  4.  * except in compliance with the License. You may obtain a copy of
  5.  * the License at http://www.mozilla.org/MPL/
  6.  * 
  7.  * Software distributed under the License is distributed on an "AS
  8.  * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
  9.  * implied. See the License for the specific language governing
  10.  * rights and limitations under the License.
  11.  * 
  12.  * The Original Code is the Netscape security libraries.
  13.  * 
  14.  * The Initial Developer of the Original Code is Netscape
  15.  * Communications Corporation.  Portions created by Netscape are 
  16.  * Copyright (C) 1994-2000 Netscape Communications Corporation.  All
  17.  * Rights Reserved.
  18.  * 
  19.  * Contributor(s):
  20.  * 
  21.  * Alternatively, the contents of this file may be used under the
  22.  * terms of the GNU General Public License Version 2 or later (the
  23.  * "GPL"), in which case the provisions of the GPL are applicable 
  24.  * instead of those above.  If you wish to allow use of your 
  25.  * version of this file only under the terms of the GPL and not to
  26.  * allow others to use your version of this file under the MPL,
  27.  * indicate your decision by deleting the provisions above and
  28.  * replace them with the notice and other provisions required by
  29.  * the GPL.  If you do not delete the provisions above, a recipient
  30.  * may use your version of this file under either the MPL or the
  31.  * GPL.
  32.  */
  34. #include <stdio.h>
  35. #include <string.h>
  36. #include "secutil.h"
  38. #if defined(XP_UNIX)
  39. #include <unistd.h>
  40. #include <sys/time.h>
  41. #include <termios.h>
  42. #endif
  44. #include "secopt.h"
  46. #if defined(XP_WIN)
  47. #include <time.h>
  48. #include <conio.h>
  49. #endif
  51. #if defined(__sun) && !defined(SVR4)
  52. extern int fclose(FILE*);
  53. extern int fprintf(FILE *, char *, ...);
  54. extern int getopt(int, char**, char*);
  55. extern int isatty(int);
  56. extern char *optarg;
  57. extern char *sys_errlist[];
  58. #define strerror(errno) sys_errlist[errno]
  59. #endif
  61. #include "nspr.h"
  62. #include "prtypes.h"
  63. #include "prtime.h"
  64. #include "prlong.h"
  66. static char *progName;
  68. static SECStatus
  69. ListKeys(SECKEYKeyDBHandle *handle, FILE *out)
  70. {
  71.     int rt;
  73.     rt = SECU_PrintKeyNames(handle, out);
  74.     if (rt) {
  75. SECU_PrintError(progName, "unable to list nicknames");
  76. return SECFailure;
  77.     }
  78.     return SECSuccess;
  79. }
  81. static SECStatus
  82. DumpPublicKey(SECKEYKeyDBHandle *handle, char *nickname, FILE *out)
  83. {
  84.     SECKEYLowPrivateKey *privKey;
  85.     SECKEYLowPublicKey *publicKey;
  87.     /* check if key actually exists */
  88.     if (SECU_CheckKeyNameExists(handle, nickname) == PR_FALSE) {
  89. SECU_PrintError(progName, "the key "%s" does not exist", nickname);
  90. return SECFailure;
  91.     }
  93.     /* Read in key */
  94.     privKey = SECU_GetPrivateKey(handle, nickname);
  95.     if (!privKey) {
  96. return SECFailure;
  97.     }
  99.     publicKey = SECKEY_LowConvertToPublicKey(privKey);
  101.     /* Output public key (in the clear) */
  102.     switch(publicKey->keyType) {
  103.       case rsaKey:
  104. fprintf(out, "RSA Public-Key:n");
  105. SECU_PrintInteger(out, &publicKey->u.rsa.modulus, "modulus", 1);
  106. SECU_PrintInteger(out, &publicKey->u.rsa.publicExponent,
  107.   "publicExponent", 1);
  108. break;
  109.       case dsaKey:
  110. fprintf(out, "DSA Public-Key:n");
  111. SECU_PrintInteger(out, &publicKey->u.dsa.params.prime, "prime", 1);
  112. SECU_PrintInteger(out, &publicKey->u.dsa.params.subPrime,
  113.   "subPrime", 1);
  114. SECU_PrintInteger(out, &publicKey->u.dsa.params.base, "base", 1);
  115. SECU_PrintInteger(out, &publicKey->u.dsa.publicValue, "publicValue", 1);
  116. break;
  117.       default:
  118. fprintf(out, "unknown key typen");
  119. break;
  120.     }
  121.     return SECSuccess;
  122. }
  124. static SECStatus
  125. DumpPrivateKey(SECKEYKeyDBHandle *handle, char *nickname, FILE *out)
  126. {
  127.     SECKEYLowPrivateKey *key;
  129.     /* check if key actually exists */
  130.     if (SECU_CheckKeyNameExists(handle, nickname) == PR_FALSE) {
  131. SECU_PrintError(progName, "the key "%s" does not exist", nickname);
  132. return SECFailure;
  133.     }
  135.     /* Read in key */
  136.     key = SECU_GetPrivateKey(handle, nickname);
  137.     if (!key) {
  138. SECU_PrintError(progName, "error retrieving key");
  139. return SECFailure;
  140.     }
  142.     switch(key->keyType) {
  143.       case rsaKey:
  144. fprintf(out, "RSA Private-Key:n");
  145. SECU_PrintInteger(out, &key->u.rsa.modulus, "modulus", 1);
  146. SECU_PrintInteger(out, &key->u.rsa.publicExponent, "publicExponent", 1);
  147. SECU_PrintInteger(out, &key->u.rsa.privateExponent,
  148.   "privateExponent", 1);
  149. SECU_PrintInteger(out, &key->u.rsa.prime1, "prime1", 1);
  150. SECU_PrintInteger(out, &key->u.rsa.prime2, "prime2", 1);
  151. SECU_PrintInteger(out, &key->u.rsa.exponent1, "exponent1", 1);
  152. SECU_PrintInteger(out, &key->u.rsa.exponent2, "exponent2", 1);
  153. SECU_PrintInteger(out, &key->u.rsa.coefficient, "coefficient", 1);
  154. break;
  155.       case dsaKey:
  156. fprintf(out, "DSA Private-Key:n");
  157. SECU_PrintInteger(out, &key->u.dsa.params.prime, "prime", 1);
  158. SECU_PrintInteger(out, &key->u.dsa.params.subPrime, "subPrime", 1);
  159. SECU_PrintInteger(out, &key->u.dsa.params.base, "base", 1);
  160. SECU_PrintInteger(out, &key->u.dsa.publicValue, "publicValue", 1);
  161. SECU_PrintInteger(out, &key->u.dsa.privateValue, "privateValue", 1);
  162. break;
  163.       default:
  164. fprintf(out, "unknown key typen");
  165. break;
  166.     }
  167.     return SECSuccess;
  168. }
  170. static SECStatus
  171. ChangePassword(SECKEYKeyDBHandle *handle)
  172. {
  173.     SECStatus rv;
  175.     /* Write out database with a new password */
  176.     rv = SECU_ChangeKeyDBPassword(handle, NULL);
  177.     if (rv) {
  178. SECU_PrintError(progName, "unable to change key password");
  179.     }
  180.     return rv;
  181. }
  183. static SECStatus
  184. DeletePrivateKey (SECKEYKeyDBHandle *keyHandle, char *nickName)
  185. {
  186.     SECStatus rv;
  188.     rv = SECU_DeleteKeyByName (keyHandle, nickName);
  189.     if (rv != SECSuccess)
  190. fprintf(stderr, "%s: problem deleting private key (%s)n",
  191. progName, SECU_Strerror(PR_GetError()));
  192.     return (rv);
  194. }
  197. static void
  198. Usage(const char *progName)
  199. {
  200.     fprintf(stderr,
  201.     "Usage:  %s -p name [-d keydir]n", progName);
  202.     fprintf(stderr,
  203.     "        %s -P name [-d keydir]n", progName);
  204.     fprintf(stderr,
  205.     "        %s -D name [-d keydir]n", progName);
  206.     fprintf(stderr,
  207.     "        %s -l [-d keydir]n", progName);
  208.     fprintf(stderr,
  209.     "        %s -c [-d keydir]n", progName);
  211.     fprintf(stderr, "%-20s Pretty print public key info for named keyn",
  212.     "-p nickname");
  213.     fprintf(stderr, "%-20s Pretty print private key info for named keyn",
  214.     "-P nickname");
  215.     fprintf(stderr, "%-20s Delete named private key from the key databasen",
  216.     "-D nickname");
  217.     fprintf(stderr, "%-20s List the nicknames for the keys in a databasen",
  218.     "-l");
  219.     fprintf(stderr, "%-20s Change the key database passwordn",
  220.     "-c");
  221.     fprintf(stderr, "n");
  222.     fprintf(stderr, "%-20s Key database directory (default is ~/.netscape)n",
  223.     "-d keydir");
  225.     exit(-1);
  226. }
  228. int main(int argc, char **argv)
  229. {
  230.     int o, changePassword, deleteKey, dumpPublicKey, dumpPrivateKey, list;
  231.     char *nickname;
  232.     SECStatus rv;
  233.     SECKEYKeyDBHandle *keyHandle;
  235.     progName = strrchr(argv[0], '/');
  236.     progName = progName ? progName+1 : argv[0];
  238.     /* Parse command line arguments */
  239.     changePassword = deleteKey = dumpPublicKey = dumpPrivateKey = list = 0;
  240.     nickname = NULL;
  242.     while ((o = getopt(argc, argv, "ADP:cd:glp:")) != -1) {
  243. switch (o) {
  244.   case '?':
  245.     Usage(progName);
  246.     break;
  248.   case 'A':
  249.     fprintf(stderr, "%s: Can no longer add a key.", progName);
  250.     fprintf(stderr, " Use pkcs12 to import a key.nn");
  251.     Usage(progName);
  252.     break;
  254.   case 'D':
  255.     deleteKey = 1;
  256.     nickname = optarg;
  257.     break;
  259.   case 'P':
  260.     dumpPrivateKey = 1;
  261.     nickname = optarg;
  262.     break;
  264.   case 'c':
  265.     changePassword = 1;
  266.     break;
  268.   case 'd':
  269.     SECU_ConfigDirectory(optarg);
  270.     break;
  272.   case 'g':
  273.     fprintf(stderr, "%s: Can no longer generate a key.", progName);
  274.     fprintf(stderr, " Use certutil to generate a cert request.nn");
  275.     Usage(progName);
  276.     break;
  278.   case 'l':
  279.     list = 1;
  280.     break;
  282.   case 'p':
  283.     dumpPublicKey = 1;
  284.     nickname = optarg;
  285.     break;
  286. }
  287.     }
  289.     if (dumpPublicKey+changePassword+dumpPrivateKey+list+deleteKey != 1)
  290. Usage(progName);
  292.     if ((list || changePassword) && nickname)
  293. Usage(progName);
  295.     if ((dumpPublicKey || dumpPrivateKey || deleteKey) && !nickname)
  296. Usage(progName);
  299.     /* Call the libsec initialization routines */
  300.     PR_Init( PR_SYSTEM_THREAD, PR_PRIORITY_NORMAL, 1);
  301.     SEC_Init();
  303.     /*
  304.      * XXX Note that the following opens the key database writable.
  305.      * If dumpPublicKey or dumpPrivateKey or list, though, we only want
  306.      * to open it read-only.  There needs to be a better interface
  307.      * to the initialization routines so that we can specify which way
  308.      * to open it.
  309.      */
  310.     rv = SECU_PKCS11Init();
  311.     if (rv != SECSuccess) {
  312.         SECU_PrintError(progName, "SECU_PKCS11Init failed");
  313. return -1;
  314.     }
  316.     keyHandle = SECKEY_GetDefaultKeyDB();
  317.     if (keyHandle == NULL) {
  318.         SECU_PrintError(progName, "could not open key database");
  319. return -1;
  320.     }
  322.     if (dumpPublicKey) {
  323. rv = DumpPublicKey(keyHandle, nickname, stdout);
  324.     } else
  325.     if (changePassword) {
  326. rv = ChangePassword(keyHandle);
  327.     } else
  328.     if (dumpPrivateKey) {
  329. rv = DumpPrivateKey(keyHandle, nickname, stdout);
  330.     } else
  331.     if (list) {
  332. rv = ListKeys(keyHandle, stdout);
  333.     } else
  334.     if (deleteKey) {
  335. rv = DeletePrivateKey(keyHandle, nickname);
  336.     }
  338.     
  339.     return rv ? -1 : 0;
  340. }