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

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

CA认证

开发平台：

WINDOWS

certcgi.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. /* Cert-O-Matic CGI */
  37. #include "nspr.h"
  38. #include "prtypes.h"
  39. #include "prtime.h"
  40. #include "prlong.h"
  42. #include "pk11func.h"
  43. #include "cert.h"
  44. #include "cdbhdl.h"
  45. #include "cryptohi.h"
  46. #include "secoid.h"
  47. #include "secder.h"
  48. #include "genname.h"
  49. #include "xconst.h"
  50. #include "secutil.h"
  51. #include "pqgutil.h"
  52. #include "certxutl.h"
  53. #include "secrng.h" /* for RNG_ */
  56. /* #define TEST           1 */
  57. /* #define FILEOUT        1 */
  58. /* #define OFFLINE        1 */
  59. #define START_FIELDS   100
  60. #define PREFIX_LEN     6
  61. #define SERIAL_FILE    "../serial"
  62. #define DB_DIRECTORY   ".."
  65. typedef struct PairStr Pair;
  67. struct PairStr {
  68.     char *name;
  69.     char *data;
  70. };
  73. char prefix[PREFIX_LEN];
  76. const SEC_ASN1Template CERTIA5TypeTemplate[] = {
  77.     { SEC_ASN1_IA5_STRING }
  78. };
  82. SECKEYPrivateKey *privkeys[9] = {NULL, NULL, NULL, NULL, NULL, NULL, NULL,
  83.  NULL, NULL};
  86. #ifdef notdef
  87. const SEC_ASN1Template CERT_GeneralNameTemplate[] = {
  88.     { SEC_ASN1_SEQUENCE_OF, 0, SEC_AnyTemplate }
  89. };
  90. #endif
  93. static void
  94. error_out(char  *error_string)
  95. {
  96.     printf("Content-type: text/plainnn");
  97.     printf(error_string);
  98.     fflush(stderr);
  99.     fflush(stdout);
  100.     exit(1);
  101. }
  103. static void
  104. error_allocate(void)
  105. {
  106.     error_out("ERROR: Unable to allocate memory");
  107. }
  110. static char *
  111. make_copy_string(char  *read_pos, 
  112.  int   length, 
  113.  char  sentinal_value)
  114.     /* copys string from to a new string it creates and 
  115.        returns a pointer to the new string */
  116. {
  117.     int                remaining = length;
  118.     char               *write_pos;
  119.     char               *new;
  121.     new = write_pos = (char *) PORT_Alloc (length);
  122.     if (new == NULL) {
  123. error_allocate();
  124.     }
  125.     while (*read_pos != sentinal_value) {
  126. if (remaining == 1) {
  127.     remaining += length;
  128.     length = length * 2;
  129.     new = PORT_Realloc(new,length);
  130.     if (new == NULL) {
  131. error_allocate();
  132.     }
  133.     write_pos = new + length - remaining;
  134. }
  135. *write_pos = *read_pos;
  136. ++write_pos;
  137. ++read_pos;
  138. remaining = remaining - 1;
  139.     }
  140.     *write_pos = '';
  141.     return new;
  142. }
  145. static char *
  146. PasswordStub(PK11SlotInfo  *slot, 
  147.      void          *cx)
  148. {
  149. return NULL;
  150. }
  153. static SECStatus
  154. clean_input(Pair *data)
  155.     /* converts the non-alphanumeric characters in a form post 
  156.        from hex codes back to characters */
  157. {
  158.     int           length;
  159.     int           hi_digit;
  160.     int           low_digit;
  161.     char          character;
  162.     char          *begin_pos;
  163.     char          *read_pos;
  164.     char          *write_pos;
  165.     PRBool        name = PR_TRUE;
  167.     begin_pos = data->name;
  168.     while (begin_pos != NULL) {
  169. length = strlen(begin_pos);
  170. read_pos = write_pos = begin_pos;
  171. while ((read_pos - begin_pos) < length) {
  172.     if (*read_pos == '+') {
  173. *read_pos = ' ';
  174.     }
  175.     if (*read_pos == '%') {
  176. hi_digit = *(read_pos + 1);
  177. low_digit = *(read_pos +2);
  178. read_pos += 3;
  179. if (isdigit(hi_digit)){
  180.     hi_digit = hi_digit - '0';
  181. } else {
  182.     hi_digit = toupper(hi_digit);
  183.     if (isxdigit(hi_digit)) {
  184. hi_digit = (hi_digit - 'A') + 10;
  185.     } else {
  186. error_out("ERROR: Form data incorrectly formated");
  187.     }
  188. }
  189. if (isdigit(low_digit)){
  190.     low_digit = low_digit - '0';
  191. } else {
  192.     low_digit = toupper(low_digit);
  193.     if ((low_digit >='A') && (low_digit <= 'F')) {
  194. low_digit = (low_digit - 'A') + 10;
  195.     } else {
  196. error_out("ERROR: Form data incorrectly formated");
  197.     }
  198. }
  199. character = (hi_digit << 4) | low_digit;
  200. if (character != 10) {
  201.     *write_pos = character;
  202.     ++write_pos;
  203. }
  204.     } else {
  205. *write_pos = *read_pos;
  206. ++write_pos;
  207. ++read_pos;
  208.     }
  209. }
  210. *write_pos = '';
  211. if (name == PR_TRUE) {
  212.     begin_pos = data->data;
  213.     name = PR_FALSE;
  214. } else {
  215.     data++;
  216.     begin_pos = data->name;
  217.     name = PR_TRUE;
  218. }
  219.     }
  220.     return SECSuccess;
  221. }
  223. static char *
  224. make_name(char  *new_data)
  225.     /* gets the next field name in the input string and returns
  226.        a pointer to a string containing a copy of it */
  227. {
  228.     int         length = 20;
  229.     char        *name;
  231.     name = make_copy_string(new_data, length, '=');
  232.     return name;
  233. }
  235. static char *
  236. make_data(char  *new_data)
  237.     /* gets the data for the next field in the input string 
  238.        and returns a pointer to a string containing it */
  239. {
  240.     int         length = 100;
  241.     char        *data;
  242.     char        *read_pos;
  244.     read_pos = new_data;
  245.     while (*(read_pos - 1) != '=') {
  246. ++read_pos;
  247.     }
  248.     data = make_copy_string(read_pos, length, '&');
  249.     return data;
  250. }
  253. static Pair
  254. make_pair(char  *new_data)
  255.     /* makes a pair name/data pair from the input string */
  256. {
  257.     Pair        temp;
  259.     temp.name = make_name(new_data);
  260.     temp.data = make_data(new_data);
  261.     return temp;
  262. }
  266. static Pair *
  267. make_datastruct(char  *data, int len)
  268.     /* parses the input from the form post into a data 
  269.        structure of field name/data pairs */
  270. {
  271.     Pair              *datastruct;
  272.     Pair              *current;
  273.     char              *curr_pos;
  274.     int               fields = START_FIELDS;
  275.     int               remaining = START_FIELDS;
  277.     curr_pos = data;
  278.     datastruct = current = (Pair *) PORT_Alloc(fields * sizeof(Pair));
  279.     if (datastruct == NULL) {
  280. error_allocate();
  281.     }
  282.     while (curr_pos - data < len) {
  283. if (remaining == 1) {
  284.     remaining += fields;
  285.     fields = fields * 2;
  286.     datastruct = (Pair *) PORT_Realloc
  287. (datastruct, fields * sizeof(Pair));
  288.     if (datastruct == NULL) {
  289. error_allocate;
  290.     }
  291.     current = datastruct + (fields - remaining);
  292. }
  293. *current = make_pair(curr_pos);
  294. while (*curr_pos != '&') {
  295.     ++curr_pos;
  296. }
  297. ++curr_pos;
  298. ++current;
  299. remaining = remaining - 1;
  300.     }
  301.     current->name = NULL;
  302.     return datastruct;
  303. }
  305. static char *
  306. return_name(Pair  *data_struct,
  307.     int   n)
  308.     /* returns a pointer to the name of the nth 
  309.        (starting from 0) item in the data structure */
  310. {
  311.     char          *name;
  313.     if ((data_struct + n)->name != NULL) {
  314. name = (data_struct + n)->name;
  315. return name;
  316.     } else {
  317. return NULL;
  318.     }
  319. }
  321. static char *
  322. return_data(Pair  *data_struct,int n)
  323.     /* returns a pointer to the data of the nth (starting from 0) 
  324.        itme in the data structure */
  325. {
  326.     char          *data;
  328.     data = (data_struct + n)->data;
  329.     return data;
  330. }
  333. static char *
  334. add_prefix(char  *field_name)
  335. {
  336.     extern char  prefix[PREFIX_LEN];
  337.     int          i = 0;
  338.     char         *rv;
  339.     char         *write;
  341.     rv = write = PORT_Alloc(PORT_Strlen(prefix) + PORT_Strlen(field_name) + 1);
  342.     for(i = 0; i < PORT_Strlen(prefix); i++) {
  343. *write = prefix[i];
  344. write++;
  345.     }
  346.     *write = '';
  347.     rv = PORT_Strcat(rv,field_name);
  348.     return rv;
  349. }
  352. static char *
  353. find_field(Pair    *data, 
  354.    char    *field_name, 
  355.    PRBool  add_pre)
  356.     /* returns a pointer to the data of the first pair 
  357.        thats name matches the string it is passed */
  358. {
  359.     int            i = 0;
  360.     char           *retrieved;
  361.     int            found = 0;
  363.     if (add_pre) {
  364. field_name = add_prefix(field_name);
  365.     }
  366.     while(return_name(data, i) != NULL) {
  367. if (PORT_Strcmp(return_name(data, i), field_name) == 0) {
  368.     retrieved = return_data(data, i);
  369.     found = 1;
  370.     break;
  371. }
  372. i++;
  373.     }
  374.     if (!found) {
  375. retrieved = NULL;
  376.     }
  377.     return retrieved;
  378. }
  380. static PRBool
  381. find_field_bool(Pair    *data, 
  382. char    *fieldname, 
  383. PRBool  add_pre)
  384. {
  385.     char                *rv;
  387.     rv = find_field(data, fieldname, add_pre);
  389.     if  ((rv != NULL) && (PORT_Strcmp(rv, "true")) == 0) {
  390. return PR_TRUE;
  391.     } else {
  392. return PR_FALSE;
  393.     }
  394. }
  396. static char *
  397. update_data_by_name(Pair  *data, 
  398.     char  *field_name,
  399.                     char  *new_data)
  400.     /* replaces the data in the data structure associated with 
  401.        a name with new data, returns null if not found */
  402. {
  403.     int                   i = 0;
  404.     int                   found = 0;
  405.     int                   length = 100;
  406.     char                  *new;
  408.     while (return_name(data, i) != NULL) {
  409. if (PORT_Strcmp(return_name(data, i), field_name) == 0) {
  410.     new = make_copy_string( new_data, length, '');
  411.     PORT_Free(return_data(data, i));
  412.     found = 1;
  413.     (*(data + i)).data = new;
  414.     break;
  415. }
  416. i++;
  417.     }
  418.     if (!found) {
  419. new = NULL;
  420.     }
  421.     return new;
  422. }
  424. static char *
  425. update_data_by_index(Pair  *data, 
  426.      int   n, 
  427.      char  *new_data)
  428.     /* replaces the data of a particular index in the data structure */
  429. {
  430.     int                    length = 100;
  431.     char                   *new;
  433.     new = make_copy_string(new_data, length, '');
  434.     PORT_Free(return_data(data, n));
  435.     (*(data + n)).data = new;
  436.     return new;
  437. }
  440. static Pair *
  441. add_field(Pair   *data, 
  442.   char*  field_name, 
  443.   char*  field_data)
  444.     /* adds a new name/data pair to the data structure */
  445. {
  446.     int          i = 0;
  447.     int          j;
  448.     int          name_length = 100;
  449.     int          data_length = 100;
  451.     while(return_name(data, i) != NULL) {
  452. i++;
  453.     }
  454.     j = START_FIELDS;
  455.     while ( j < (i + 1) ) {
  456. j = j * 2;
  457.     }
  458.     if (j == (i + 1)) {
  459. data = (Pair *) PORT_Realloc(data, (j * 2) * sizeof(Pair));
  460. if (data == NULL) {
  461.     error_allocate();
  462. }
  463.     }
  464.     (*(data + i)).name = make_copy_string(field_name, name_length, '');
  465.     (*(data + i)).data = make_copy_string(field_data, data_length, '');
  466.     (data + i + 1)->name = NULL;
  467.     return data;
  468. }
  471. static CERTCertificateRequest *
  472. makeCertReq(Pair             *form_data,
  473.     int              which_priv_key)
  474.     /* makes and encodes a certrequest */
  475. {
  477.     PK11SlotInfo             *slot;
  478.     CERTCertificateRequest   *certReq = NULL;
  479.     CERTSubjectPublicKeyInfo *spki;
  480.     SECKEYPrivateKey         *privkey = NULL;
  481.     SECKEYPublicKey          *pubkey = NULL;
  482.     CERTName                 *name;
  483.     char                     *key;
  484.     extern SECKEYPrivateKey  *privkeys[9];
  485.     int                      keySizeInBits;
  486.     char                     *challenge = "foo";
  487.     SECStatus                rv = SECSuccess;
  488.     PQGParams                *pqgParams = NULL;
  489.     PQGVerify                *pqgVfy = NULL;
  491.     name = CERT_AsciiToName(find_field(form_data, "subject", PR_TRUE));
  492.     if (name == NULL) {
  493. error_out("ERROR: Unable to create Subject Name");
  494.     }
  495.     key = find_field(form_data, "key", PR_TRUE);
  496.     if (key == NULL) {
  497. switch (*find_field(form_data, "keysize", PR_TRUE)) {
  498.   case '0':
  499.     keySizeInBits = 2048;
  500.     break;
  501.   case '1':
  502.     keySizeInBits = 1024;
  503.     break;
  504.   case '2':
  505.     keySizeInBits = 512;
  506.     break;
  507.   default:
  508.     error_out("ERROR: Unsupported Key length selected");
  509. }
  510. if (find_field_bool(form_data, "keyType-dsa", PR_TRUE)) {
  511.     rv = PQG_ParamGen(keySizeInBits, &pqgParams, &pqgVfy);
  512.     if (rv != SECSuccess) {
  513. error_out("ERROR: Unable to generate PQG parameters");
  514.     }
  515.     slot = PK11_GetBestSlot(CKM_DSA_KEY_PAIR_GEN, NULL);
  516.     privkey = PK11_GenerateKeyPair(slot, CKM_DSA_KEY_PAIR_GEN, 
  517.    pqgParams,&pubkey, PR_FALSE, 
  518.    PR_TRUE, NULL);
  519. } else {
  520.     privkey = SECKEY_CreateRSAPrivateKey(keySizeInBits, &pubkey, NULL);
  521. }
  522. privkeys[which_priv_key] = privkey;
  523. spki = SECKEY_CreateSubjectPublicKeyInfo(pubkey);
  524.     } else {
  525. spki = SECKEY_ConvertAndDecodePublicKeyAndChallenge(key, challenge, 
  526.     NULL);
  527. if (spki == NULL) {
  528.     error_out("ERROR: Unable to decode Public Key and Challenge String");
  529. }
  530.     }
  531.     certReq = CERT_CreateCertificateRequest(name, spki, NULL);
  532.     if (certReq == NULL) {
  533. error_out("ERROR: Unable to create Certificate Request");
  534.     }
  535.     if (pubkey != NULL) {
  536. SECKEY_DestroyPublicKey(pubkey);
  537.     }
  538.     if (spki != NULL) {
  539. SECKEY_DestroySubjectPublicKeyInfo(spki);
  540.     }
  541.     if (pqgParams != NULL) {
  542. PQG_DestroyParams(pqgParams);
  543.     }
  544.     if (pqgVfy != NULL) {
  545. PQG_DestroyVerify(pqgVfy);
  546.     }
  547.     return certReq;
  548. }
  552. static CERTCertificate *
  553. MakeV1Cert(CERTCertDBHandle        *handle, 
  554.    CERTCertificateRequest  *req,
  555.    char                    *issuerNameStr, 
  556.    PRBool                  selfsign, 
  557.    int                     serialNumber,
  558.    int                     warpmonths,
  559.    Pair                    *data)
  560. {
  561.     CERTCertificate                 *issuerCert = NULL;
  562.     CERTValidity                    *validity;
  563.     CERTCertificate                 *cert = NULL;
  564.     PRExplodedTime                  printableTime;
  565.     PRTime                          now, 
  566.                             after;
  567.     SECStatus rv;
  568.    
  569.     
  571.     if ( !selfsign ) {
  572. issuerCert = CERT_FindCertByNameString(handle, issuerNameStr);
  573. if (!issuerCert) {
  574.     error_out("ERROR: Could not find issuer's certificate");
  575.     return NULL;
  576. }
  577.     }
  578.     if (find_field_bool(data, "manValidity", PR_TRUE)) {
  579. rv = DER_AsciiToTime(&now, find_field(data, "notBefore", PR_TRUE));
  580.     } else {
  581. now = PR_Now();
  582.     }
  583.     PR_ExplodeTime (now, PR_GMTParameters, &printableTime);
  584.     if ( warpmonths ) {
  585. printableTime.tm_month += warpmonths;
  586. now = PR_ImplodeTime (&printableTime);
  587. PR_ExplodeTime (now, PR_GMTParameters, &printableTime);
  588.     }
  589.     if (find_field_bool(data, "manValidity", PR_TRUE)) {
  590. rv = DER_AsciiToTime(&after, find_field(data, "notAfter", PR_TRUE));
  591. PR_ExplodeTime (after, PR_GMTParameters, &printableTime);
  592.     } else {
  593. printableTime.tm_month += 3;
  594. after = PR_ImplodeTime (&printableTime);
  595.     }
  596.     /* note that the time is now in micro-second unit */
  597.     validity = CERT_CreateValidity (now, after);
  599.     if ( selfsign ) {
  600. cert = CERT_CreateCertificate
  601.     (serialNumber,&(req->subject), validity, req);
  602.     } else {
  603. cert = CERT_CreateCertificate
  604.     (serialNumber,&(issuerCert->subject), validity, req);
  605.     }
  606.     
  607.     CERT_DestroyValidity(validity);
  608.     if ( issuerCert ) {
  609. CERT_DestroyCertificate (issuerCert);
  610.     }
  611.     return(cert);
  612. }
  614. static int
  615. get_serial_number(Pair  *data)
  616. {
  617.     int                 serial = 0;
  618.     int                 error;
  619.     char                *filename = SERIAL_FILE;
  620.     char                *SN;
  621.     FILE                *serialFile;
  624.     if (find_field_bool(data, "serial-auto", PR_TRUE)) {
  625. serialFile = fopen(filename, "r");
  626. if (serialFile != NULL) {
  627.     fread(&serial, sizeof(int), 1, serialFile);
  628.     if (ferror(serialFile) != 0) {
  629. error_out("Error: Unable to read serial number file");
  630.     }
  631.     if (serial == 4294967295) {
  632. serial = 21;
  633.     }
  634.     fclose(serialFile);
  635.     ++serial;
  636.     serialFile = fopen(filename,"w");
  637.     if (serialFile == NULL) {
  638.         error_out("ERROR: Unable to open serial number file for writing");
  639.     }
  640.     fwrite(&serial, sizeof(int), 1, serialFile);
  641.     if (ferror(serialFile) != 0) {
  642. error_out("Error: Unable to write to serial number file");
  643.     }
  644. } else {
  645.     fclose(serialFile);
  646.     serialFile = fopen(filename,"w");
  647.     if (serialFile == NULL) {
  648. error_out("ERROR: Unable to open serial number file");
  649.     }
  650.     serial = 21;
  651.     fwrite(&serial, sizeof(int), 1, serialFile);
  652.     if (ferror(serialFile) != 0) {
  653. error_out("Error: Unable to write to serial number file");
  654.     }
  655.     error = ferror(serialFile);
  656.     if (error != 0) {
  657. error_out("ERROR: Unable to write to serial file");
  658.     }
  659. }
  660. fclose(serialFile);
  661.     } else {
  662. SN = find_field(data, "serial_value", PR_TRUE);
  663. while (*SN != '') {
  664.     serial = serial * 16;
  665.     if ((*SN >= 'A') && (*SN <='F')) {
  666. serial += *SN - 'A' + 10; 
  667.     } else {
  668. if ((*SN >= 'a') && (*SN <='f')) {
  669.     serial += *SN - 'a' + 10;
  670. } else {
  671.     serial += *SN - '0';
  672. }
  673.     }
  674.     ++SN;
  675. }
  676.     }
  677.     return serial;
  678. }
  683.        
  684. static CERTCertDBHandle
  685. *OpenCertDB(void)
  686.   /* NOTE: This routine has been modified to allow the libsec/pcertdb.c
  687.    * routines to automatically find and convert the old cert database
  688.    * into the new v3.0 format (cert db version 5).
  689.    */
  690. {
  691.     CERTCertDBHandle  *certHandle;
  692.     SECStatus         rv;
  694.     /* Allocate a handle to fill with CERT_OpenCertDB below */
  695.     certHandle = (CERTCertDBHandle *)PORT_ZAlloc(sizeof(CERTCertDBHandle));
  696.     if (!certHandle) {
  697. error_out("ERROR: unable to get database handle");
  698. return NULL;
  699.     }
  701.     rv = CERT_OpenCertDB(certHandle, PR_FALSE, SECU_CertDBNameCallback, NULL);
  703.     if (rv) {
  704. error_out("ERROR: Could not open certificate database");
  705. if (certHandle) free (certHandle);  /* we don't want to leave 
  706.        anything behind... */
  707. return NULL;
  708.     } else {
  709. CERT_SetDefaultCertDB(certHandle);
  710.     }
  712.     return certHandle;
  713. }
  715. typedef SECStatus (* EXTEN_VALUE_ENCODER)
  716. (PRArenaPool *extHandle, void *value, SECItem *encodedValue);
  718. static SECStatus 
  719. EncodeAndAddExtensionValue(
  720. PRArenaPool          *arena, 
  721. void                 *extHandle, 
  722. void                 *value, 
  723. PRBool       criticality,
  724. int       extenType, 
  725. EXTEN_VALUE_ENCODER  EncodeValueFn)
  726. {
  727.     SECItem                  encodedValue;
  728.     SECStatus                rv;
  731.     encodedValue.data = NULL;
  732.     encodedValue.len = 0;
  733.     rv = (*EncodeValueFn)(arena, value, &encodedValue);
  734.     if (rv != SECSuccess) {
  735. error_out("ERROR: Unable to encode extension value");
  736.     }
  737.     rv = CERT_AddExtension
  738. (extHandle, extenType, &encodedValue, criticality, PR_TRUE);
  739.     return (rv);
  740. }
  744. static SECStatus 
  745. AddKeyUsage (void  *extHandle, 
  746.      Pair  *data)
  747. {
  748.     SECItem        bitStringValue;
  749.     unsigned char  keyUsage = 0x0;
  751.     if (find_field_bool(data,"keyUsage-digitalSignature", PR_TRUE)){
  752. keyUsage |= (0x80 >> 0);
  753.     }
  754.     if (find_field_bool(data,"keyUsage-nonRepudiation", PR_TRUE)){
  755. keyUsage |= (0x80 >> 1);
  756.     }
  757.     if (find_field_bool(data,"keyUsage-keyEncipherment", PR_TRUE)){
  758. keyUsage |= (0x80 >> 2);
  759.     }
  760.     if (find_field_bool(data,"keyUsage-dataEncipherment", PR_TRUE)){
  761. keyUsage |= (0x80 >> 3);
  762.     }
  763.     if (find_field_bool(data,"keyUsage-keyAgreement", PR_TRUE)){
  764. keyUsage |= (0x80 >> 4);
  765.     }
  766.     if (find_field_bool(data,"keyUsage-keyCertSign", PR_TRUE)) {
  767. keyUsage |= (0x80 >> 5);
  768.     }
  769.     if (find_field_bool(data,"keyUsage-cRLSign", PR_TRUE)) {
  770. keyUsage |= (0x80 >> 6);
  771.     }
  773.     bitStringValue.data = &keyUsage;
  774.     bitStringValue.len = 1;
  776.     return (CERT_EncodeAndAddBitStrExtension
  777.     (extHandle, SEC_OID_X509_KEY_USAGE, &bitStringValue,
  778.      (find_field_bool(data, "keyUsage-crit", PR_TRUE))));
  780. }
  782. static CERTOidSequence *
  783. CreateOidSequence(void)
  784. {
  785.   CERTOidSequence *rv = (CERTOidSequence *)NULL;
  786.   PRArenaPool *arena = (PRArenaPool *)NULL;
  788.   arena = PORT_NewArena(DER_DEFAULT_CHUNKSIZE);
  789.   if( (PRArenaPool *)NULL == arena ) {
  790.     goto loser;
  791.   }
  793.   rv = (CERTOidSequence *)PORT_ArenaZAlloc(arena, sizeof(CERTOidSequence));
  794.   if( (CERTOidSequence *)NULL == rv ) {
  795.     goto loser;
  796.   }
  798.   rv->oids = (SECItem **)PORT_ArenaZAlloc(arena, sizeof(SECItem *));
  799.   if( (SECItem **)NULL == rv->oids ) {
  800.     goto loser;
  801.   }
  803.   rv->arena = arena;
  804.   return rv;
  806.  loser:
  807.   if( (PRArenaPool *)NULL != arena ) {
  808.     PORT_FreeArena(arena, PR_FALSE);
  809.   }
  811.   return (CERTOidSequence *)NULL;
  812. }
  814. static SECStatus
  815. AddOidToSequence(CERTOidSequence *os, SECOidTag oidTag)
  816. {
  817.   SECItem **oids;
  818.   PRUint32 count = 0;
  819.   SECOidData *od;
  821.   od = SECOID_FindOIDByTag(oidTag);
  822.   if( (SECOidData *)NULL == od ) {
  823.     return SECFailure;
  824.   }
  826.   for( oids = os->oids; (SECItem *)NULL != *oids; oids++ ) {
  827.     count++;
  828.   }
  830.   /* ArenaZRealloc */
  832.   {
  833.     PRUint32 i;
  835.     oids = (SECItem **)PORT_ArenaZAlloc(os->arena, sizeof(SECItem *) * (count+2));
  836.     if( (SECItem **)NULL == oids ) {
  837.       return SECFailure;
  838.     }
  839.     
  840.     for( i = 0; i < count; i++ ) {
  841.       oids[i] = os->oids[i];
  842.     }
  844.     /* ArenaZFree(os->oids); */
  845.   }
  847.   os->oids = oids;
  848.   os->oids[count] = &od->oid;
  850.   return SECSuccess;
  851. }
  853. static SECItem *
  854. EncodeOidSequence(CERTOidSequence *os)
  855. {
  856.   SECItem *rv;
  857.   extern const SEC_ASN1Template CERT_OidSeqTemplate[];
  859.   rv = (SECItem *)PORT_ArenaZAlloc(os->arena, sizeof(SECItem));
  860.   if( (SECItem *)NULL == rv ) {
  861.     goto loser;
  862.   }
  864.   if( !SEC_ASN1EncodeItem(os->arena, rv, os, CERT_OidSeqTemplate) ) {
  865.     goto loser;
  866.   }
  868.   return rv;
  870.  loser:
  871.   return (SECItem *)NULL;
  872. }
  874. static SECStatus
  875. AddExtKeyUsage(void *extHandle, Pair *data)
  876. {
  877.   SECStatus rv;
  878.   CERTOidSequence *os;
  879.   SECItem *value;
  880.   PRBool crit;
  882.   os = CreateOidSequence();
  883.   if( (CERTOidSequence *)NULL == os ) {
  884.     return SECFailure;
  885.   }
  887.   if( find_field_bool(data, "extKeyUsage-serverAuth", PR_TRUE) ) {
  888.     rv = AddOidToSequence(os, SEC_OID_EXT_KEY_USAGE_SERVER_AUTH);
  889.     if( SECSuccess != rv ) goto loser;
  890.   }
  892.   if( find_field_bool(data, "extKeyUsage-clientAuth", PR_TRUE) ) {
  893.     rv = AddOidToSequence(os, SEC_OID_EXT_KEY_USAGE_CLIENT_AUTH);
  894.     if( SECSuccess != rv ) goto loser;
  895.   }
  897.   if( find_field_bool(data, "extKeyUsage-codeSign", PR_TRUE) ) {
  898.     rv = AddOidToSequence(os, SEC_OID_EXT_KEY_USAGE_CODE_SIGN);
  899.     if( SECSuccess != rv ) goto loser;
  900.   }
  902.   if( find_field_bool(data, "extKeyUsage-emailProtect", PR_TRUE) ) {
  903.     rv = AddOidToSequence(os, SEC_OID_EXT_KEY_USAGE_EMAIL_PROTECT);
  904.     if( SECSuccess != rv ) goto loser;
  905.   }
  907.   if( find_field_bool(data, "extKeyUsage-timeStamp", PR_TRUE) ) {
  908.     rv = AddOidToSequence(os, SEC_OID_EXT_KEY_USAGE_TIME_STAMP);
  909.     if( SECSuccess != rv ) goto loser;
  910.   }
  912.   if( find_field_bool(data, "extKeyUsage-ocspResponder", PR_TRUE) ) {
  913.     rv = AddOidToSequence(os, SEC_OID_OCSP_RESPONDER);
  914.     if( SECSuccess != rv ) goto loser;
  915.   }
  917.   if( find_field_bool(data, "extKeyUsage-NS-govtApproved", PR_TRUE) ) {
  918.     rv = AddOidToSequence(os, SEC_OID_NS_KEY_USAGE_GOVT_APPROVED);
  919.     if( SECSuccess != rv ) goto loser;
  920.   }
  922.   value = EncodeOidSequence(os);
  924.   crit = find_field_bool(data, "extKeyUsage-crit", PR_TRUE);
  926.   rv = CERT_AddExtension(extHandle, SEC_OID_X509_EXT_KEY_USAGE, value,
  927.                          crit, PR_TRUE);
  928.   /*FALLTHROUGH*/
  929.  loser:
  930.   CERT_DestroyOidSequence(os);
  931.   return rv;
  932. }
  934. static SECStatus
  935. AddSubKeyID(void             *extHandle, 
  936.     Pair             *data, 
  937.     CERTCertificate  *subjectCert)
  938. {
  939.     SECItem                  encodedValue;
  940.     SECStatus                rv;
  941.     char                     *read;
  942.     char                     *write;
  943.     char                     *first;
  944.     char                     character;
  945.     int                      high_digit = 0,
  946.                      low_digit = 0;
  947.     int                      len;
  948.     PRBool                   odd = PR_FALSE;
  951.     encodedValue.data = NULL;
  952.     encodedValue.len = 0;
  953.     first = read = write = find_field(data,"subjectKeyIdentifier-text", 
  954.       PR_TRUE);
  955.     len = PORT_Strlen(first);
  956.     odd = ((len % 2) != 0 ) ? PR_TRUE : PR_FALSE;
  957.     if (find_field_bool(data, "subjectKeyIdentifier-radio-hex", PR_TRUE)) {
  958. if (odd) {
  959.     error_out("ERROR: Improperly formated subject key identifier, hex values must be expressed as an octet string");
  960. }
  961. while (*read != '') {
  962.     if (!isxdigit(*read)) {
  963. error_out("ERROR: Improperly formated subject key identifier");
  964.     }
  965.     *read = toupper(*read);
  966.     if ((*read >= 'A') && (*read <= 'F')) {
  967. high_digit = *read - 'A' + 10;
  968.     }  else {
  969. high_digit = *read - '0';
  970.     }
  971.     ++read;
  972.     if (!isxdigit(*read)) {
  973. error_out("ERROR: Improperly formated subject key identifier");
  974.     }
  975.     *read = toupper(*read);
  976.     if ((*read >= 'A') && (*read <= 'F')) {
  977. low_digit = *(read) - 'A' + 10;
  978.     } else {
  979. low_digit = *(read) - '0';
  980.     }
  981.     character = (high_digit << 4) | low_digit;
  982.     *write = character;
  983.     ++write;
  984.     ++read;
  985. }
  986. *write = '';
  987. len = write - first;
  988.     }
  989.     subjectCert->subjectKeyID.data = (unsigned char *) find_field
  990. (data,"subjectKeyIdentifier-text", PR_TRUE);
  991.     subjectCert->subjectKeyID.len = len;
  992.     rv = CERT_EncodeSubjectKeyID
  993. (NULL, find_field(data,"subjectKeyIdentifier-text", PR_TRUE),
  994.  len, &encodedValue);
  995.     if (rv) {
  996. return (rv);
  997.     }
  998.     return (CERT_AddExtension(extHandle,  SEC_OID_X509_SUBJECT_KEY_ID, 
  999.       &encodedValue, PR_FALSE, PR_TRUE));
  1000. }
  1003. static SECStatus 
  1004. AddAuthKeyID (void              *extHandle,
  1005.       Pair              *data, 
  1006.       char              *issuerNameStr, 
  1007.       CERTCertDBHandle  *handle)
  1008. {
  1009.     CERTAuthKeyID               *authKeyID = NULL;    
  1010.     PRArenaPool                 *arena = NULL;
  1011.     SECStatus                   rv = SECSuccess;
  1012.     CERTCertificate             *issuerCert = NULL;
  1013.     CERTGeneralName             *genNames;
  1014.     CERTName                    *directoryName = NULL;
  1017.     issuerCert = CERT_FindCertByNameString(handle, issuerNameStr);
  1018.     arena = PORT_NewArena(DER_DEFAULT_CHUNKSIZE);
  1019.     if ( !arena ) {
  1020. error_allocate();
  1021.     }
  1023.     authKeyID = PORT_ArenaZAlloc (arena, sizeof (CERTAuthKeyID));
  1024.     if (authKeyID == NULL) {
  1025. error_allocate();
  1026.     }
  1027.     if (find_field_bool(data, "authorityKeyIdentifier-radio-keyIdentifier", 
  1028. PR_TRUE)) {
  1029. authKeyID->keyID.data = PORT_ArenaAlloc (arena, PORT_Strlen 
  1030.        ((char *)issuerCert->subjectKeyID.data));
  1031. if (authKeyID->keyID.data == NULL) {
  1032.     error_allocate();
  1033. }
  1034. PORT_Memcpy (authKeyID->keyID.data, issuerCert->subjectKeyID.data, 
  1035.      authKeyID->keyID.len = 
  1036.         PORT_Strlen((char *)issuerCert->subjectKeyID.data));
  1037.     } else {
  1039. PORT_Assert (arena);
  1040. genNames = (CERTGeneralName *) PORT_ArenaZAlloc (arena, (sizeof(CERTGeneralName)));
  1041. if (genNames == NULL){
  1042.     error_allocate();
  1043. }
  1044. genNames->l.next = genNames->l.prev = &(genNames->l);
  1045. genNames->type = certDirectoryName;
  1047. directoryName = CERT_AsciiToName(issuerCert->subjectName);
  1048. if (!directoryName) {
  1049.     error_out("ERROR: Unable to create Directory Name");
  1050. }
  1051. rv = CERT_CopyName (arena, &genNames->name.directoryName, 
  1052.     directoryName);
  1053.         CERT_DestroyName (directoryName);
  1054. if (rv != SECSuccess) {
  1055.     error_out("ERROR: Unable to copy Directory Name");
  1056. }
  1057. authKeyID->authCertIssuer = genNames;
  1058. if (authKeyID->authCertIssuer == NULL && SECFailure == 
  1059.                                             PORT_GetError ()) {
  1060.     error_out("ERROR: Unable to get Issuer General Name for Authority Key ID Extension");
  1061. }
  1062. authKeyID->authCertSerialNumber = issuerCert->serialNumber;
  1063.     }
  1064.     rv = EncodeAndAddExtensionValue(arena, extHandle, authKeyID, PR_FALSE, 
  1065.     SEC_OID_X509_AUTH_KEY_ID, 
  1066.     (EXTEN_VALUE_ENCODER)
  1067.     CERT_EncodeAuthKeyID);
  1068.     if (arena) {
  1069. PORT_FreeArena (arena, PR_FALSE);
  1070.     }
  1071.     return (rv);
  1072. }
  1075. static SECStatus 
  1076. AddPrivKeyUsagePeriod(void             *extHandle, 
  1077.       Pair             *data, 
  1078.       CERTCertificate  *cert)
  1079. {
  1080.     char *notBeforeStr;
  1081.     char *notAfterStr;
  1082.     PRArenaPool *arena = NULL;
  1083.     SECStatus rv = SECSuccess;
  1084.     PKUPEncodedContext *pkup;
  1087.     arena = PORT_NewArena(DER_DEFAULT_CHUNKSIZE);
  1088.     if ( !arena ) {
  1089. error_allocate();
  1090.     }
  1091.     pkup = PORT_ArenaZAlloc (arena, sizeof (PKUPEncodedContext));
  1092.     if (pkup == NULL) {
  1093. error_allocate();
  1094.     }
  1095.     notBeforeStr = (char *) PORT_Alloc(16 * sizeof(char));
  1096.     notAfterStr = (char *) PORT_Alloc(16 * sizeof(char));
  1097.     *notBeforeStr = '';
  1098.     *notAfterStr = '';
  1099.     pkup->arena = arena;
  1100.     pkup->notBefore.len = 0;
  1101.     pkup->notBefore.data = NULL;
  1102.     pkup->notAfter.len = 0;
  1103.     pkup->notAfter.data = NULL;
  1104.     if (find_field_bool(data, "privKeyUsagePeriod-radio-notBefore", PR_TRUE) ||
  1105. find_field_bool(data, "privKeyUsagePeriod-radio-both", PR_TRUE)) {
  1106. pkup->notBefore.len = 15;
  1107. pkup->notBefore.data = (unsigned char *)notBeforeStr;
  1108. if (find_field_bool(data, "privKeyUsagePeriod-notBefore-radio-manual", 
  1109.     PR_TRUE)) {
  1110.     PORT_Strcat(notBeforeStr,find_field(data,
  1111.    "privKeyUsagePeriod-notBefore-year",
  1112.    PR_TRUE));
  1113.     PORT_Strcat(notBeforeStr,find_field(data,
  1114.    "privKeyUsagePeriod-notBefore-month",
  1115.    PR_TRUE));
  1116.     PORT_Strcat(notBeforeStr,find_field(data,
  1117.    "privKeyUsagePeriod-notBefore-day",
  1118.    PR_TRUE));
  1119.     PORT_Strcat(notBeforeStr,find_field(data,
  1120.    "privKeyUsagePeriod-notBefore-hour",
  1121.    PR_TRUE));
  1122.     PORT_Strcat(notBeforeStr,find_field(data,
  1123.   "privKeyUsagePeriod-notBefore-minute",
  1124.    PR_TRUE));
  1125.     PORT_Strcat(notBeforeStr,find_field(data,
  1126.   "privKeyUsagePeriod-notBefore-second",
  1127.    PR_TRUE));
  1128.     if ((*(notBeforeStr + 14) != '') ||
  1129. (!isdigit(*(notBeforeStr + 13))) ||
  1130. (*(notBeforeStr + 12) >= '5' && *(notBeforeStr + 12) <= '0') ||
  1131. (!isdigit(*(notBeforeStr + 11))) ||
  1132. (*(notBeforeStr + 10) >= '5' && *(notBeforeStr + 10) <= '0') ||
  1133. (!isdigit(*(notBeforeStr + 9))) ||
  1134. (*(notBeforeStr + 8) >= '2' && *(notBeforeStr + 8) <= '0') ||
  1135. (!isdigit(*(notBeforeStr + 7))) ||
  1136. (*(notBeforeStr + 6) >= '3' && *(notBeforeStr + 6) <= '0') ||
  1137. (!isdigit(*(notBeforeStr + 5))) ||
  1138. (*(notBeforeStr + 4) >= '1' && *(notBeforeStr + 4) <= '0') ||
  1139. (!isdigit(*(notBeforeStr + 3))) ||
  1140. (!isdigit(*(notBeforeStr + 2))) ||
  1141. (!isdigit(*(notBeforeStr + 1))) ||
  1142. (!isdigit(*(notBeforeStr + 0))) ||
  1143. (*(notBeforeStr + 8) == '2' && *(notBeforeStr + 9) >= '4') ||
  1144. (*(notBeforeStr + 6) == '3' && *(notBeforeStr + 7) >= '1') ||
  1145. (*(notBeforeStr + 4) == '1' && *(notBeforeStr + 5) >= '2')) {
  1146. error_out("ERROR: Improperly formated private key usage period");
  1147.     }
  1148.     *(notBeforeStr + 14) = 'Z';
  1149.     *(notBeforeStr + 15) = '';
  1150. } else {
  1151.     if ((*(cert->validity.notBefore.data) > '5') || 
  1152. ((*(cert->validity.notBefore.data) == '5') &&
  1153.  (*(cert->validity.notBefore.data + 1) != '0'))) {
  1154. PORT_Strcat(notBeforeStr, "19");
  1155.     } else {
  1156. PORT_Strcat(notBeforeStr, "20");
  1157.     }
  1158.     PORT_Strcat(notBeforeStr, (char *)cert->validity.notBefore.data);
  1159. }
  1160.     }
  1161.     if (find_field_bool(data, "privKeyUsagePeriod-radio-notAfter", PR_TRUE) ||
  1162. find_field_bool(data, "privKeyUsagePeriod-radio-both", PR_TRUE)) {
  1163. pkup->notAfter.len = 15;
  1164. pkup->notAfter.data = (unsigned char *)notAfterStr;
  1165. PORT_Strcat(notAfterStr,find_field(data,"privKeyUsagePeriod-notAfter-year", 
  1166.       PR_TRUE));
  1167. PORT_Strcat(notAfterStr,find_field(data,"privKeyUsagePeriod-notAfter-month",
  1168.       PR_TRUE));
  1169. PORT_Strcat(notAfterStr,find_field(data,"privKeyUsagePeriod-notAfter-day", 
  1170.       PR_TRUE));
  1171. PORT_Strcat(notAfterStr,find_field(data,"privKeyUsagePeriod-notAfter-hour", 
  1172.       PR_TRUE));
  1173. PORT_Strcat(notAfterStr,find_field(data,"privKeyUsagePeriod-notAfter-minute",
  1174.       PR_TRUE));
  1175. PORT_Strcat(notAfterStr,find_field(data,"privKeyUsagePeriod-notAfter-second",
  1176.       PR_TRUE));
  1177. if ((*(notAfterStr + 14) != '') ||
  1178.     (!isdigit(*(notAfterStr + 13))) ||
  1179.     (*(notAfterStr + 12) >= '5' && *(notAfterStr + 12) <= '0') ||
  1180.     (!isdigit(*(notAfterStr + 11))) ||
  1181.     (*(notAfterStr + 10) >= '5' && *(notAfterStr + 10) <= '0') ||
  1182.     (!isdigit(*(notAfterStr + 9))) ||
  1183.     (*(notAfterStr + 8) >= '2' && *(notAfterStr + 8) <= '0') ||
  1184.     (!isdigit(*(notAfterStr + 7))) ||
  1185.     (*(notAfterStr + 6) >= '3' && *(notAfterStr + 6) <= '0') ||
  1186.     (!isdigit(*(notAfterStr + 5))) ||
  1187.     (*(notAfterStr + 4) >= '1' && *(notAfterStr + 4) <= '0') ||
  1188.     (!isdigit(*(notAfterStr + 3))) ||
  1189.     (!isdigit(*(notAfterStr + 2))) ||
  1190.     (!isdigit(*(notAfterStr + 1))) ||
  1191.     (!isdigit(*(notAfterStr + 0))) ||
  1192.     (*(notAfterStr + 8) == '2' && *(notAfterStr + 9) >= '4') ||
  1193.     (*(notAfterStr + 6) == '3' && *(notAfterStr + 7) >= '1') ||
  1194.     (*(notAfterStr + 4) == '1' && *(notAfterStr + 5) >= '2')) {
  1195.     error_out("ERROR: Improperly formated private key usage period");
  1196. }
  1197. *(notAfterStr + 14) = 'Z';
  1198. *(notAfterStr + 15) = '';
  1199.     }
  1201.     PORT_Assert (arena);
  1203.     rv = EncodeAndAddExtensionValue(arena, extHandle, pkup, 
  1204.     find_field_bool(data,
  1205.     "privKeyUsagePeriod-crit", 
  1206.     PR_TRUE), 
  1207.     SEC_OID_X509_PRIVATE_KEY_USAGE_PERIOD, 
  1208.     (EXTEN_VALUE_ENCODER)
  1209.     CERT_EncodePublicKeyUsagePeriod);
  1210.     if (arena) {
  1211. PORT_FreeArena (arena, PR_FALSE);
  1212.     }
  1213.     if (notBeforeStr != NULL) {
  1214. PORT_Free(notBeforeStr);
  1215.     }
  1216.     if (notAfterStr != NULL) {
  1217. PORT_Free(notAfterStr);
  1218.     }
  1219.     return (rv);
  1220. }    
  1222. static SECStatus 
  1223. AddBasicConstraint(void   *extHandle, 
  1224.    Pair   *data)
  1225. {
  1226.     CERTBasicConstraints  basicConstraint;
  1227.     SECItem               encodedValue;
  1228.     SECStatus             rv;
  1230.     encodedValue.data = NULL;
  1231.     encodedValue.len = 0;
  1232.     basicConstraint.pathLenConstraint = CERT_UNLIMITED_PATH_CONSTRAINT;
  1233.     basicConstraint.isCA = (find_field_bool(data,"basicConstraints-cA-radio-CA",
  1234.     PR_TRUE));
  1235.     if (find_field_bool(data,"basicConstraints-pathLengthConstraint", PR_TRUE)){
  1236. basicConstraint.pathLenConstraint = atoi 
  1237.     (find_field(data,"basicConstraints-pathLengthConstraint-text", 
  1238. PR_TRUE));
  1239.     }
  1240.     
  1241.     rv = CERT_EncodeBasicConstraintValue (NULL, &basicConstraint, 
  1242.   &encodedValue);
  1243.     if (rv)
  1244. return (rv);
  1245.     rv = CERT_AddExtension(extHandle, SEC_OID_X509_BASIC_CONSTRAINTS, 
  1246.    &encodedValue, 
  1247.    (find_field_bool(data,"basicConstraints-crit", 
  1248.     PR_TRUE)), PR_TRUE);
  1250.     PORT_Free (encodedValue.data);
  1251.     return (rv);
  1252. }
  1256. static SECStatus 
  1257. AddNscpCertType (void  *extHandle, 
  1258.  Pair  *data)
  1259. {
  1260.     SECItem            bitStringValue;
  1261.     unsigned char      CertType = 0x0;
  1263.     if (find_field_bool(data,"netscape-cert-type-ssl-client", PR_TRUE)){
  1264. CertType |= (0x80 >> 0);
  1265.     }
  1266.     if (find_field_bool(data,"netscape-cert-type-ssl-server", PR_TRUE)){
  1267. CertType |= (0x80 >> 1);
  1268.     }
  1269.     if (find_field_bool(data,"netscape-cert-type-smime", PR_TRUE)){
  1270. CertType |= (0x80 >> 2);
  1271.     }
  1272.     if (find_field_bool(data,"netscape-cert-type-object-signing", PR_TRUE)){
  1273. CertType |= (0x80 >> 3);
  1274.     }
  1275.     if (find_field_bool(data,"netscape-cert-type-reserved", PR_TRUE)){
  1276. CertType |= (0x80 >> 4);
  1277.     }
  1278.     if (find_field_bool(data,"netscape-cert-type-ssl-ca", PR_TRUE)) {
  1279. CertType |= (0x80 >> 5);
  1280.     }
  1281.     if (find_field_bool(data,"netscape-cert-type-smime-ca", PR_TRUE)) {
  1282. CertType |= (0x80 >> 6);
  1283.     }
  1284.     if (find_field_bool(data,"netscape-cert-type-object-signing-ca", PR_TRUE)) {
  1285. CertType |= (0x80 >> 7);
  1286.     }
  1288.     bitStringValue.data = &CertType;
  1289.     bitStringValue.len = 1;
  1291.     return (CERT_EncodeAndAddBitStrExtension
  1292.     (extHandle, SEC_OID_NS_CERT_EXT_CERT_TYPE, &bitStringValue,
  1293.      (find_field_bool(data, "netscape-cert-type-crit", PR_TRUE))));
  1294. }
  1297. static SECStatus
  1298. add_IA5StringExtension(void    *extHandle, 
  1299.        char    *string, 
  1300.        PRBool  crit, 
  1301.        int     idtag)
  1302. {
  1303.     SECItem                    encodedValue;
  1304.     SECStatus                  rv;
  1306.     encodedValue.data = NULL;
  1307.     encodedValue.len = 0;
  1309.     rv = CERT_EncodeIA5TypeExtension(NULL, string, &encodedValue);
  1310.     if (rv) {
  1311. return (rv);
  1312.     }
  1313.     return (CERT_AddExtension(extHandle, idtag, &encodedValue, crit, PR_TRUE));
  1314. }
  1316. static SECItem *
  1317. string_to_oid(char  *string)
  1318. {
  1319.     int             i;
  1320.     int             length = 20;
  1321.     int             remaining;
  1322.     int             first_value;
  1323.     int             second_value;
  1324.     int             value;
  1325.     int             oidLength;
  1326.     unsigned char   *oidString;
  1327.     unsigned char   *write;
  1328.     unsigned char   *read;
  1329.     unsigned char   *temp;
  1330.     SECItem         *oid;
  1331.     
  1332.     
  1333.     remaining = length;
  1334.     i = 0;
  1335.     while (*string == ' ') {
  1336. string++;
  1337.     }
  1338.     while (isdigit(*(string + i))) {
  1339. i++;
  1340.     }
  1341.     if (*(string + i) == '.') {
  1342. *(string + i) = '';
  1343.     } else {
  1344. error_out("ERROR: Improperly formated OID");
  1345.     }
  1346.     first_value = atoi(string);
  1347.     if (first_value < 0 || first_value > 2) {
  1348. error_out("ERROR: Improperly formated OID");
  1349.     }
  1350.     string += i + 1;
  1351.     i = 0;
  1352.     while (isdigit(*(string + i))) {
  1353. i++;
  1354.     }
  1355.     if (*(string + i) == '.') {
  1356. *(string + i) = '';
  1357.     } else {
  1358. error_out("ERROR: Improperly formated OID");
  1359.     }
  1360.     second_value = atoi(string);
  1361.     if (second_value < 0 || second_value > 39) {
  1362. error_out("ERROR: Improperly formated OID");
  1363.     }
  1364.     oidString = PORT_ZAlloc(2);
  1365.     *oidString = (first_value * 40) + second_value;
  1366.     *(oidString + 1) = '';
  1367.     oidLength = 1;
  1368.     string += i + 1;
  1369.     i = 0;
  1370.     temp = write = PORT_ZAlloc(length);
  1371.     while (*string != '') {
  1372. value = 0;
  1373. while(isdigit(*(string + i))) {
  1374.     i++;
  1375. }
  1376. if (*(string + i) == '') {
  1377.     value = atoi(string);
  1378.     string += i;
  1379. } else {
  1380.     if (*(string + i) == '.') {
  1381. *(string + i) == '';
  1382. value = atoi(string);
  1383. string += i + 1;
  1384.     } else {
  1385. *(string + i) = '';
  1386. i++;
  1387. value = atoi(string);
  1388. if (*(string + i) == ' ') {
  1389.     while (*(string + i) == ' ')
  1390. i++;
  1391. }
  1392. if (*(string + i) != '') {
  1393.     error_out("ERROR: Improperly formated OID");
  1394. }
  1395.     }
  1396. }
  1397. i = 0;
  1398. while (value != 0) {
  1399.     if (remaining < 1) {
  1400. remaining += length;
  1401. length = length * 2;
  1402. temp = PORT_Realloc(temp, length);
  1403. write = temp + length - remaining;
  1404.     }
  1405.     *write = (value & 0x7f) | (0x80);
  1406.     write++;
  1407.     remaining--;
  1408.     value = value >> 7;
  1409. }
  1410. *temp = *temp & (0x7f);
  1411. oidLength += write - temp;
  1412. oidString = PORT_Realloc(oidString, (oidLength + 1));
  1413. read = write - 1;
  1414. write = oidLength + oidString - 1;
  1415. for (i = 0; i < (length - remaining); i++) {
  1416.     *write = *read;
  1417.     write--;
  1418.     read++;
  1419. }
  1420. write = temp;
  1421. remaining = length;
  1422.     }
  1423.     *(oidString + oidLength) = '';
  1424.     oid = (SECItem *) PORT_ZAlloc(sizeof(SECItem));
  1425.     oid->data = oidString;
  1426.     oid->len  = oidLength;
  1427.     PORT_Free(temp);
  1428.     return oid;
  1429. }
  1431. static SECItem *
  1432. string_to_ipaddress(char *string)
  1433. {
  1434.     int      i = 0;
  1435.     int      value;
  1436.     int      j = 0;
  1437.     SECItem  *ipaddress;
  1438.     
  1440.     while (*string == ' ') {
  1441. string++;
  1442.     }
  1443.     ipaddress = (SECItem *) PORT_ZAlloc(sizeof(SECItem));
  1444.     ipaddress->data = PORT_ZAlloc(9);
  1445.     while (*string != '' && j < 8) {
  1446. while (isdigit(*(string + i))) {
  1447.     i++;
  1448. }
  1449. if (*(string + i) == '.') {
  1450.     *(string + i) = '';
  1451.     value = atoi(string);
  1452.     string = string + i + 1;
  1453.     i = 0;
  1454. } else {
  1455.     if (*(string + i) == '') {
  1456. value = atoi(string);
  1457. string = string + i;
  1458. i = 0;
  1459.     } else {
  1460. *(string + i) = '';
  1461. while (*(string + i) == ' ') {
  1462.     i++;
  1463. }
  1464. if (*(string + i) == '') {
  1465.     value = atoi(string);
  1466.     string = string + i;
  1467.     i = 0;
  1468. } else {
  1469.     error_out("ERROR: Improperly formated IP Address");
  1470. }
  1471.     }
  1472. }
  1473. if (value >= 0 || value < 256) {
  1474.     *(ipaddress->data + j) = value;
  1475. } else {
  1476.     error_out("ERROR: Improperly formated IP Address");
  1477. }
  1478. j++;
  1479.     }
  1480.     *(ipaddress->data + j) = '';
  1481.     if (j != 4 && j != 8) {
  1482. error_out("ERROR: Improperly formated IP Address");
  1483.     }
  1484.     ipaddress->len = j;
  1485.     return ipaddress;
  1486. }
  1488. static SECItem *
  1489. string_to_binary(char  *string)
  1490. {
  1491.     SECItem            *rv;
  1492.     int                high_digit;
  1493.     int                low_digit;
  1495.     rv = (SECItem *) PORT_ZAlloc(sizeof(SECItem));
  1496.     if (rv == NULL) {
  1497. error_allocate();
  1498.     }
  1499.     rv->data = (unsigned char *) PORT_ZAlloc((PORT_Strlen(string))/3 + 2);
  1500.     while (!isxdigit(*string)) {
  1501. string++;
  1502.     }
  1503.     rv->len = 0;
  1504.     while (*string != '') {
  1505. if (isxdigit(*string)) {
  1506.     if (*string >= '0' && *string <= '9') {
  1507. high_digit = *string - '0';
  1508.     } else {
  1509. *string = toupper(*string);
  1510. high_digit = *string - 'A';
  1511.     }
  1512.     string++;
  1513.     if (*string >= '0' && *string <= '9') {
  1514. low_digit = *string - '0';
  1515.     } else {
  1516. *string = toupper(*string);
  1517. low_digit = *string = 'A';
  1518.     }
  1519.     (rv->len)++;
  1520. } else {
  1521.     if (*string == ':') {
  1522. string++;
  1523.     } else {
  1524. if (*string == ' ') {
  1525.     while (*string == ' ') {
  1526. string++;
  1527.     }
  1528. }
  1529. if (*string != '') {
  1530.     error_out("ERROR: Improperly formated binary encoding");
  1531. }
  1532.     }
  1533. } 
  1534.     }
  1536.     return rv;
  1537. }
  1539. static SECStatus
  1540. MakeGeneralName(char             *name, 
  1541. CERTGeneralName  *genName,
  1542. PRArenaPool      *arena)
  1543. {
  1544.     SECItem                      *oid;
  1545.     SECOidData                   *oidData;
  1546.     SECItem                      *ipaddress;
  1547.     SECItem                      *temp = NULL;
  1548.     int                          i;
  1549.     int                          nameType;
  1550.     PRBool                       binary = PR_FALSE;
  1551.     SECStatus                    rv = SECSuccess;
  1552.     PRBool                       nickname;
  1554.     PORT_Assert(genName);
  1555.     PORT_Assert(arena);
  1556.     nameType = *(name + PORT_Strlen(name) - 1) - '0';
  1557.     if (nameType == 0  && *(name +PORT_Strlen(name) - 2) == '1') {
  1558. nickname = PR_TRUE;
  1559. nameType = certOtherName;
  1560.     }
  1561.     if (nameType < 1 || nameType > 9) {
  1562. error_out("ERROR: Unknown General Name Type");
  1563.     }
  1564.     *(name + PORT_Strlen(name) - 4) = '';
  1565.     genName->type = nameType;
  1566.     
  1567.     switch (genName->type) {
  1568.       case certURI:
  1569.       case certRFC822Name:
  1570.       case certDNSName: {
  1571.   genName->name.other.data = (unsigned char *)name;
  1572.   genName->name.other.len = PORT_Strlen(name);
  1573.   break;
  1574.       }
  1575.       
  1576.       case certIPAddress: {
  1577.   ipaddress = string_to_ipaddress(name);
  1578.   genName->name.other.data = ipaddress->data;
  1579.   genName->name.other.len = ipaddress->len;
  1580.   break;
  1581.       }
  1582.       
  1583.       case certRegisterID: {
  1584.   oid = string_to_oid(name);
  1585.   genName->name.other.data = oid->data;
  1586.   genName->name.other.len = oid->len;
  1587.   break;
  1588.       }
  1589.       
  1590.       case certEDIPartyName:
  1591.       case certX400Address: {
  1592.   
  1593.   genName->name.other.data = PORT_ArenaAlloc (arena, 
  1594.       PORT_Strlen (name) + 2);
  1595.   if (genName->name.other.data == NULL) {
  1596.       error_allocate();
  1597.   }
  1598.   
  1599.   PORT_Memcpy (genName->name.other.data + 2, name, PORT_Strlen (name));
  1600.   /* This may not be accurate for all cases.  
  1601.      For now, use this tag type */
  1602.   genName->name.other.data[0] = (char)(((genName->type - 1) & 
  1603. 0x1f)| 0x80);
  1604.   genName->name.other.data[1] = (char)PORT_Strlen (name);
  1605.   genName->name.other.len = PORT_Strlen (name) + 2;
  1606.   break;
  1607.       }
  1608.       
  1609.       case certOtherName: {
  1610.   i = 0;
  1611.   if (!nickname) {
  1612.       while (!isdigit(*(name + PORT_Strlen(name) - i))) {
  1613.   i++;
  1614.       }
  1615.       if (*(name + PORT_Strlen(name) - i) == '1') {
  1616.   binary = PR_TRUE;
  1617.       } else {
  1618.   binary = PR_FALSE;
  1619.       }  
  1620.       while (*(name + PORT_Strlen(name) - i) != '-') {
  1621.   i++;
  1622.       }
  1623.       *(name + PORT_Strlen(name) - i - 1) = '';
  1624.       i = 0;
  1625.       while (*(name + i) != '-') {
  1626.   i++;
  1627.       }
  1628.       *(name + i - 1) = '';
  1629.       oid = string_to_oid(name + i + 2);
  1630.   } else {
  1631.       oidData = SECOID_FindOIDByTag(SEC_OID_NETSCAPE_NICKNAME);
  1632.       oid = &oidData->oid;
  1633.       while (*(name + PORT_Strlen(name) - i) != '-') {
  1634.   i++;
  1635.       }
  1636.       *(name + PORT_Strlen(name) - i) = '';
  1637.   }
  1638.   genName->name.OthName.oid.data = oid->data;
  1639.   genName->name.OthName.oid.len  = oid->len;
  1640.   if (binary) {
  1641.       temp = string_to_binary(name);
  1642.       genName->name.OthName.name.data = temp->data;
  1643.       genName->name.OthName.name.len = temp->len;
  1644.   } else {
  1645.       temp = (SECItem *) PORT_ZAlloc(sizeof(SECItem));
  1646.       if (temp == NULL) {
  1647.   error_allocate();
  1648.       }
  1649.       temp->data = (unsigned char *)name;
  1650.       temp->len = PORT_Strlen(name);
  1651.       SEC_ASN1EncodeItem (arena, &(genName->name.OthName.name), temp,
  1652.   CERTIA5TypeTemplate);
  1653.   }
  1654.   PORT_Free(temp);
  1655.   break;
  1656.       }
  1657.       
  1658.       case certDirectoryName: {
  1659.   CERTName *directoryName = NULL;
  1660.   
  1661.   directoryName = CERT_AsciiToName (name);
  1662.   if (!directoryName) {
  1663.       error_out("ERROR: Improperly formated alternative name");
  1664.       break;
  1665.   }
  1666.   rv = CERT_CopyName (arena, &genName->name.directoryName, 
  1667.       directoryName);
  1668.   CERT_DestroyName (directoryName);
  1669.   
  1670.   break;
  1671.       }
  1672.     }
  1673.     genName->l.next = &(genName->l);
  1674.     genName->l.prev = &(genName->l);
  1675.     return rv;
  1676. }
  1679. static CERTGeneralName *
  1680. MakeAltName(Pair             *data, 
  1681.     char             *which, 
  1682.     PRArenaPool      *arena)
  1683. {
  1684.     CERTGeneralName          *SubAltName;
  1685.     CERTGeneralName          *current;
  1686.     CERTGeneralName          *newname;
  1687.     char                     *name = NULL;
  1688.     SECStatus                rv = SECSuccess;
  1689.     int                      len;
  1690.     
  1692.     len = PORT_Strlen(which);
  1693.     name = find_field(data, which, PR_TRUE);
  1694.     SubAltName = current = (CERTGeneralName *) PORT_ZAlloc
  1695.                                         (sizeof(CERTGeneralName));
  1696.     if (current == NULL) {
  1697. error_allocate();
  1698.     }
  1699.     while (name != NULL) {
  1701. rv = MakeGeneralName(name, current, arena);
  1703. if (rv != SECSuccess) {
  1704.     break;
  1705. }
  1706. if (*(which + len -1) < '9') {
  1707.     *(which + len - 1) = *(which + len - 1) + 1;
  1708. } else {
  1709.     if (isdigit(*(which + len - 2) )) {
  1710. *(which + len - 2) = *(which + len - 2) + 1;
  1711. *(which + len - 1) = '0';
  1712.     } else {
  1713. *(which + len - 1) = '1';
  1714. *(which + len) = '0';
  1715. *(which + len + 1) = '';
  1716. len++;
  1717.     }
  1718. }
  1719. len = PORT_Strlen(which);
  1720. name = find_field(data, which, PR_TRUE);
  1721. if (name != NULL) {
  1722.     newname = (CERTGeneralName *) PORT_ZAlloc(sizeof(CERTGeneralName));
  1723.     if (newname == NULL) {
  1724. error_allocate();
  1725.     }
  1726.     current->l.next = &(newname->l);
  1727.     newname->l.prev = &(current->l);
  1728.     current = newname;
  1729.             newname = NULL;
  1730. } else {
  1731.     current->l.next = &(SubAltName->l);
  1732.     SubAltName->l.prev = &(current->l);
  1733. }
  1734.     }
  1735.     if (rv == SECFailure) {
  1736. return NULL;
  1737.     }
  1738.     return SubAltName;
  1739. }
  1741. static CERTNameConstraints *
  1742. MakeNameConstraints(Pair             *data, 
  1743.     PRArenaPool      *arena)
  1744. {
  1745.     CERTNameConstraints      *NameConstraints;
  1746.     CERTNameConstraint       *current = NULL;
  1747.     CERTNameConstraint       *last_permited = NULL;
  1748.     CERTNameConstraint       *last_excluded = NULL;
  1749.     char                     *constraint = NULL;
  1750.     char                     *which;
  1751.     SECStatus                rv = SECSuccess;
  1752.     int                      len;
  1753.     int                      i;
  1754.     long                     max;
  1755.     long                     min;
  1756.     PRBool                   permited;
  1757.     
  1759.     NameConstraints = (CERTNameConstraints *) PORT_ZAlloc
  1760.                             (sizeof(CERTNameConstraints));
  1761.     which = make_copy_string("NameConstraintSelect0", 25,'');
  1762.     len = PORT_Strlen(which);
  1763.     constraint = find_field(data, which, PR_TRUE);
  1764.     NameConstraints->permited = NameConstraints->excluded = NULL;
  1765.     while (constraint != NULL) {
  1766. current = (CERTNameConstraint *) PORT_ZAlloc
  1767.                        (sizeof(CERTNameConstraint));
  1768. if (current == NULL) {
  1769.     error_allocate();
  1770. }
  1771. i = 0;
  1772. while (*(constraint + PORT_Strlen(constraint) - i) != '-') {
  1773.     i++;
  1774. }
  1775.         *(constraint + PORT_Strlen(constraint) - i - 1) = ''; 
  1776. max = (long) atoi(constraint + PORT_Strlen(constraint) + 3);
  1777. if (max > 0) {
  1778.     (void) SEC_ASN1EncodeInteger(arena, &current->max, max);
  1779. }
  1780. i = 0;
  1781. while (*(constraint + PORT_Strlen(constraint) - i) != '-') {
  1782.     i++;
  1783. }
  1784.         *(constraint + PORT_Strlen(constraint) - i - 1) = '';
  1785. min = (long) atoi(constraint + PORT_Strlen(constraint) + 3);
  1786. (void) SEC_ASN1EncodeInteger(arena, &current->min, min);
  1787. while (*(constraint + PORT_Strlen(constraint) - i) != '-') {
  1788.     i++;
  1789. }
  1790.         *(constraint + PORT_Strlen(constraint) - i - 1) = '';
  1791. if (*(constraint + PORT_Strlen(constraint) + 3) == 'p') {
  1792.     permited = PR_TRUE;
  1793. } else {
  1794.     permited = PR_FALSE;
  1795. }
  1796. rv = MakeGeneralName(constraint, &(current->name), arena);
  1798. if (rv != SECSuccess) {
  1799.     break;
  1800. }
  1801. if (*(which + len - 1) < '9') {
  1802.     *(which + len - 1) = *(which + len - 1) + 1;
  1803. } else {
  1804.     if (isdigit(*(which + len - 2) )) {
  1805. *(which + len - 2) = *(which + len - 2) + 1;
  1806. *(which + len - 1) = '0';
  1807.     } else {
  1808. *(which + len - 1) = '1';
  1809. *(which + len) = '0';
  1810. *(which + len + 1) = '';
  1811. len++;
  1812.     }
  1813. }
  1814. len = PORT_Strlen(which);
  1815. if (permited) {
  1816.     if (NameConstraints->permited == NULL) {
  1817. NameConstraints->permited = last_permited = current;
  1818.     }
  1819.     last_permited->l.next = &(current->l);
  1820.     current->l.prev = &(last_permited->l);
  1821.     last_permited = current;
  1822. } else {
  1823.     if (NameConstraints->excluded == NULL) {
  1824. NameConstraints->excluded = last_excluded = current;
  1825.     }
  1826.     last_excluded->l.next = &(current->l);
  1827.     current->l.prev = &(last_excluded->l);
  1828.     last_excluded = current;
  1829. }
  1830. constraint = find_field(data, which, PR_TRUE);
  1831. if (constraint != NULL) {
  1832.     current = (CERTNameConstraint *) PORT_ZAlloc(sizeof(CERTNameConstraint));
  1833.     if (current = NULL) {
  1834. error_allocate();
  1835.     }
  1836. }
  1837.     }
  1838.     if (NameConstraints->permited != NULL) {
  1839. last_permited->l.next = &(NameConstraints->permited->l);
  1840. NameConstraints->permited->l.prev = &(last_permited->l);
  1841.     }
  1842.     if (NameConstraints->excluded != NULL) {
  1843. last_excluded->l.next = &(NameConstraints->excluded->l);
  1844. NameConstraints->excluded->l.prev = &(last_excluded->l);
  1845.     }
  1846.     if (which != NULL) {
  1847. PORT_Free(which);
  1848.     }
  1849.     if (rv == SECFailure) {
  1850. return NULL;
  1851.     }
  1852.     return NameConstraints;
  1853. }
  1857. static SECStatus
  1858. AddAltName(void              *extHandle,
  1859.    Pair              *data,
  1860.    char              *issuerNameStr, 
  1861.    CERTCertDBHandle  *handle,
  1862.    int               type)
  1863. {
  1864.     PRBool             autoIssuer = PR_FALSE;
  1865.     PRArenaPool        *arena = NULL;
  1866.     CERTGeneralName    *genName = NULL;
  1867.     CERTName           *directoryName = NULL;
  1868.     char               *which = NULL;
  1869.     char               *name = NULL;
  1870.     SECStatus          rv = SECSuccess;
  1871.     SECItem            *issuersAltName = NULL;
  1872.     CERTCertificate    *issuerCert = NULL;
  1873.     void               *mark;
  1876.     arena = PORT_NewArena(DER_DEFAULT_CHUNKSIZE);
  1877.     if (arena == NULL) {
  1878. error_allocate();
  1879.     }
  1880.     if (type == 0) {
  1881. which = make_copy_string("SubAltNameSelect0", 20,'');
  1882. genName = MakeAltName(data, which, arena);
  1883.     } else {
  1884. if (autoIssuer) {
  1885.     autoIssuer = find_field_bool(data,"IssuerAltNameSourceRadio-auto",
  1886.  PR_TRUE);
  1887.     issuerCert = CERT_FindCertByNameString(handle, issuerNameStr);
  1888.     rv = cert_FindExtension((*issuerCert).extensions, 
  1889.     SEC_OID_X509_SUBJECT_ALT_NAME, 
  1890.     issuersAltName);
  1891.     if (issuersAltName == NULL) {
  1892. name = PORT_Alloc(PORT_Strlen((*issuerCert).subjectName) + 4);
  1893. PORT_Strcpy(name, (*issuerCert).subjectName);
  1894. PORT_Strcat(name, " - 5");
  1895.     }
  1896. } else {
  1897.     which = make_copy_string("IssuerAltNameSelect0", 20,'');
  1898.     genName = MakeAltName(data, which, arena);
  1899. }
  1900.     }
  1901.     if (type == 0) {
  1902. EncodeAndAddExtensionValue(arena, extHandle, genName, 
  1903.    find_field_bool(data, "SubAltName-crit", 
  1904.    PR_TRUE), 
  1905.    SEC_OID_X509_SUBJECT_ALT_NAME, 
  1906.    (EXTEN_VALUE_ENCODER)
  1907.    CERT_EncodeAltNameExtension);
  1909.     } else {
  1910. if (autoIssuer && (name == NULL)) {
  1911.     rv = CERT_AddExtension
  1912. (extHandle, SEC_OID_X509_ISSUER_ALT_NAME, issuersAltName,
  1913.  find_field_bool(data, "IssuerAltName-crit", PR_TRUE), PR_TRUE);
  1914. } else {
  1915.     EncodeAndAddExtensionValue(arena, extHandle, genName, 
  1916.        find_field_bool(data, 
  1917.        "IssuerAltName-crit", 
  1918.        PR_TRUE), 
  1919.        SEC_OID_X509_ISSUER_ALT_NAME, 
  1920.        (EXTEN_VALUE_ENCODER)
  1921.        CERT_EncodeAltNameExtension);
  1922. }
  1923.     }
  1924.     if (which != NULL) {
  1925. PORT_Free(which);
  1926.     }
  1927.     if (issuerCert != NULL) {
  1928. CERT_DestroyCertificate(issuerCert);
  1929.     }
  1930.     if (arena != NULL) {
  1931. PORT_ArenaRelease (arena, mark);
  1932.     }
  1933.     return rv;
  1934. }
  1937. static SECStatus
  1938. AddNameConstraints(void  *extHandle,
  1939.    Pair  *data)
  1940. {
  1941.     PRBool              autoIssuer = PR_FALSE;
  1942.     PRArenaPool         *arena = NULL;
  1943.     CERTNameConstraints *constraints = NULL;
  1944.     char                *constraint = NULL;
  1945.     SECStatus           rv = SECSuccess;
  1948.     arena = PORT_NewArena(DER_DEFAULT_CHUNKSIZE);
  1949.     if (arena == NULL) {
  1950. error_allocate();
  1951.     }
  1952.     constraints = MakeNameConstraints(data, arena);
  1953.     if (constraints != NULL) {
  1954. EncodeAndAddExtensionValue(arena, extHandle, constraints, PR_TRUE, 
  1955.    SEC_OID_X509_NAME_CONSTRAINTS, 
  1956.    (EXTEN_VALUE_ENCODER)
  1957.    CERT_EncodeNameConstraintsExtension);
  1958.     }
  1959.     if (arena != NULL) {
  1960. PORT_ArenaRelease (arena, NULL);
  1961.     }
  1962.     return rv;
  1963. }
  1966. static SECStatus
  1967. add_extensions(CERTCertificate   *subjectCert, 
  1968.        Pair              *data, 
  1969.        char              *issuerNameStr, 
  1970.        CERTCertDBHandle  *handle)
  1971. {
  1972.     void                         *extHandle;
  1973.     SECStatus                    rv = SECSuccess;
  1976.     extHandle = CERT_StartCertExtensions (subjectCert);
  1977.     if (extHandle == NULL) {
  1978. error_out("ERROR: Unable to get certificates extension handle");
  1979.     }
  1980.     if (find_field_bool(data, "keyUsage", PR_TRUE)) {
  1981. rv = AddKeyUsage(extHandle, data);
  1982. if (rv != SECSuccess) {
  1983.     error_out("ERROR: Unable to add Key Usage extension");
  1984. }
  1985.     }
  1987.     if( find_field_bool(data, "extKeyUsage", PR_TRUE) ) {
  1988.       rv = AddExtKeyUsage(extHandle, data);
  1989.       if( SECSuccess != rv ) {
  1990.         error_out("ERROR: Unable to add Extended Key Usage extension");
  1991.       }
  1992.     }
  1994.     if (find_field_bool(data, "basicConstraints", PR_TRUE)) {
  1995. rv = AddBasicConstraint(extHandle, data);
  1996. if (rv != SECSuccess) {
  1997.     error_out("ERROR: Unable to add Basic Constraint extension");
  1998. }
  1999.     }
  2000.     if (find_field_bool(data, "subjectKeyIdentifier", PR_TRUE)) {
  2001. rv = AddSubKeyID(extHandle, data, subjectCert);
  2002. if (rv != SECSuccess) {
  2003.     error_out("ERROR: Unable to add Subject Key Identifier Extension");
  2004. }
  2005.     }
  2006.     if (find_field_bool(data, "authorityKeyIdentifier", PR_TRUE)) {
  2007. rv = AddAuthKeyID (extHandle, data, issuerNameStr, handle);
  2008. if (rv != SECSuccess) {
  2009.     error_out("ERROR: Unable to add Authority Key Identifier extension");
  2010. }
  2011.     }
  2012.     if (find_field_bool(data, "privKeyUsagePeriod", PR_TRUE)) {
  2013. rv = AddPrivKeyUsagePeriod (extHandle, data, subjectCert);
  2014. if (rv != SECSuccess) {
  2015.     error_out("ERROR: Unable to add Private Key Usage Period extension");
  2016. }
  2017.     }
  2018.     if (find_field_bool(data, "SubAltName", PR_TRUE)) {
  2019. rv = AddAltName (extHandle, data, NULL, NULL, 0);
  2020. if (rv != SECSuccess) {
  2021.     error_out("ERROR: Unable to add Subject Alternative Name extension");
  2022. }
  2023.     }
  2024.     if (find_field_bool(data, "IssuerAltName", PR_TRUE)) {
  2025. rv = AddAltName (extHandle, data, issuerNameStr, handle, 1);
  2026. if (rv != SECSuccess) {
  2027.     error_out("ERROR: Unable to add Issuer Alternative Name Extension");
  2028. }
  2029.     }
  2030.     if (find_field_bool(data, "NameConstraints", PR_TRUE)) {
  2031. rv = AddNameConstraints(extHandle, data);
  2032. if (rv != SECSuccess) {
  2033.     error_out("ERROR: Unable to add Name Constraints Extension");
  2034. }
  2035.     }
  2036.     if (find_field_bool(data, "netscape-cert-type", PR_TRUE)) {
  2037. rv = AddNscpCertType(extHandle, data);
  2038. if (rv != SECSuccess) {
  2039.     error_out("ERROR: Unable to add Netscape Certificate Type Extension");
  2040. }
  2041.     }
  2042.     if (find_field_bool(data, "netscape-base-url", PR_TRUE)) {
  2043. rv = add_IA5StringExtension(extHandle, 
  2044.     find_field(data, "netscape-base-url-text", 
  2045.        PR_TRUE), 
  2046.     find_field_bool(data, 
  2047.     "netscape-base-url-crit", 
  2048.     PR_TRUE),
  2049.     SEC_OID_NS_CERT_EXT_BASE_URL);
  2050. if (rv != SECSuccess) {
  2051.     error_out("ERROR: Unable to add Netscape Base URL Extension");
  2052. }
  2053.     }
  2054.     if (find_field_bool(data, "netscape-revocation-url", PR_TRUE)) {
  2055. rv = add_IA5StringExtension(extHandle, 
  2056.     find_field(data, 
  2057.        "netscape-revocation-url-text", 
  2058.        PR_TRUE), 
  2059.     find_field_bool
  2060.        (data, "netscape-revocation-url-crit", 
  2061. PR_TRUE),
  2062.     SEC_OID_NS_CERT_EXT_REVOCATION_URL);
  2063. if (rv != SECSuccess) {
  2064.     error_out("ERROR: Unable to add Netscape Revocation URL Extension");
  2065. }
  2066.     }
  2067.     if (find_field_bool(data, "netscape-ca-revocation-url", PR_TRUE)) {
  2068. rv = add_IA5StringExtension(extHandle, 
  2069.     find_field(data, 
  2070.       "netscape-ca-revocation-url-text",
  2071.        PR_TRUE), 
  2072.     find_field_bool
  2073.         (data, "netscape-ca-revocation-url-crit"
  2074.  , PR_TRUE),
  2075.     SEC_OID_NS_CERT_EXT_CA_REVOCATION_URL);
  2076. if (rv != SECSuccess) {
  2077.     error_out("ERROR: Unable to add Netscape CA Revocation URL Extension");
  2078. }
  2079.     }
  2080.     if (find_field_bool(data, "netscape-cert-renewal-url", PR_TRUE)) {
  2081. rv = add_IA5StringExtension(extHandle, 
  2082.     find_field(data, 
  2083.        "netscape-cert-renewal-url-text",
  2084.        PR_TRUE), 
  2085.     find_field_bool
  2086.         (data, "netscape-cert-renewal-url-crit",
  2087.  PR_TRUE),
  2088.     SEC_OID_NS_CERT_EXT_CERT_RENEWAL_URL);
  2089. if (rv != SECSuccess) {
  2090.     error_out("ERROR: Unable to add Netscape Certificate Renewal URL Extension");
  2091. }
  2092.     }
  2093.     if (find_field_bool(data, "netscape-ca-policy-url", PR_TRUE)) {
  2094. rv = add_IA5StringExtension(extHandle, 
  2095.     find_field(data, 
  2096.        "netscape-ca-policy-url-text", 
  2097.        PR_TRUE), 
  2098.     find_field_bool
  2099.          (data, "netscape-ca-policy-url-crit", 
  2100.   PR_TRUE),
  2101.     SEC_OID_NS_CERT_EXT_CA_POLICY_URL);
  2102. if (rv != SECSuccess) {
  2103.     error_out("ERROR: Unable to add Netscape CA Policy URL Extension");
  2104. }
  2105.     }
  2106.     if (find_field_bool(data, "netscape-ssl-server-name", PR_TRUE)) {
  2107. rv = add_IA5StringExtension(extHandle, 
  2108.     find_field(data, 
  2109.        "netscape-ssl-server-name-text", 
  2110.        PR_TRUE), 
  2111.     find_field_bool
  2112.          (data, "netscape-ssl-server-name-crit",
  2113.   PR_TRUE),
  2114.     SEC_OID_NS_CERT_EXT_SSL_SERVER_NAME);
  2115. if (rv != SECSuccess) {
  2116.     error_out("ERROR: Unable to add Netscape SSL Server Name Extension");
  2117. }
  2118.     }
  2119.     if (find_field_bool(data, "netscape-comment", PR_TRUE)) {
  2120. rv = add_IA5StringExtension(extHandle, 
  2121.     find_field(data, "netscape-comment-text", 
  2122.        PR_TRUE), 
  2123.     find_field_bool(data, 
  2124.     "netscape-comment-crit", 
  2125.     PR_TRUE),
  2126.     SEC_OID_NS_CERT_EXT_COMMENT);
  2127. if (rv != SECSuccess) {
  2128.     error_out("ERROR: Unable to add Netscape Comment Extension");
  2129. }
  2130.     }
  2131.     CERT_FinishExtensions(extHandle);
  2132.     return (rv);
  2133. }
  2137. char *
  2138. return_dbpasswd(PK11SlotInfo *slot, PRBool retry, void *data)
  2139. {
  2140.     char *rv;
  2142.     /* don't clobber our poor smart card */
  2143.     if (retry == PR_TRUE) {
  2144. return NULL;
  2145.     }
  2146.     rv = PORT_Alloc(sizeof(char) * 4);
  2147.     PORT_Strcpy(rv, "foo");
  2148.     return rv;
  2149. }
  2152. SECKEYPrivateKey *
  2153. FindPrivateKeyFromNameStr(char              *name, 
  2154.   CERTCertDBHandle  *certHandle)
  2155. {
  2156.     SECKEYPrivateKey                        *key;
  2157.     CERTCertificate                         *cert;
  2158.     SECStatus                               status = SECSuccess;
  2161.     cert = CERT_FindCertByNameString(certHandle, name);
  2162.     if (cert == NULL) {
  2163. error_out("ERROR: Unable to retrieve issuers certificate");
  2164.     }
  2165.     key = PK11_FindKeyByAnyCert(cert, NULL);
  2166.     return key;
  2167. }
  2169. static SECItem *
  2170. SignCert(CERTCertificate   *cert,
  2171.  char              *issuerNameStr,
  2172.  Pair              *data,
  2173.  CERTCertDBHandle  *handle,
  2174.          int               which_key)
  2175. {
  2176.     SECItem                der;
  2177.     SECItem                *result = NULL;
  2178.     SECKEYPrivateKey       *caPrivateKey = NULL;
  2179.     SECStatus              rv;
  2180.     PRArenaPool            *arena;
  2181.     SECOidTag              algID;
  2183.     if (which_key == 0) {
  2184. caPrivateKey = FindPrivateKeyFromNameStr(issuerNameStr, handle); 
  2185.     } else {
  2186. caPrivateKey = privkeys[which_key - 1];
  2187.     }
  2188.     if (caPrivateKey == NULL) {
  2189. error_out("ERROR: unable to retrieve issuers key");
  2190.     }
  2192.     arena = cert->arena;
  2194.     switch(caPrivateKey->keyType) {
  2195.       case rsaKey:
  2196. algID = SEC_OID_PKCS1_MD5_WITH_RSA_ENCRYPTION;
  2197. break;
  2198.       case dsaKey:
  2199. algID = SEC_OID_ANSIX9_DSA_SIGNATURE_WITH_SHA1_DIGEST;
  2200. break;
  2201.       default:
  2202. error_out("ERROR: Unknown key type for issuer.");
  2203. goto done;
  2204. break;
  2205.     }
  2207.     rv = SECOID_SetAlgorithmID(arena, &cert->signature, algID, 0);
  2208.     if (rv != SECSuccess) {
  2209. error_out("ERROR: Could not set signature algorithm id.");
  2210.     }
  2212.     if (find_field_bool(data,"ver-1", PR_TRUE)) {
  2213. *(cert->version.data) = 0;
  2214. cert->version.len = 1;
  2215.     } else {
  2216. *(cert->version.data) = 2;
  2217. cert->version.len = 1;
  2218.     }
  2219.     der.data = NULL;
  2220.     der.len = 0;
  2221.     (void) SEC_ASN1EncodeItem (arena, &der, cert, CERT_CertificateTemplate);
  2222.     if (der.data == NULL) {
  2223. error_out("ERROR: Could not encode certificate.n");
  2224.     }
  2225.     rv = SEC_DerSignData (arena, &(cert->derCert), der.data, der.len, caPrivateKey,
  2226.   algID);
  2227.     if (rv != SECSuccess) {
  2228. error_out("ERROR: Could not sign encoded certificate data.n");
  2229.     }
  2230. done:
  2231.     SECKEY_DestroyPrivateKey(caPrivateKey);
  2232.     return &(cert->derCert);
  2233. }
  2236. void
  2237. main()
  2238. {
  2239.     int                    length = 500;
  2240.     int                    remaining = 500;
  2241.     int                    n;
  2242.     int                    fields = 3;
  2243.     int                    i;
  2244.     int                    serial;
  2245.     int                    chainLen;
  2246.     int                    which_key;
  2247.     char                   *pos;
  2248. #ifdef OFFLINE
  2249.     char                   *form_output = "key=MIIBPTCBpzCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEA7SLqjWBL9Wl11Vlg%0AaMqZCvcQOL%2FnvSqYPPRP0XZy9SoAeyWzQnBOiCm2t8H5mK7r2jnKdAQOmfhjaJil%0A3hNVu3SekHOXF6Ze7bkWa6%2FSGVcY%2FojkydxFSgY43nd1iydzPQDp8WWLL%2BpVpt%2B%2B%0ATRhFtVXbF0fQI03j9h3BoTgP2lkCAwEAARYDZm9vMA0GCSqGSIb3DQEBBAUAA4GB%0AAJ8UfRKJ0GtG%2B%2BufCC6tAfTzKrq3CTBHnom55EyXcsAsv6WbDqI%2F0rLAPkn2Xo1r%0AnNhtMxIuj441blMt%2Fa3AGLOy5zmC7Qawt8IytvQikQ1XTpTBCXevytrmLjCmlURr%0ANJryTM48WaMQHiMiJpbXCqVJC1d%2FpEWBtqvALzZaOOIy&subject=CN%3D%22test%22%26serial-auto%3Dtrue%26serial_value%3D%26ver-1%3Dtrue%26ver-3%3Dfalse%26caChoiceradio-SignWithDefaultkey%3Dtrue%26caChoiceradio-SignWithRandomChain%3Dfalse%26autoCAs%3D%26caChoiceradio-SignWithSpecifiedChain%3Dfalse%26manCAs%3D%26%24";
  2250. #else
  2251.     char                   *form_output;
  2252. #endif
  2253.     char                   *issuerNameStr;
  2254.     char                   *certName;
  2255.     char                   *DBdir = DB_DIRECTORY;
  2256.     char                   *prefixs[10] = {"CA#1-", "CA#2-", "CA#3-", 
  2257.    "CA#4-", "CA#5-", "CA#6-", 
  2258.    "CA#7-", "CA#8-", "CA#9-", ""};
  2259.     Pair                   *form_data;
  2260.     CERTCertificate        *cert;
  2261.     CERTCertDBHandle       *handle;
  2262.     CERTCertificateRequest *certReq = NULL;
  2263.     int                    warpmonths = 0;
  2264.     SECItem                *certDER;
  2265. #ifdef FILEOUT
  2266.     FILE                   *outfile;
  2267. #endif
  2268.     SECStatus              status = SECSuccess;
  2269.     extern                 char prefix[PREFIX_LEN];
  2270.     SEC_PKCS7ContentInfo   *certChain;
  2271.     SECItem                *encodedCertChain;
  2272.     PRBool                 UChain = PR_FALSE;
  2276. #ifdef TEST
  2277.     sleep(20);
  2278. #endif
  2279.     RNG_SystemInfoForRNG();
  2280.     SECU_ConfigDirectory(DBdir);
  2282.     PR_Init( PR_SYSTEM_THREAD, PR_PRIORITY_NORMAL, 1);
  2284.     SECU_PKCS11Init(PR_FALSE);     
  2285.     SEC_Init();
  2286.     PK11_SetPasswordFunc(return_dbpasswd);
  2287.     handle = NULL;
  2288.     handle = OpenCertDB();
  2289.     if (handle == NULL) {
  2290. error_out("Error: Unable to open certificate database");
  2291.     }
  2292.     prefix[0]= '';
  2293. #if !defined(OFFLINE)
  2294.     form_output = (char*) PORT_Alloc(length);
  2295.     if (form_output == NULL) {
  2296. error_allocate();
  2297.     }
  2298.     pos = form_output;
  2299.     while (feof(stdin) == 0 ) {
  2300. if (remaining <= 1) {
  2301.     remaining += length;
  2302.     length = length * 2;
  2303.     form_output = PORT_Realloc(form_output, (length));
  2304.     if (form_output == NULL) {
  2305. error_allocate();
  2306.     }
  2307.     pos = form_output + length - remaining;
  2308. }
  2309. n = fread(pos, sizeof(char), (size_t) (remaining - 1), stdin);
  2310. pos += n;
  2311. remaining -= n;
  2312.     }
  2313.     *pos = '&';
  2314.     pos++;
  2315.     length = pos - form_output;
  2316. #else
  2317.     length = PORT_Strlen(form_output);
  2318. #endif
  2319. #ifdef FILEOUT
  2320.     printf("Content-type: text/plainnn");
  2321.     fwrite(form_output, sizeof(char), (size_t)length, stdout);
  2322.     printf("n");
  2323. #endif
  2324. #ifdef FILEOUT
  2325.     fwrite(form_output, sizeof(char), (size_t)length, stdout);
  2326.     printf("n");
  2327.     fflush(stdout);
  2328. #endif
  2329.     form_data = make_datastruct(form_output, length);
  2330.     status = clean_input(form_data);
  2331. #if !defined(OFFLINE)
  2332.     PORT_Free(form_output);
  2333. #endif
  2334. #ifdef FILEOUT
  2335.     i = 0;
  2336.     while(return_name(form_data, i) != NULL) {
  2337.         printf("%s",return_name(form_data,i));
  2338.         printf("=n");
  2339.         printf("%s",return_data(form_data,i));
  2340.         printf("n");
  2341. i++;
  2342.     }
  2343.     printf("I got that done, woo hoon");
  2344.     fflush(stdout);
  2345. #endif
  2346.     issuerNameStr = PORT_Alloc(35 * sizeof(char));
  2347.     if (find_field_bool(form_data, "caChoiceradio-SignWithSpecifiedChain",
  2348. PR_FALSE)) {
  2349. UChain = PR_TRUE;
  2350. chainLen = atoi(find_field(form_data, "manCAs", PR_FALSE));
  2351. PORT_Strcpy(prefix, prefixs[0]);
  2352. issuerNameStr = PORT_Strcpy(issuerNameStr,
  2353.        "CN=Cert-O-Matic II, O=Cert-O-Matic II");
  2354. if (chainLen == 0) {
  2355.     UChain =  PR_FALSE;
  2356. }
  2357.     } else {
  2358. if (find_field_bool(form_data, "caChoiceradio-SignWithRandomChain", 
  2359.     PR_FALSE)) {
  2360.     PORT_Strcpy(prefix,prefixs[9]);
  2361.     chainLen = atoi(find_field(form_data, "autoCAs", PR_FALSE));
  2362.     if (chainLen < 1 || chainLen > 18) {
  2363. issuerNameStr = PORT_Strcpy(issuerNameStr, 
  2364.        "CN=CA18, O=Cert-O-Matic II");
  2365.     }
  2366.     issuerNameStr = PORT_Strcpy(issuerNameStr, "CN=CA");
  2367.     issuerNameStr = PORT_Strcat(issuerNameStr, 
  2368.    find_field(form_data,"autoCAs", PR_FALSE));
  2369.     issuerNameStr = PORT_Strcat(issuerNameStr,", O=Cert-O-Matic II");
  2370. } else {
  2371.     issuerNameStr = PORT_Strcpy(issuerNameStr, 
  2372.    "CN=Cert-O-Matic II, O=Cert-O-Matic II");
  2373. }
  2374. chainLen = 0;
  2375.     }
  2377.     i = -1;
  2378.     which_key = 0;
  2379.     do {
  2380.      extern SECStatus cert_GetKeyID(CERTCertificate *cert);
  2381. i++;
  2382. if (i != 0 && UChain) {
  2383.     PORT_Strcpy(prefix, prefixs[i]);
  2384. }
  2385. /*        find_field(form_data,"subject", PR_TRUE); */
  2386. certReq = makeCertReq(form_data, which_key);
  2387. #ifdef OFFLINE
  2388. serial = 900;
  2389. #else
  2390. serial = get_serial_number(form_data);
  2391. #endif
  2392. cert = MakeV1Cert(handle, certReq, issuerNameStr, PR_FALSE, 
  2393.   serial, warpmonths, form_data);
  2394. if (certReq != NULL) {
  2395.     CERT_DestroyCertificateRequest(certReq);
  2396. }
  2397. if (find_field_bool(form_data,"ver-3", PR_TRUE)) {
  2398.     status = add_extensions(cert, form_data, issuerNameStr, handle);
  2399.     if (status != SECSuccess) {
  2400. error_out("ERROR: Unable to add extensions");
  2401.     }
  2402. }
  2403. status = cert_GetKeyID(cert);
  2404. if (status == SECFailure) {
  2405.     error_out("ERROR: Unable to get Key ID.");
  2406. }
  2407. certDER = SignCert(cert, issuerNameStr, form_data, handle, which_key);
  2408. CERT_NewTempCertificate(handle, certDER, NULL, PR_FALSE, PR_TRUE);
  2409. issuerNameStr = find_field(form_data, "subject", PR_TRUE);
  2410. /*        SECITEM_FreeItem(certDER, PR_TRUE); */
  2411. CERT_DestroyCertificate(cert);
  2412. if (i == (chainLen - 1)) {
  2413.     i = 8;
  2414. }
  2415. ++which_key;
  2416.     } while (i < 9 && UChain);
  2420. #ifdef FILEOUT
  2421.     outfile = fopen("../certout", "wb");
  2422. #endif
  2423.     certName = find_field(form_data, "subject", PR_FALSE);
  2424.     cert = CERT_FindCertByNameString(handle, certName);
  2425.     certChain = SEC_PKCS7CreateCertsOnly (cert, PR_TRUE, handle);
  2426.     if (certChain == NULL) {
  2427. error_out("ERROR: No certificates in cert chain");
  2428.     }
  2429.     encodedCertChain = SEC_PKCS7EncodeItem (NULL, NULL, certChain, NULL, NULL, 
  2430.     NULL);
  2431.     if (encodedCertChain) {
  2432. #if !defined(FILEOUT)
  2433. printf("Content-type: application/x-x509-user-certnn");
  2434. fwrite (encodedCertChain->data, 1, encodedCertChain->len, stdout);
  2435. #else
  2436. fwrite (encodedCertChain->data, 1, encodedCertChain->len, outfile);
  2437. #endif
  2439.     } else {
  2440. error_out("Error: Unable to DER encode certificate");
  2441.     }
  2442. #ifdef FILEOUT
  2443.     printf("nI got here!n");
  2444.     fflush(outfile);
  2445.     fclose(outfile);
  2446. #endif
  2447.     fflush(stdout);
  2448.     return;
  2449. }