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

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

CA认证

开发平台：

WINDOWS

newuser.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.  */
  33. #include <stdio.h>
  34. #include <fcntl.h>
  35. #include <sys/types.h>
  36. #ifdef XP_UNIX
  37. #include <unistd.h>
  38. #endif
  39. #include "cryptint.h"
  40. #include "blapi.h" /* program calls low level functions directly!*/
  41. #include "pk11func.h"
  42. #include "secmod.h"
  43. #include "secmodi.h"
  44. #include "cert.h"
  45. #include "cdbhdl.h"
  46. #include "key.h"
  47. #include "swforti.h"
  48. #include "secutil.h"
  49. #include "secrng.h"
  51. #ifndef O_BINARY
  52. #define O_BINARY 0
  53. #endif
  55. #define MAX_PERSONALITIES 50
  56. typedef struct {
  57.     int index;
  58.     CI_CERT_STR label;
  59.     CERTCertificate *cert;
  60. } certlist;
  62. typedef struct {
  63.    int card;
  64.    int index;
  65.    CI_CERT_STR label;
  66.    certlist valid[MAX_PERSONALITIES];
  67.    int count;
  68. } Cert;
  71. #define EMAIL_OID_LEN 9
  72. #define EMAIL_OID 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x09, 0x01
  73. unsigned char emailAVA[127] = {
  74. 0x31, 6+EMAIL_OID_LEN,  /* Set */
  75. 0x30, 4+EMAIL_OID_LEN, /* Sequence */
  76. 0x06, EMAIL_OID_LEN, EMAIL_OID,
  77. 0x13, 0, /* printable String */
  78. };
  79. #define EMAIL_DATA_START 8+EMAIL_OID_LEN
  81. int emailOffset[] = { 1, 3, EMAIL_DATA_START-1 };
  82. int offsetCount = sizeof(emailOffset)/sizeof(emailOffset[0]);
  84. unsigned char hash[20] = { 'H', 'a', 's', 'h', ' ', 'F', 'a', 'i', 'l', 'e',
  85.   'd', ' ', '*', '*', '*', '*', '*', '*', '*', '*' };
  86. unsigned char sig[40] = { 'H', 'a', 's', 'h', ' ', 'F', 'a', 'i', 'l', 'e',
  87.  'd', ' ', '*', '*', '*', '*', '*', '*', '*', '*',
  88.  '>', '>', '>', ' ', 'N', 'o', 't', ' ', 'S', 'i',
  89.  'g', 'n', 'd', ' ', '<', '<', '<', ' ', ' ', ' ' };
  92. /*void *malloc(int); */
  94. unsigned char *data_start(unsigned char *buf, int length, int *data_length) 
  95. {
  96.     unsigned char tag;
  97.     int used_length= 0;
  99.     tag = buf[used_length++];
  101.     /* blow out when we come to the end */
  102.     if (tag == 0) {
  103. return NULL;
  104.     }
  106.     *data_length = buf[used_length++];
  108.     if (*data_length&0x80) {
  109. int  len_count = *data_length & 0x7f;
  111. *data_length = 0;
  113. while (len_count-- > 0) {
  114.     *data_length = (*data_length << 8) | buf[used_length++];
  115. } 
  116.     }
  118.     if (*data_length > (length-used_length) ) {
  119. *data_length = length-used_length;
  120. return NULL;
  121.     }
  123.     return (buf + used_length);
  124. }
  126. unsigned char *
  127. GetAbove(unsigned char *cert,int cert_length,int *above_len)
  128. {
  129. unsigned char *buf = cert;
  130. int buf_length = cert_length;
  131. unsigned char *tmp;
  132. int len;
  134. *above_len = 0;
  136. /* optional serial number */
  137. if ((buf[0] & 0xa0) == 0xa0) {
  138.     tmp = data_start(buf,buf_length,&len);
  139.     if (tmp == NULL) return NULL;
  140.     buf_length -= (tmp-buf) + len;
  141.     buf = tmp + len;
  142. }
  143.         /* serial number */
  144. tmp = data_start(buf,buf_length,&len);
  145. if (tmp == NULL) return NULL;
  146. buf_length -= (tmp-buf) + len;
  147. buf = tmp + len;
  148. /* skip the OID */
  149. tmp = data_start(buf,buf_length,&len);
  150. if (tmp == NULL) return NULL;
  151. buf_length -= (tmp-buf) + len;
  152. buf = tmp + len;
  153. /* issuer */
  154. tmp = data_start(buf,buf_length,&len);
  155. if (tmp == NULL) return NULL;
  156. buf_length -= (tmp-buf) + len;
  157. buf = tmp + len;
  158. /* skip the date */
  159. tmp = data_start(buf,buf_length,&len);
  160. if (tmp == NULL) return NULL;
  161. buf_length -= (tmp-buf) + len;
  162. buf = tmp + len;
  164. *above_len = buf - cert;
  165. return cert;
  166. }
  168. unsigned char *
  169. GetSubject(unsigned char *cert,int cert_length,int *subj_len) {
  170. unsigned char *buf = cert;
  171. int buf_length = cert_length;
  172. unsigned char *tmp;
  173. int len;
  175. *subj_len = 0;
  177. /* optional serial number */
  178. if ((buf[0] & 0xa0) == 0xa0) {
  179.     tmp = data_start(buf,buf_length,&len);
  180.     if (tmp == NULL) return NULL;
  181.     buf_length -= (tmp-buf) + len;
  182.     buf = tmp + len;
  183. }
  184.         /* serial number */
  185. tmp = data_start(buf,buf_length,&len);
  186. if (tmp == NULL) return NULL;
  187. buf_length -= (tmp-buf) + len;
  188. buf = tmp + len;
  189. /* skip the OID */
  190. tmp = data_start(buf,buf_length,&len);
  191. if (tmp == NULL) return NULL;
  192. buf_length -= (tmp-buf) + len;
  193. buf = tmp + len;
  194. /* issuer */
  195. tmp = data_start(buf,buf_length,&len);
  196. if (tmp == NULL) return NULL;
  197. buf_length -= (tmp-buf) + len;
  198. buf = tmp + len;
  199. /* skip the date */
  200. tmp = data_start(buf,buf_length,&len);
  201. if (tmp == NULL) return NULL;
  202. buf_length -= (tmp-buf) + len;
  203. buf = tmp + len;
  205. return data_start(buf,buf_length,subj_len);
  206. }
  208. unsigned char *
  209. GetBelow(unsigned char *cert,int cert_length,int *below_len) {
  210. unsigned char *subj;
  211. int subj_len;
  212. unsigned char *below;
  214. *below_len = 0;
  216. subj = GetSubject(cert,cert_length,&subj_len);
  218. below = subj + subj_len;
  219. *below_len = cert_length - (below - cert);
  220. return below;
  221. }
  223. unsigned char *
  224. GetSignature(unsigned char *sig,int sig_length,int *subj_len) {
  225. unsigned char *buf = sig;
  226. int buf_length = sig_length;
  227. unsigned char *tmp;
  228. int len;
  230. *subj_len = 0;
  232.         /* signature oid */
  233. tmp = data_start(buf,buf_length,&len);
  234. if (tmp == NULL) return NULL;
  235. buf_length -= (tmp-buf) + len;
  236. buf = tmp + len;
  237. /* signature data */
  238. tmp = data_start(buf,buf_length,&len);
  239. if (tmp == NULL) return NULL;
  241. *subj_len = len -1;
  242. return tmp+1;
  243. }
  245. int DER_Sequence(unsigned char *buf, int length) {
  246.     int next = 0;
  248.     buf[next++] = 0x30;
  249.     if (length < 0x80) {
  250. buf[next++] = length;
  251.     } else {
  252. buf[next++] = 0x82;
  253. buf[next++] = (length >> 8) & 0xff;
  254. buf[next++] = length & 0xff;
  255.     }
  256.     return next;
  257. }
  259. static
  260. int Cert_length(unsigned char *buf, int length) {
  261.     unsigned char tag;
  262.     int used_length= 0;
  263.     int data_length;
  265.     tag = buf[used_length++];
  267.     /* blow out when we come to the end */
  268.     if (tag == 0) {
  269.         return 0;
  270.     }
  272.     data_length = buf[used_length++];
  274.     if (data_length&0x80) {
  275.         int  len_count = data_length & 0x7f;
  277.         data_length = 0;
  279.         while (len_count-- > 0) {
  280.             data_length = (data_length << 8) | buf[used_length++];
  281.         }
  282.     }
  284.     if (data_length > (length-used_length) ) {
  285.         return length;
  286.     }
  288.     return (data_length + used_length);
  289. }
  291. int
  292. InitCard(int card, char *inpass) {
  293.     int cirv;
  294.     char buf[50];
  295.     char *pass;
  297.     cirv = CI_Open( 0 /* flags */, card);
  298.     if (cirv != CI_OK) return cirv;
  300.     if (inpass == NULL) {
  301.         sprintf(buf,"Enter PIN for card in socket %d: ",card);
  302.         pass = SECU_GetPasswordString(NULL, buf);
  304.         if (pass == NULL) {
  305.     CI_Close(CI_POWER_DOWN_FLAG,card);
  306.     return CI_FAIL;
  307.         }
  308.     } else pass=inpass;
  310.     cirv = CI_CheckPIN(CI_USER_PIN,(unsigned char *)pass);
  311.     if (cirv != CI_OK)  {
  312. CI_Close(CI_POWER_DOWN_FLAG,card);
  313.     }
  314.     return cirv;
  315. }
  317. int
  318. isUser(CI_PERSON *person) {
  319.     return 1;
  320. }
  322. int
  323. isCA(CI_PERSON *person) {
  324.     return 0;
  325. }
  327. int FoundCert(int card, char *name, Cert *cert) {
  328.     CI_PERSON personalities[MAX_PERSONALITIES];
  329.     CI_PERSON *person;
  330.     int cirv;
  331.     int i;
  332.     int user_len = strlen(name);
  334.     PORT_Memset(personalities, 0, sizeof(CI_PERSON)*MAX_PERSONALITIES);
  336.     cirv = CI_GetPersonalityList(MAX_PERSONALITIES,personalities);
  337.     if (cirv != CI_OK) return 0;
  340.     cert->count = 1;
  341.     cert->valid[0].index = 0;
  342.     memcpy(cert->valid[0].label,"RRXX0000Root PAA Certificate        ",
  343. sizeof(cert->valid[0].label));
  344.     cert->valid[0].cert = NULL;
  345.     for (i=0; i < MAX_PERSONALITIES; i++) {
  346. person = &personalities[i];
  347. if ( (PORT_Memcmp(person->CertLabel,"RRXX",4) == 0) ||
  348.      (PORT_Memcmp(person->CertLabel,"RTXX",4) == 0) ||
  349.      (PORT_Memcmp(person->CertLabel,"LAXX",4) == 0) ||
  350.      (PORT_Memcmp(person->CertLabel,"INKS",4) == 0) ||
  351.      (PORT_Memcmp(person->CertLabel,"INKX",4) == 0) ||
  352.      (PORT_Memcmp(person->CertLabel,"ONKS",4) == 0) ||
  353.      (PORT_Memcmp(person->CertLabel,"ONKX",4) == 0) ||
  354.      (PORT_Memcmp(person->CertLabel,"KEAK",4) == 0) ||
  355.      (PORT_Memcmp(person->CertLabel,"3IKX",4) == 0) ||
  356.      (PORT_Memcmp(person->CertLabel,"DSA1",4) == 0) ||
  357.      (PORT_Memcmp(person->CertLabel,"DSAI",4) == 0) ||
  358.      (PORT_Memcmp(person->CertLabel,"DSAO",4) == 0) ||
  359.      (PORT_Memcmp(person->CertLabel,"3IXS",4) == 0) ||
  360.      (PORT_Memcmp(person->CertLabel,"3OXS",4) == 0) ){
  361.     int index;
  363.     cert->valid[cert->count].cert = NULL;
  364.     memcpy(cert->valid[cert->count].label,
  365. person->CertLabel,sizeof(person->CertLabel));
  366.     for (index = sizeof(person->CertLabel)-1;
  367. cert->valid[cert->count].label[index] == ' '; index--) {
  368. cert->valid[cert->count].label[index] = 0;
  369.     }
  370.     cert->valid[cert->count++].index = person->CertificateIndex;
  371. }
  372.     }
  373.     for (i=0; i < MAX_PERSONALITIES; i++) {
  374. person = &personalities[i];
  375. if (strncmp((char *)&person->CertLabel[8],name,user_len) == 0) {
  376.     cert->card = card;
  377.     cert->index = person->CertificateIndex;
  378.     memcpy(&cert->label,person->CertLabel,sizeof(person->CertLabel));
  379.     return 1;
  380. }
  381.     }
  382.     return 0;
  383. }
  385. void
  386. Terminate(char *mess, int cirv, int card1, int card2)
  387. {
  388.     fprintf(stderr,"FAIL: %s error %dn",mess,cirv);
  389.     if (card1 != -1) CI_Close(CI_POWER_DOWN_FLAG,card1);
  390.     if (card2 != -1) CI_Close(CI_POWER_DOWN_FLAG,card2);
  391.     CI_Terminate();
  392.     exit(1);
  393. }
  395. void
  396. usage(char *prog)
  397. {
  398.     fprintf(stderr,"usage: %s [-e email][-t transport][-u userpin][-U userpass][-s ssopin][-S ssopass][-o outfile] common_name ca_labeln",prog);
  399.     exit(1);
  400. }
  402. #define CERT_SIZE 2048
  405. /* version and oid */
  406. unsigned char header[] = {
  407.     /* Cert OID */
  408.     0x02, 0x10,
  409.      0x00, 0x00, 0x00, 0x00,
  410.      0x00, 0x00, 0x00, 0x00,
  411.      0x00, 0x00, 0x00, 0x00,
  412.      0x00, 0x00, 0x00, 0x00,
  413.     0x30, 0x0b, 0x06, 0x09,
  414.     0x60, 0x86, 0x48, 0x01, 0x65, 0x02, 0x01, 0x01, 0x13 };
  416. #define KEY_START 21
  417. #define KMID_OFFSET 4
  418. #define KEA_OFFSET 15
  419. #define DSA_OFFSET 148
  420. unsigned char key[] = {
  421.    /* Sequence(Constructed): 293 bytes (0x125) */
  422.    0x30, 0x82, 0x01, 0x25,
  423.    /*Sequence(Constructed): 11 bytes (0xb) */
  424.    0x30, 0x0b,
  425.    /* ObjectId(Universal): 9 bytes (0x9) */
  426.    0x06, 0x09,
  427.    0x60, 0x86, 0x48, 0x01, 0x65, 0x02, 0x01, 0x01, 0x14,
  428.    /* BitString(Universal): 276 bytes (0x114) */
  429.    0x03, 0x82, 0x01, 0x14,
  430.    0x00, 0x00, 0x01, 0xef, 0x04, 0x01, 0x00, 0x01,
  431.    0x00, 0x00, 0x69, 0x60, 0x70, 0x00, 0x80, 0x02,
  432.    0x2e, 0x46, 0xb9, 0xcb, 0x22, 0x72, 0x0b, 0x1c,
  433.    0xe6, 0x25, 0x20, 0x16, 0x86, 0x05, 0x8e, 0x2b,
  434.    0x98, 0xd1, 0x46, 0x3d, 0x00, 0xb8, 0x69, 0xe1,
  435.    0x1a, 0x42, 0x7d, 0x7d, 0xb5, 0xbf, 0x9f, 0x26,
  436.    0xd3, 0x2c, 0xb1, 0x73, 0x01, 0xb6, 0xb2, 0x6f,
  437.    0x7b, 0xa5, 0x54, 0x85, 0x60, 0x77, 0x81, 0x8a,
  438.    0x87, 0x86, 0xe0, 0x2d, 0xbf, 0xdb, 0x28, 0xe8,
  439.    0xfa, 0x20, 0x35, 0xb4, 0xc0, 0x94, 0x10, 0x8e,
  440.    0x1c, 0x58, 0xaa, 0x02, 0x60, 0x97, 0xf5, 0xb3,
  441.    0x2f, 0xf8, 0x99, 0x29, 0x28, 0x73, 0x47, 0x36,
  442.    0xdd, 0x1d, 0x78, 0x95, 0xeb, 0xb8, 0xec, 0x45,
  443.    0x96, 0x69, 0x6f, 0x54, 0xc8, 0x1f, 0x2d, 0x3a,
  444.    0xd9, 0x0e, 0x8e, 0xaa, 0x59, 0x11, 0x8c, 0x3b,
  445.    0x8d, 0xa4, 0xed, 0xf2, 0x7d, 0xdc, 0x42, 0xaa,
  446.    0xa4, 0xd2, 0x1c, 0xb9, 0x87, 0xd0, 0xd9, 0x3d,
  447.    0x8e, 0x89, 0xbb, 0x06, 0x54, 0xcf, 0x32, 0x00,
  448.    0x02, 0x00, 0x00, 0x80, 0x0b, 0x80, 0x6c, 0x0f,
  449.    0x71, 0xd1, 0xa1, 0xa9, 0x26, 0xb4, 0xf1, 0xcd,
  450.    0x6a, 0x7a, 0x09, 0xaa, 0x58, 0x28, 0xd7, 0x35,
  451.    0x74, 0x8e, 0x7c, 0x83, 0xcb, 0xfe, 0x00, 0x3b,
  452.    0x62, 0x00, 0xfb, 0x90, 0x37, 0xcd, 0x93, 0xcf,
  453.    0xf3, 0xe4, 0x6d, 0x8d, 0xdd, 0xb8, 0x53, 0xe0,
  454.    0x5c, 0xda, 0x1a, 0x7e, 0x56, 0x03, 0x95, 0x03,
  455.    0x2f, 0x74, 0x86, 0xb1, 0xa0, 0xbb, 0x05, 0x91,
  456.    0xe4, 0x76, 0x83, 0xe6, 0x62, 0xf9, 0x12, 0x64,
  457.    0x5a, 0x62, 0xd8, 0x94, 0x04, 0x1f, 0x83, 0x02,
  458.    0x2e, 0xc5, 0xa7, 0x17, 0x46, 0x46, 0x21, 0x96,
  459.    0xc3, 0xa9, 0x8e, 0x92, 0x18, 0xd1, 0x52, 0x08,
  460.    0x1d, 0xff, 0x8e, 0x24, 0xdb, 0x6c, 0xd8, 0xfe,
  461.    0x80, 0x93, 0xe1, 0xa5, 0x4a, 0x0a, 0x37, 0x24,
  462.    0x18, 0x07, 0xbe, 0x0f, 0xaf, 0x73, 0xea, 0x50,
  463.    0x64, 0xa1, 0xb3, 0x77, 0xe5, 0x41, 0x02, 0x82,
  464.    0x39, 0xb9, 0xe3, 0x94 
  465. };
  467. unsigned char valitity[] = {
  468.    0x30, 0x1e,
  469.    0x17, 0x0d,
  470.    '2','0','0','0','0','1','0','1','0','0','0','0','Z',
  471.    0x17, 0x0d,
  472.    '2','0','0','5','1','2','0','1','0','0','0','0','Z'
  473. };
  476. unsigned char cnam_oid[] = { 0x06, 0x03, 0x55, 0x04, 0x03 };
  478. unsigned char signature[] = {
  479.     /* the OID */
  480.     0x30, 0x0b, 0x06, 0x09,
  481.     0x60, 0x86, 0x48, 0x01, 0x65, 0x02, 0x01, 0x01, 0x13,
  482.     /* signature wrap */
  483.     0x03, 0x29, 0x00,
  484.     /* 40 byte dsa signature */
  485.     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
  486.     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
  487.     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
  488.     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
  489. };
  491. unsigned char fortezza_oid [] = {
  492.     0x60, 0x86, 0x48, 0x01, 0x65, 0x02, 0x01, 0x01, 0x13
  493. };
  495. unsigned char software_ou[] = {
  496.     0x31, 26, 0x30, 24,
  497.     0x06, 0x03, 0x55, 0x04, 0x0b,
  498.     0x13, 17, 
  499.       'S','o','f','t','w',
  500.       'a','r','e',' ','F',
  501.       'O','R','T','E','Z','Z','A'
  502. };
  505. char letterarray[] = {
  506. 'a','b','c','d','e','f','g','h','i','j','k','l','m','n',
  507. 'o','p','q','r','s','t','u','v','w','x','y','z' };
  509. char constarray[] = {
  510. 'b','c','d','f','g','h','j','k','l','m','n',
  511. 'p','q','r','s','t','v','w','x','y','z' };
  513. char vowelarray[] = {
  514. 'a','e','i','o','u','y' };
  516. char digitarray[] = {
  517. '0','1','2','3','4','5','6','7','8','9' };
  519. unsigned long
  520. getRandom(unsigned long max) {
  521. unsigned short data;
  522. unsigned long result;
  524. fort_GenerateRandom((unsigned char *)&data,sizeof(data));
  526. result = (unsigned long)data * max;
  527. result = result >> 16;
  528. return result;
  529. }
  532. char getLetter(void)
  533. {
  534.    return letterarray[getRandom(sizeof(letterarray))];
  535. }
  536. char getVowel(void)
  537. {
  538.    return vowelarray[getRandom(sizeof(vowelarray))];
  539. }
  540. char getDigit(void)
  541. {
  542.    return digitarray[getRandom(sizeof(digitarray))];
  543. }
  545. char getConst(void)
  546. {
  547.    return constarray[getRandom(sizeof(constarray))];
  548. }
  550. char *getPinPhrase(void)
  551. {
  552.     char * pass = PORT_ZAlloc(5);
  554.     pass[0] = getDigit();
  555.     pass[1] = getDigit();
  556.     pass[2] = getDigit();
  557.     pass[3] = getDigit();
  559.     return pass;
  560. }
  562. char *getPassPhrase(void)
  563. {
  564.     char * pass = PORT_ZAlloc(13);
  566.     pass[0] = getConst()+'A'-'a';
  567.     pass[1] = getVowel();
  568.     pass[2] = getConst();
  569.     pass[3] = getVowel();
  570.     pass[4] = getConst();
  571.     pass[5] = getVowel();
  572.     pass[6] = getConst();
  573.     pass[7] = getDigit();
  574.     pass[8] = getDigit();
  575.     pass[9] = getDigit();
  576.     pass[10] = getDigit();
  577.     pass[11] = getLetter()+'A'-'a';
  579.     return pass;
  580. }
  582. extern void
  583. makeCertSlot(fortSlotEntry *   entry,
  584. int            index,
  585. char *         label,
  586. SECItem *      cert,
  587.   FORTSkipjackKeyPtr Ks, 
  588. unsigned char *xKEA, 
  589. unsigned char *xDSA, 
  590.   unsigned char *pubKey, 
  591. int            pubKeyLen, 
  592. unsigned char *p, 
  593. unsigned char *q, 
  594. unsigned char *g);
  596. extern void
  597. makeProtectedPhrase(FORTSWFile *     file, 
  598. fortProtectedPhrase *prot_phrase,
  599.          FORTSkipjackKeyPtr   Ks, 
  600. FORTSkipjackKeyPtr   Kinit, 
  601. char *               phrase);
  603. extern void
  604. fill_in(SECItem *item, unsigned char *data, int len);
  606. char *userLabel = "INKS0002                            ";
  607. main(int argc, char **argv)
  608. {
  609. char *progname = *argv++;
  610. char *commonName = NULL;
  611. char *caname = NULL;
  612. char *email = NULL;
  613. char *outname = NULL;
  614. char *cp;
  615. int arg_count = 0;
  616. Cert caCert;
  617.         SECItem userCert;
  618. int cirv,i;
  619. int cards, start;
  620. unsigned char *subject;
  621. int            subject_len;
  622. int            signature_len = sizeof(signature);
  623. int            newSubject_len, newCertBody_len, len;
  624. int            cname1_len, cname_len, pstring_len;
  625. int            valitity_len = sizeof(valitity);
  626. unsigned char origCert[CERT_SIZE];
  627. unsigned char newSubject[CERT_SIZE];
  628. unsigned char newCertBody[CERT_SIZE];
  629. unsigned char newCert[CERT_SIZE];
  630. unsigned char pstring[CERT_SIZE];
  631. unsigned char cname1[CERT_SIZE];
  632. unsigned char cname[CERT_SIZE];
  633. CERTCertificate *myCACert = NULL;
  634. CERTCertificate *cert;
  635. CERTCertDBHandle certhandle;
  636. SECStatus rv;
  637. SECMODModule *module;
  638. unsigned char serial[16];
  639. SECKEYPublicKey *pubKey;
  640. DSAPrivateKey *keaPrivKey;
  641. DSAPrivateKey *dsaPrivKey;
  642. CI_RANDOM randomVal;
  643. PQGParams *params;
  644. int pca_index = -1;
  645. unsigned char *p,*q,*g;
  646. FORTSkipjackKey Ks;
  647. FORTSkipjackKey Kinit;
  648.         FORTSWFile *file;
  649.         FORTSignedSWFile *signed_file;
  650.         FORTSignedSWFile *signed_file2;
  651. unsigned char random[20];
  652. unsigned char vers;
  653. unsigned char *data;
  654. char *transportPin=NULL;
  655. char *ssoMemPhrase=NULL;
  656. char *userMemPhrase=NULL;
  657. char *ssoPin=NULL;
  658. char *userPin=NULL;
  659. char *pass=NULL;
  660. SECItem *outItem;
  661. int email_len = 0;
  662. int emailAVA_len = 0;
  664.    
  665.     /* put better argument parsing here */
  666.     while ((cp = *argv++) != NULL) {
  667. if (*cp == '-') {
  668.     while (*++cp) {
  669. switch (*cp) {
  670. /* verbose mode */
  671. case 'e':
  672.     email = *argv++;
  673.     break;
  674. /* explicitly set the target */
  675. case 'o':
  676.     outname = *argv++;
  677.     break;
  678. case 't':
  679. /* provide password on command line */
  680.     transportPin = *argv++;
  681.     break;
  682. case 'u':
  683. /* provide user password on command line */
  684.     userPin = *argv++;
  685.     break;
  686. case 'U':
  687. /* provide user password on command line */
  688.     userMemPhrase = *argv++;
  689.     break;
  690. case 's':
  691. /* provide user password on command line */
  692.     ssoPin = *argv++;
  693.     break;
  694. case 'S':
  695. /* provide user password on command line */
  696.     ssoMemPhrase = *argv++;
  697.     break;
  698. case 'p':
  699. /* provide card password on command line */
  700.     pass = *argv++;
  701.     break;
  702. case 'd':
  703.     transportPin="test1234567890";
  704.     ssoMemPhrase="sso1234567890";
  705.     userMemPhrase="user1234567890";
  706.     ssoPin="9999";
  707.     userPin="0000";
  708.     break;
  709. default:
  710.     usage(progname);
  711.     break;
  712. }
  713.     }
  714. } else switch (arg_count++) {
  715.     case 0:
  716. commonName = cp;
  717. break;
  718.     case 1:
  719. caname = cp;
  720. break;
  721.     default:
  722. usage(progname);
  723. } 
  724.     }
  726.     if (outname == NULL) outname = "swfort.sfi";
  727.     if (caname == NULL) usage(progname);
  731. caCert.card = -1;
  732. memset(newCert,0,CERT_SIZE);
  734. if (commonName == NULL) usage(progname);
  737. cirv = CI_Initialize(&cards);
  739.         start = 0;
  740. for (i=0; i < cards; i++) {
  741.     cirv = InitCard(i+1,pass);
  742.     if (cirv == CI_OK) {
  743.       if (FoundCert(i+1,caname,&caCert)) {
  744. break;
  745.       }
  746.     }
  747. }
  748.    
  749. if (caCert.card == -1) {
  750.    fprintf(stderr,
  751. "WARNING: Couldn't find Signing CA...new cert will not be signedn");
  752. }
  755. /*
  756.  * initialize enough security to deal with certificates.
  757.  */
  758. rv = CERT_OpenVolatileCertDB(&certhandle);
  759. if (rv != SECSuccess) {
  760.     Terminate("Couldn't build temparary Cert Database", 
  761. 1, -1, caCert.card);
  762.     exit(1);
  763. }
  764. CERT_SetDefaultCertDB(&certhandle);
  766. RNG_RNGInit();
  767. CI_GenerateRandom(random);
  768. RNG_RandomUpdate(random,sizeof(random));
  769. CI_GenerateRandom(random);
  770. RNG_RandomUpdate(random,sizeof(random));
  771. PK11_InitSlotLists();
  773. module = SECMOD_NewInternal();
  774. if (module == NULL) {
  775.     Terminate("Couldn't initialize security", 1, -1, caCert.card);
  776.     exit(1);
  777. }
  778. rv = SECMOD_LoadModule(module);
  779. if (rv != SECSuccess) {
  780.     Terminate("Couldn't initialize security", 2, -1, caCert.card);
  781.     exit(1);
  782. }
  784.     if (transportPin == NULL) transportPin = getPassPhrase();
  785.     if (ssoMemPhrase == NULL) ssoMemPhrase = getPassPhrase();
  786.     if (userMemPhrase == NULL) userMemPhrase = getPassPhrase();
  787.     if (ssoPin == NULL) ssoPin = getPinPhrase();
  788.     if (userPin == NULL) userPin = getPinPhrase();
  792. /* now dump the certs into the temparary data base */
  793. for (i=0; i < caCert.count; i++) {
  794.     int trusted = 0;
  795.          SECItem derCert;
  797.     cirv = CI_Select(caCert.card);
  798.     if (cirv != CI_OK) {
  799. Terminate("Couldn't select on CA card",cirv, 
  800. -1, caCert.card);
  801.     }
  802.     cirv = CI_GetCertificate(caCert.valid[i].index,origCert);
  803.             if (cirv != CI_OK) {
  804. continue;
  805.     }
  806.     derCert.data = origCert;
  807.     derCert.len = Cert_length(origCert, sizeof(origCert));
  808.     cert = CERT_NewTempCertificate(&certhandle,&derCert, NULL, 
  809. PR_FALSE, PR_TRUE);
  810.     caCert.valid[i].cert = cert;
  811.     if (cert == NULL) continue;
  812.             if (caCert.valid[i].index == caCert.index) myCACert=cert;
  813.     if (caCert.valid[i].index == atoi((char *)&caCert.label[4]))
  814.  pca_index = i;
  815. }
  817. if (myCACert == NULL) {
  818.    Terminate("Couldn't find CA's Certificate", 1, -1, caCert.card);
  819.    exit(1);
  820. }
  823.         /*
  824.  * OK now build the user cert.
  825.  */
  826. /* first get the serial number and KMID */
  827.         cirv = CI_GenerateRandom(randomVal);
  828. memcpy(&header[2],randomVal,sizeof(serial));
  829. memcpy(serial,randomVal,sizeof(serial));
  830. memcpy(&key[KEY_START+KMID_OFFSET],randomVal+sizeof(serial),7);
  831.  /* KMID */
  833. /* now generate the keys */
  834. pubKey = CERT_ExtractPublicKey(myCACert);
  835. if (pubKey == NULL) {
  836.    Terminate("Couldn't extract CA's public key", 
  837. 1, -1, caCert.card);
  838.    exit(1);
  839. }
  842. switch (pubKey->keyType) {
  843. case fortezzaKey:
  844.     params = &pubKey->u.fortezza.params;
  845.     break;
  846. case dsaKey:
  847.     params = &pubKey->u.dsa.params;
  848.     break;
  849. default:
  850.    Terminate("Certificate is not a fortezza or DSA Cert",
  851. 1, -1, caCert.card);
  852.    exit(1);
  853. }
  855. rv = DSA_NewKey(params,&keaPrivKey);
  856. if (rv != SECSuccess) {
  857.    Terminate("Couldn't Generate KEA key", 
  858. PORT_GetError(), -1, caCert.card);
  859.    exit(1);
  860. }
  861. rv = DSA_NewKey(params,&dsaPrivKey);
  862. if (rv != SECSuccess) {
  863.    Terminate("Couldn't Generate DSA key", 
  864. PORT_GetError(), -1, caCert.card);
  865.    exit(1);
  866. }
  868. if (keaPrivKey->publicValue.len == 129) 
  869. keaPrivKey->publicValue.data++;
  870. if (dsaPrivKey->publicValue.len == 129) 
  871. dsaPrivKey->publicValue.data++;
  872. if (keaPrivKey->privateValue.len == 21) 
  873. keaPrivKey->privateValue.data++;
  874. if (dsaPrivKey->privateValue.len == 21) 
  875. dsaPrivKey->privateValue.data++;
  877. /* save the parameters */
  878. p = params->prime.data;
  879. if (params->prime.len == 129) p++;
  880. q = params->subPrime.data;
  881. if (params->subPrime.len == 21) q++;
  882. g = params->base.data;
  883. if (params->base.len == 129) g++;
  885. memcpy(&key[KEY_START+KEA_OFFSET],
  886. keaPrivKey->publicValue.data,
  887. keaPrivKey->publicValue.len);
  888. memcpy(&key[KEY_START+DSA_OFFSET],
  889. dsaPrivKey->publicValue.data,
  890. dsaPrivKey->publicValue.len);
  892. /* build the der subject */
  893. subject = data_start(myCACert->derSubject.data,myCACert->derSubject.len,
  894. &subject_len);
  896. /* build the new Common name AVA */
  897. len = DER_Sequence(pstring,strlen(commonName));
  898. memcpy(pstring+len,commonName,strlen(commonName));
  899.  len += strlen(commonName);
  900. pstring_len = len;
  901. pstring[0] = 0x13;
  903. len = DER_Sequence(cname1,sizeof(cnam_oid)+pstring_len);
  904. memcpy(cname1+len,cnam_oid,sizeof(cnam_oid)); len += sizeof(cnam_oid);
  905. memcpy(cname1+len,pstring,pstring_len); len += pstring_len;
  906. cname1_len = len;
  908. len = DER_Sequence(cname, cname1_len);
  909. memcpy(cname+len,cname1,cname1_len); len += cname1_len;
  910. cname_len = len;
  911. cname[0] = 0x31; /* make it a set rather than a sequence */
  913. if (email) {
  914.     email_len = strlen(email);
  915.     emailAVA_len = EMAIL_DATA_START + email_len;
  916. }
  918. /* now assemble it */
  919. len = DER_Sequence(newSubject,subject_len + sizeof(software_ou) +
  920. cname_len + emailAVA_len);
  921. memcpy(newSubject+len,subject,subject_len);
  923. for (i=0; i < subject_len; i++) {
  924.    if (memcmp(newSubject+len+i,cnam_oid,sizeof(cnam_oid)) == 0) {
  925. newSubject[i+len+4] = 0x0b; /* change CN to OU */
  926. break;
  927.    }
  928. }
  929. len += subject_len;
  930. memcpy(newSubject+len,software_ou,sizeof(software_ou)); 
  931. len += sizeof(software_ou);
  932. memcpy(newSubject+len,cname,cname_len); len += cname_len;
  933. newSubject_len = len;
  935. /*
  936.  * build the email AVA
  937.  */
  938. if (email) {
  939.     memcpy(&emailAVA[EMAIL_DATA_START],email,email_len);
  940.     for (i=0; i < offsetCount; i++) {
  941. emailAVA[emailOffset[i]] += email_len;
  942.     }
  943.     memcpy(newSubject+len,emailAVA,emailAVA_len);
  944.     newSubject_len += emailAVA_len;
  945. }
  948. /*
  949.  * Assemble the Cert
  950.  */
  952. len = DER_Sequence(newCertBody,sizeof(header)+newSubject_len+
  953.    valitity_len+myCACert->derSubject.len+sizeof(key));
  954. memcpy(newCertBody+len,header,sizeof(header));len += sizeof(header);
  955. memcpy(newCertBody+len,myCACert->derSubject.data,
  956. myCACert->derSubject.len);len += myCACert->derSubject.len;
  957. memcpy(newCertBody+len,valitity,valitity_len);len += valitity_len;
  958. memcpy(newCertBody+len,newSubject,newSubject_len);
  959. len += newSubject_len;
  960. memcpy(newCertBody+len,key,sizeof(key));len += sizeof(key);
  961. newCertBody_len = len;
  964. /*
  965.  * generate the hash
  966.  */
  967. cirv = CI_InitializeHash();
  968. if (cirv == CI_OK) {
  969.     int hash_left = newCertBody_len & 63;
  970.     int hash_len = newCertBody_len - hash_left;
  971.     cirv = CI_Hash(hash_len,newCertBody);
  972.     if (cirv == CI_OK) {
  973. cirv = CI_GetHash(hash_left,newCertBody+hash_len,hash);
  974.     }
  975. }
  977. /*
  978.  * now sign the hash
  979.  */
  980. if ((cirv == CI_OK) && (caCert.card != -1)) {
  981.     cirv = CI_Select(caCert.card);
  982.     if (cirv == CI_OK) {
  983. cirv = CI_SetPersonality(caCert.index);
  984. if (cirv == CI_OK) {
  985.     cirv = CI_Sign(hash,sig);
  986. }
  987.     }
  988. } else cirv = -1;
  990. if (cirv != CI_OK) {
  991.    memcpy(sig,hash,sizeof(hash));
  992. }
  994. /*
  995.  * load in new signature
  996.  */
  997. {
  998.     int sig_len;
  999.     unsigned char *sig_start = 
  1000. GetSignature(signature,signature_len,&sig_len);
  1001.     memcpy(sig_start,sig,sizeof(sig));
  1002. }
  1004. /*
  1005.  * now do the final wrap
  1006.  */
  1007. len = DER_Sequence(newCert,newCertBody_len+signature_len);
  1008. memcpy(newCert+len,newCertBody,newCertBody_len); len += newCertBody_len;
  1009. memcpy(newCert+len, signature, signature_len); len +=signature_len;
  1010. userCert.data = newCert;
  1011. userCert.len = len;
  1014. /* OK, we now have our cert, let's go build our software file */
  1015. signed_file = PORT_ZNew(FORTSignedSWFile);
  1016. file = &signed_file->file;
  1018. signed_file->signatureWrap.signature.data  = PORT_ZAlloc(40);
  1019. signed_file->signatureWrap.signature.len  = 40;
  1020. signed_file->signatureWrap.signatureAlgorithm.algorithm.data  =
  1021.                                        fortezza_oid;
  1022. signed_file->signatureWrap.signatureAlgorithm.algorithm.len = 
  1023. sizeof(fortezza_oid);
  1025.         vers = 1;
  1026. fill_in(&file->version,&vers,1);
  1027. file->derIssuer.data = myCACert->derSubject.data;
  1028. file->derIssuer.len = myCACert->derSubject.len;
  1029. file->serialID.data = serial;
  1030. file->serialID.len =sizeof(serial);
  1031. /* generate out Ks value */
  1032. fort_GenerateRandom(Ks,sizeof(Ks));
  1033. makeProtectedPhrase(file,&file->initMemPhrase,Kinit,NULL,transportPin);
  1034. makeProtectedPhrase(file,&file->ssoMemPhrase,Ks,Kinit,ssoMemPhrase);
  1035. makeProtectedPhrase(file,&file->ssoPinPhrase,Ks,Kinit,ssoPin);
  1036. makeProtectedPhrase(file,&file->userMemPhrase,Ks,Kinit,userMemPhrase);
  1037. makeProtectedPhrase(file,&file->userPinPhrase,Ks,Kinit,userPin);
  1038. file->wrappedRandomSeed.data = PORT_ZAlloc(12);
  1039. file->wrappedRandomSeed.len = 12;
  1040.         cirv = fort_GenerateRandom(file->wrappedRandomSeed.data,10);
  1041. if (cirv != CI_OK) {
  1042.    Terminate("Couldn't get Random Seed", 
  1043. cirv, -1, caCert.card);
  1044. }
  1045. fort_skipjackWrap(Ks,12,file->wrappedRandomSeed.data,
  1046.                                 file->wrappedRandomSeed.data);
  1047. file->slotEntries = PORT_ZAlloc(sizeof(fortSlotEntry *)*5);
  1048. /* paa */
  1049. file->slotEntries[0] = PORT_ZNew(fortSlotEntry);
  1050. makeCertSlot(file->slotEntries[0],0,caCert.valid[0].label,
  1051. &caCert.valid[0].cert->derCert,
  1052. Ks,NULL,NULL,NULL,0,p,q,g);
  1053. /* pca */
  1054. file->slotEntries[1] = PORT_ZNew(fortSlotEntry);
  1055. makeCertSlot(file->slotEntries[1],1,caCert.valid[pca_index].label,
  1056. &caCert.valid[pca_index].cert->derCert,
  1057. Ks,NULL,NULL,NULL,0,p,q,g);
  1058. /* ca */
  1059. file->slotEntries[2] = PORT_ZNew(fortSlotEntry);
  1060. /* make sure the caCert lable points to our new pca slot location */
  1061. caCert.label[4] = '0';
  1062. caCert.label[5] = '0';
  1063. caCert.label[6] = '0';
  1064. caCert.label[7] = '1';
  1065. makeCertSlot(file->slotEntries[2],2,caCert.label,&myCACert->derCert,
  1066. Ks,NULL,NULL,NULL,0,p,q,g);
  1067. /* user */
  1068. file->slotEntries[3] = PORT_ZNew(fortSlotEntry);
  1069. strncpy(&userLabel[8],commonName,sizeof(CI_PERSON)-8);
  1070. makeCertSlot(file->slotEntries[3],3,userLabel,&userCert,Ks,
  1071. keaPrivKey->privateValue.data,
  1072. dsaPrivKey->privateValue.data,
  1073. key, sizeof(key), p, q, g);
  1074. file->slotEntries[4] = 0;
  1076. /* encode the file so we can sign it */
  1077. outItem = FORT_PutSWFile(signed_file);
  1079. /* get the der encoded data to sign */
  1080. signed_file2 = FORT_GetSWFile(outItem);
  1082. /* now sign it */
  1083. len = signed_file2->signatureWrap.data.len;
  1084. data = signed_file2->signatureWrap.data.data;
  1085. /*
  1086.  * generate the hash
  1087.  */
  1088. cirv = CI_InitializeHash();
  1089. if (cirv == CI_OK) {
  1090.     int hash_left = len & 63;
  1091.     int hash_len = len - hash_left;
  1092.     cirv = CI_Hash(hash_len,data);
  1093.     if (cirv == CI_OK) {
  1094. cirv = CI_GetHash(hash_left,data+hash_len,hash);
  1095.     }
  1096. }
  1098. /*
  1099.  * now sign the hash
  1100.  */
  1101. if ((cirv == CI_OK) && (caCert.card != -1)) {
  1102.     cirv = CI_Select(caCert.card);
  1103.     if (cirv == CI_OK) {
  1104. cirv = CI_SetPersonality(caCert.index);
  1105. if (cirv == CI_OK) {
  1106.     cirv = CI_Sign(hash,sig);
  1107. }
  1108.     }
  1109. } else cirv = -1;
  1111. if (cirv != CI_OK) {
  1112.    memcpy(sig,hash,sizeof(hash));
  1113. }
  1114. memcpy( signed_file->signatureWrap.signature.data,sig,sizeof(sig));
  1115. signed_file->signatureWrap.signature.len = sizeof(sig)*8; 
  1118. /* encode it for the last time */
  1119. outItem = FORT_PutSWFile(signed_file);
  1122. /*
  1123.  * write it out to the .sfi file
  1124.  */
  1125. {
  1126.     int fd = open(outname,O_WRONLY|O_CREAT|O_BINARY,0777);
  1128.     write(fd,outItem->data,outItem->len);
  1129.     close(fd);
  1130. }
  1131. CI_Close(CI_POWER_DOWN_FLAG,caCert.card);
  1132. CI_Terminate();
  1134. printf("Wrote %s to file %s.n",commonName,outname);
  1135. printf("Initialization Memphrase: %sn",transportPin);
  1136. printf("SSO Memphrase: %sn",ssoMemPhrase);
  1137. printf("User Memphrase: %sn",userMemPhrase);
  1138. printf("SSO pin: %sn",ssoPin);
  1139. printf("User pin: %sn",userPin);
  1141. return 0;
  1142. }