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

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

CA认证

开发平台：

WINDOWS

keystuff.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. #if defined(XP_WIN) || defined (XP_PC)
  45. #include <time.h>
  46. #include <conio.h>
  47. #endif
  49. #if defined(__sun) && !defined(SVR4)
  50. extern int fclose(FILE*);
  51. extern int fprintf(FILE *, char *, ...);
  52. extern int isatty(int);
  53. extern char *sys_errlist[];
  54. #define strerror(errno) sys_errlist[errno]
  55. #endif
  57. #include "nspr.h"
  58. #include "prtypes.h"
  59. #include "prtime.h"
  60. #include "prlong.h"
  62. #include "pk11func.h"
  63. #include "secrng.h"
  64. #include "pqgutil.h"
  66. #define NUM_KEYSTROKES 120
  67. #define RAND_BUF_SIZE 60
  69. #define ERROR_BREAK rv = SECFailure;break;
  72. static void
  73. UpdateRNG(void)
  74. {
  75.     char *         randbuf;
  76.     int            fd, i, count;
  77.     char           c;
  78. #ifdef XP_UNIX
  79.     cc_t           orig_cc_min;
  80.     cc_t           orig_cc_time;
  81.     tcflag_t       orig_lflag;
  82.     struct termios tio;
  83. #endif
  85. #define FPS fprintf(stderr, 
  86.     FPS "n");
  87.     FPS "A random seed must be generated that will be used in then");
  88.     FPS "creation of your key.  One of the easiest ways to create an");
  89.     FPS "random seed is to use the timing of keystrokes on a keyboard.n");
  90.     FPS "n");
  91.     FPS "To begin, type keys on the keyboard until this progress metern");
  92.     FPS "is full.  DO NOT USE THE AUTOREPEAT FUNCTION ON YOUR KEYBOARD!n");
  93.     FPS "n");
  94.     FPS "n");
  95.     FPS "Continue typing until the progress meter is full:nn");
  96.     FPS "|                                                            |r");
  98.     /* turn off echo on stdin & return on 1 char instead of NL */
  99.     fd = fileno(stdin);
  101. #ifdef XP_UNIX
  102.     tcgetattr(fd, &tio);
  103.     orig_lflag = tio.c_lflag;
  104.     orig_cc_min = tio.c_cc[VMIN];
  105.     orig_cc_time = tio.c_cc[VTIME];
  106.     tio.c_lflag &= ~ECHO;
  107.     tio.c_lflag &= ~ICANON;
  108.     tio.c_cc[VMIN] = 1;
  109.     tio.c_cc[VTIME] = 0;
  110.     tcsetattr(fd, TCSAFLUSH, &tio);
  111. #endif
  113.     /* Get random noise from keyboard strokes */
  114.     randbuf = (char *) PORT_Alloc(RAND_BUF_SIZE);
  115.     count = 0;
  116.     while (count < NUM_KEYSTROKES+1) {
  117. #ifdef XP_UNIX
  118. c = getc(stdin);
  119. #else
  120. c = getch();
  121. #endif
  122. RNG_GetNoise(&randbuf[1], sizeof(randbuf)-1);
  123. RNG_RandomUpdate(randbuf, sizeof(randbuf));
  124. if (c != randbuf[0]) {
  125.     randbuf[0] = c;
  126.     FPS "r|");
  127.     for (i=0; i<count/(NUM_KEYSTROKES/RAND_BUF_SIZE); i++) {
  128. FPS "*");
  129.     }
  130.     if (count%(NUM_KEYSTROKES/RAND_BUF_SIZE) == 1)
  131. FPS "/");
  132.     count++;
  133. }
  134.     }
  135.     free(randbuf); 
  137.     FPS "nn");
  138.     FPS "Finished.  Press enter to continue: ");
  139.     while (getc(stdin) != 'n')
  140. ;
  141.     FPS "n");
  143. #undef FPS
  145. #ifdef XP_UNIX
  146.     /* set back termio the way it was */
  147.     tio.c_lflag = orig_lflag;
  148.     tio.c_cc[VMIN] = orig_cc_min;
  149.     tio.c_cc[VTIME] = orig_cc_time;
  150.     tcsetattr(fd, TCSAFLUSH, &tio);
  151. #endif
  152. }
  155. static unsigned char P[] = { 0x00, 0x8d, 0xf2, 0xa4, 0x94, 0x49, 0x22, 0x76,
  156.      0xaa, 0x3d, 0x25, 0x75, 0x9b, 0xb0, 0x68, 0x69,
  157.      0xcb, 0xea, 0xc0, 0xd8, 0x3a, 0xfb, 0x8d, 0x0c,
  158.      0xf7, 0xcb, 0xb8, 0x32, 0x4f, 0x0d, 0x78, 0x82,
  159.      0xe5, 0xd0, 0x76, 0x2f, 0xc5, 0xb7, 0x21, 0x0e,
  160.      0xaf, 0xc2, 0xe9, 0xad, 0xac, 0x32, 0xab, 0x7a,
  161.      0xac, 0x49, 0x69, 0x3d, 0xfb, 0xf8, 0x37, 0x24,
  162.      0xc2, 0xec, 0x07, 0x36, 0xee, 0x31, 0xc8, 0x02,
  163.      0x91 };
  164. static unsigned char Q[] = { 0x00, 0xc7, 0x73, 0x21, 0x8c, 0x73, 0x7e, 0xc8,
  165.      0xee, 0x99, 0x3b, 0x4f, 0x2d, 0xed, 0x30, 0xf4,
  166.      0x8e, 0xda, 0xce, 0x91, 0x5f };
  167. static unsigned char G[] = { 0x00, 0x62, 0x6d, 0x02, 0x78, 0x39, 0xea, 0x0a,
  168.      0x13, 0x41, 0x31, 0x63, 0xa5, 0x5b, 0x4c, 0xb5,
  169.      0x00, 0x29, 0x9d, 0x55, 0x22, 0x95, 0x6c, 0xef,
  170.      0xcb, 0x3b, 0xff, 0x10, 0xf3, 0x99, 0xce, 0x2c,
  171.      0x2e, 0x71, 0xcb, 0x9d, 0xe5, 0xfa, 0x24, 0xba,
  172.      0xbf, 0x58, 0xe5, 0xb7, 0x95, 0x21, 0x92, 0x5c,
  173.      0x9c, 0xc4, 0x2e, 0x9f, 0x6f, 0x46, 0x4b, 0x08,
  174.      0x8c, 0xc5, 0x72, 0xaf, 0x53, 0xe6, 0xd7, 0x88,
  175.      0x02 };
  177. static PQGParams default_pqg_params = {
  178.     NULL,
  179.     { 0, P, sizeof(P) },
  180.     { 0, Q, sizeof(Q) },
  181.     { 0, G, sizeof(G) }
  182. };
  184. static PQGParams *
  185. decode_pqg_params(char *str)
  186. {
  187.     char *buf;
  188.     unsigned int len;
  189.     PRArenaPool *arena;
  190.     PQGParams *params;
  191.     SECStatus status;
  192.  
  193.     arena = PORT_NewArena(DER_DEFAULT_CHUNKSIZE);
  194.     if (arena == NULL)
  195.         return NULL;
  196.  
  197.     params = PORT_ArenaZAlloc(arena, sizeof(PQGParams));
  198.     if (params == NULL)
  199.         goto loser;
  200.     params->arena = arena;
  201.  
  202.     buf = (char *)ATOB_AsciiToData(str, &len);
  203.     if ((buf == NULL) || (len == 0))
  204.         goto loser;
  205.  
  206.     status = SEC_ASN1Decode(arena, params, SECKEY_PQGParamsTemplate, buf, len);
  207.     if (status != SECSuccess)
  208.         goto loser;
  209.  
  210.     return params;
  211.  
  212. loser:
  213.     if (arena != NULL)
  214.         PORT_FreeArena(arena, PR_FALSE);
  215.     return NULL;
  216. }
  217.  
  218. static int
  219. pqg_prime_bits(char *str)
  220. {
  221.     PQGParams *params = NULL;
  222.     int primeBits = 0, i;
  223.  
  224.     params = decode_pqg_params(str);
  225.     if (params == NULL)
  226.         goto done; /* lose */
  227.  
  228.     for (i = 0; params->prime.data[i] == 0; i++)
  229.         /* empty */;
  230. primeBits = (params->prime.len - i) * 8;
  231.  
  232. done:
  233.     if (params != NULL)
  234.         PQG_DestroyParams(params);
  235.     return primeBits;
  236. }
  238. static char *
  239. SECU_GetpqgString(char *filename)
  240. {
  241.     unsigned char phrase[400];
  242.     FILE *fh;
  243.     char *rv;
  245.     fh = fopen(filename,"r");
  246.     rv = fgets ((char*) phrase, sizeof(phrase), fh);
  248.     fclose(fh);
  249.     if (phrase[strlen(phrase)-1] == 'n')
  250. phrase[strlen(phrase)-1] = '';
  251.     if (rv) {
  252. return (char*) PORT_Strdup((char*)phrase);
  253.     }
  254.     fprintf(stderr,"pqg file contain no datan");
  255.     return NULL;
  256. }
  258. PQGParams*
  259. getpqgfromfile(int keyBits, char *pqgFile)
  260. {
  261.     char *end, *str, *pqgString;
  262.     int primeBits;
  264.     pqgString = SECU_GetpqgString(pqgFile);
  265.     if (pqgString)
  266. str = PORT_Strdup(pqgString);
  267.     else
  268. return NULL;
  270.     do {
  271. end = PORT_Strchr(str, ',');
  272. if (end)
  273.     *end = '';
  274. primeBits = pqg_prime_bits(str);
  275. if (keyBits == primeBits)
  276.     goto found_match;
  277. str = end + 1;
  278.     } while (end);
  280.     PORT_Free(pqgString);
  281.     PORT_Free(str);
  282.     return NULL;
  284. found_match:
  285.     PORT_Free(pqgString);
  286.     PORT_Free(str);
  287.     return decode_pqg_params(str);
  288. }
  290. SECKEYPrivateKey *
  291. CERTUTIL_GeneratePrivateKey(KeyType keytype, PK11SlotInfo *slot, int size,
  292.     int publicExponent, char *noise, 
  293.     SECKEYPublicKey **pubkeyp, char *pqgFile,
  294.                             char *passFile)
  295. {
  296.     CK_MECHANISM_TYPE mechanism;
  297.     SECOidTag algtag;
  298.     PK11RSAGenParams rsaparams;
  299.     PQGParams *dsaparams = NULL;
  300.     void *params;
  301.     secuPWData pwdata = { PW_NONE, 0 };
  303.     /*
  304.      * Do some random-number initialization.
  305.      */
  306.     RNG_SystemInfoForRNG();
  308.     if (noise) {
  309.      RNG_FileForRNG(noise);
  310.     } else {
  311. UpdateRNG();
  312.     }
  314.     switch (keytype) {
  315.       case rsaKey:
  316. rsaparams.keySizeInBits = size;
  317. rsaparams.pe = publicExponent;
  318. mechanism = CKM_RSA_PKCS_KEY_PAIR_GEN;
  319. algtag = SEC_OID_PKCS1_MD5_WITH_RSA_ENCRYPTION;
  320. params = &rsaparams;
  321. break;
  322.       case dsaKey:
  323. mechanism = CKM_DSA_KEY_PAIR_GEN;
  324. algtag = SEC_OID_ANSIX9_DSA_SIGNATURE_WITH_SHA1_DIGEST;
  325. if (pqgFile) {
  326.     dsaparams = getpqgfromfile(size, pqgFile);
  327. } else {
  328.     dsaparams = &default_pqg_params;
  329. }
  330. params = dsaparams;
  331.       default:
  332. return NULL;
  333.     }
  335.     if (slot == NULL)
  336. return NULL;
  338.     if (passFile) {
  339. pwdata.source = PW_FROMFILE;
  340. pwdata.data = passFile;
  341.     }
  343.     if (PK11_Authenticate(slot, PR_TRUE, &pwdata) != SECSuccess)
  344. return NULL;
  346.     fprintf(stderr, "nn");
  347.     fprintf(stderr, "Generating key.  This may take a few moments...nn");
  349.     return PK11_GenerateKeyPair(slot, mechanism, params, pubkeyp,
  350. PR_TRUE /*isPerm*/, PR_TRUE /*isSensitive*/, 
  351. NULL /*wincx*/);
  352. }
  354. /*
  355.  * The following is all functionality moved over from keyutil, which may
  356.  * or may not become completely obsolete.  So, some of this stuff may
  357.  * end up being turned on from within certutil.  Some is probably not
  358.  * even feasible anymore (Add/Delete?).
  359.  */
  360. #ifdef LATER
  362. static SECStatus
  363. ListKeys(FILE *out)
  364. {
  365.     int rt;
  367.     rt = SECU_PrintKeyNames(handle, out);
  368.     if (rt) {
  369. SECU_PrintError(progName, "unable to list nicknames");
  370. return SECFailure;
  371.     }
  372.     return SECSuccess;
  373. }
  375. static SECStatus
  376. DumpPublicKey(char *nickname, FILE *out)
  377. {
  378.     SECKEYLowPrivateKey *privKey;
  379.     SECKEYLowPublicKey *publicKey;
  381.     /* check if key actually exists */
  382.     if (SECU_CheckKeyNameExists(handle, nickname) == PR_FALSE) {
  383. SECU_PrintError(progName, "the key "%s" does not exist", nickname);
  384. return SECFailure;
  385.     }
  387.     /* Read in key */
  388.     privKey = SECU_GetPrivateKey(handle, nickname);
  389.     if (!privKey) {
  390. return SECFailure;
  391.     }
  393.     publicKey = SECKEY_LowConvertToPublicKey(privKey);
  395.     /* Output public key (in the clear) */
  396.     switch(publicKey->keyType) {
  397.       case rsaKey:
  398. fprintf(out, "RSA Public-Key:n");
  399. SECU_PrintInteger(out, &publicKey->u.rsa.modulus, "modulus", 1);
  400. SECU_PrintInteger(out, &publicKey->u.rsa.publicExponent,
  401.   "publicExponent", 1);
  402. break;
  403.       case dsaKey:
  404. fprintf(out, "DSA Public-Key:n");
  405. SECU_PrintInteger(out, &publicKey->u.dsa.params.prime, "prime", 1);
  406. SECU_PrintInteger(out, &publicKey->u.dsa.params.subPrime,
  407.   "subPrime", 1);
  408. SECU_PrintInteger(out, &publicKey->u.dsa.params.base, "base", 1);
  409. SECU_PrintInteger(out, &publicKey->u.dsa.publicValue, "publicValue", 1);
  410. break;
  411.       default:
  412. fprintf(out, "unknown key typen");
  413. break;
  414.     }
  415.     return SECSuccess;
  416. }
  418. static SECStatus
  419. DumpPrivateKey(char *nickname, FILE *out)
  420. {
  421.     SECKEYLowPrivateKey *key;
  423.     /* check if key actually exists */
  424.     if (SECU_CheckKeyNameExists(handle, nickname) == PR_FALSE) {
  425. SECU_PrintError(progName, "the key "%s" does not exist", nickname);
  426. return SECFailure;
  427.     }
  429.     /* Read in key */
  430.     key = SECU_GetPrivateKey(handle, nickname);
  431.     if (!key) {
  432. SECU_PrintError(progName, "error retrieving key");
  433. return SECFailure;
  434.     }
  436.     switch(key->keyType) {
  437.       case rsaKey:
  438. fprintf(out, "RSA Private-Key:n");
  439. SECU_PrintInteger(out, &key->u.rsa.modulus, "modulus", 1);
  440. SECU_PrintInteger(out, &key->u.rsa.publicExponent, "publicExponent", 1);
  441. SECU_PrintInteger(out, &key->u.rsa.privateExponent,
  442.   "privateExponent", 1);
  443. SECU_PrintInteger(out, &key->u.rsa.prime[0], "prime[0]", 1);
  444. SECU_PrintInteger(out, &key->u.rsa.prime[1], "prime[1]", 1);
  445. SECU_PrintInteger(out, &key->u.rsa.primeExponent[0],
  446.   "primeExponent[0]", 1);
  447. SECU_PrintInteger(out, &key->u.rsa.primeExponent[1],
  448.   "primeExponent[1]", 1);
  449. SECU_PrintInteger(out, &key->u.rsa.coefficient, "coefficient", 1);
  450. break;
  451.       case dsaKey:
  452. fprintf(out, "DSA Private-Key:n");
  453. SECU_PrintInteger(out, &key->u.dsa.params.prime, "prime", 1);
  454. SECU_PrintInteger(out, &key->u.dsa.params.subPrime, "subPrime", 1);
  455. SECU_PrintInteger(out, &key->u.dsa.params.base, "base", 1);
  456. SECU_PrintInteger(out, &key->u.dsa.publicValue, "publicValue", 1);
  457. SECU_PrintInteger(out, &key->u.dsa.privateValue, "privateValue", 1);
  458. break;
  459.       default:
  460. fprintf(out, "unknown key typen");
  461. break;
  462.     }
  463.     return SECSuccess;
  464. }
  466. static SECStatus
  467. ChangePassword(void)
  468. {
  469.     SECStatus rv;
  471.     /* Write out database with a new password */
  472.     rv = SECU_ChangeKeyDBPassword(handle);
  473.     if (rv) {
  474. SECU_PrintError(progName, "unable to change key password");
  475.     }
  476.     return rv;
  477. }
  479. static SECStatus DeletePrivateKey (char *nickName)
  480. {
  481.     int rv;
  483.     rv = SECU_DeleteKeyByName (keyHandle, nickName);
  484.     if (rv != SECSuccess)
  485. fprintf(stderr, "%s: problem deleting private key (%s)n",
  486. progName, SECU_Strerror(PR_GetError()));
  487.     return (rv);
  489. }
  491. #endif /* LATER */