Reject empty generation strings.
[openssl.git] / apps / ca.c
1 /* apps/ca.c */
2 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
3  * All rights reserved.
4  *
5  * This package is an SSL implementation written
6  * by Eric Young (eay@cryptsoft.com).
7  * The implementation was written so as to conform with Netscapes SSL.
8  *
9  * This library is free for commercial and non-commercial use as long as
10  * the following conditions are aheared to.  The following conditions
11  * apply to all code found in this distribution, be it the RC4, RSA,
12  * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
13  * included with this distribution is covered by the same copyright terms
14  * except that the holder is Tim Hudson (tjh@cryptsoft.com).
15  *
16  * Copyright remains Eric Young's, and as such any Copyright notices in
17  * the code are not to be removed.
18  * If this package is used in a product, Eric Young should be given attribution
19  * as the author of the parts of the library used.
20  * This can be in the form of a textual message at program startup or
21  * in documentation (online or textual) provided with the package.
22  *
23  * Redistribution and use in source and binary forms, with or without
24  * modification, are permitted provided that the following conditions
25  * are met:
26  * 1. Redistributions of source code must retain the copyright
27  *    notice, this list of conditions and the following disclaimer.
28  * 2. Redistributions in binary form must reproduce the above copyright
29  *    notice, this list of conditions and the following disclaimer in the
30  *    documentation and/or other materials provided with the distribution.
31  * 3. All advertising materials mentioning features or use of this software
32  *    must display the following acknowledgement:
33  *    "This product includes cryptographic software written by
34  *     Eric Young (eay@cryptsoft.com)"
35  *    The word 'cryptographic' can be left out if the rouines from the library
36  *    being used are not cryptographic related :-).
37  * 4. If you include any Windows specific code (or a derivative thereof) from
38  *    the apps directory (application code) you must include an acknowledgement:
39  *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
40  *
41  * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
42  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
43  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
44  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
45  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
46  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
47  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
48  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
49  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
50  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
51  * SUCH DAMAGE.
52  *
53  * The licence and distribution terms for any publically available version or
54  * derivative of this code cannot be changed.  i.e. this code cannot simply be
55  * copied and put under another distribution licence
56  * [including the GNU Public Licence.]
57  */
58
59 /* The PPKI stuff has been donated by Jeff Barber <jeffb@issl.atl.hp.com> */
60
61 #include <stdio.h>
62 #include <stdlib.h>
63 #include <string.h>
64 #include <ctype.h>
65 #include <sys/types.h>
66 #include <openssl/conf.h>
67 #include <openssl/bio.h>
68 #include <openssl/err.h>
69 #include <openssl/bn.h>
70 #include <openssl/txt_db.h>
71 #include <openssl/evp.h>
72 #include <openssl/x509.h>
73 #include <openssl/x509v3.h>
74 #include <openssl/objects.h>
75 #include <openssl/ocsp.h>
76 #include <openssl/pem.h>
77
78 #ifndef W_OK
79 # ifdef OPENSSL_SYS_VMS
80 #  if defined(__DECC)
81 #   include <unistd.h>
82 #  else
83 #   include <unixlib.h>
84 #  endif
85 # elif !defined(OPENSSL_SYS_VXWORKS) && !defined(OPENSSL_SYS_WINDOWS) && !defined(OPENSSL_SYS_NETWARE)
86 #  include <sys/file.h>
87 # endif
88 #endif
89
90 #include "apps.h"
91
92 #ifndef W_OK
93 # define F_OK 0
94 # define X_OK 1
95 # define W_OK 2
96 # define R_OK 4
97 #endif
98
99 #undef PROG
100 #define PROG ca_main
101
102 #define BASE_SECTION    "ca"
103 #define CONFIG_FILE "openssl.cnf"
104
105 #define ENV_DEFAULT_CA          "default_ca"
106
107 #define STRING_MASK     "string_mask"
108 #define UTF8_IN                 "utf8"
109
110 #define ENV_DIR                 "dir"
111 #define ENV_CERTS               "certs"
112 #define ENV_CRL_DIR             "crl_dir"
113 #define ENV_CA_DB               "CA_DB"
114 #define ENV_NEW_CERTS_DIR       "new_certs_dir"
115 #define ENV_CERTIFICATE         "certificate"
116 #define ENV_SERIAL              "serial"
117 #define ENV_CRLNUMBER           "crlnumber"
118 #define ENV_CRL                 "crl"
119 #define ENV_PRIVATE_KEY         "private_key"
120 #define ENV_RANDFILE            "RANDFILE"
121 #define ENV_DEFAULT_DAYS        "default_days"
122 #define ENV_DEFAULT_STARTDATE   "default_startdate"
123 #define ENV_DEFAULT_ENDDATE     "default_enddate"
124 #define ENV_DEFAULT_CRL_DAYS    "default_crl_days"
125 #define ENV_DEFAULT_CRL_HOURS   "default_crl_hours"
126 #define ENV_DEFAULT_MD          "default_md"
127 #define ENV_DEFAULT_EMAIL_DN    "email_in_dn"
128 #define ENV_PRESERVE            "preserve"
129 #define ENV_POLICY              "policy"
130 #define ENV_EXTENSIONS          "x509_extensions"
131 #define ENV_CRLEXT              "crl_extensions"
132 #define ENV_MSIE_HACK           "msie_hack"
133 #define ENV_NAMEOPT             "name_opt"
134 #define ENV_CERTOPT             "cert_opt"
135 #define ENV_EXTCOPY             "copy_extensions"
136 #define ENV_UNIQUE_SUBJECT      "unique_subject"
137
138 #define ENV_DATABASE            "database"
139
140 /* Additional revocation information types */
141
142 #define REV_NONE                0 /* No addditional information */
143 #define REV_CRL_REASON          1 /* Value is CRL reason code */
144 #define REV_HOLD                2 /* Value is hold instruction */
145 #define REV_KEY_COMPROMISE      3 /* Value is cert key compromise time */
146 #define REV_CA_COMPROMISE       4 /* Value is CA key compromise time */
147
148 static const char *ca_usage[] = {
149     "usage: ca args\n",
150     "\n",
151     " -verbose        - Talk alot while doing things\n",
152     " -config file    - A config file\n",
153     " -name arg       - The particular CA definition to use\n",
154     " -gencrl         - Generate a new CRL\n",
155     " -crldays days   - Days is when the next CRL is due\n",
156     " -crlhours hours - Hours is when the next CRL is due\n",
157     " -startdate YYMMDDHHMMSSZ  - certificate validity notBefore\n",
158     " -enddate YYMMDDHHMMSSZ    - certificate validity notAfter (overrides -days)\n",
159     " -days arg       - number of days to certify the certificate for\n",
160     " -md arg         - md to use, one of md2, md5, sha or sha1\n",
161     " -policy arg     - The CA 'policy' to support\n",
162     " -keyfile arg    - private key file\n",
163     " -keyform arg    - private key file format (PEM or ENGINE)\n",
164     " -key arg        - key to decode the private key if it is encrypted\n",
165     " -cert file      - The CA certificate\n",
166     " -selfsign       - sign a certificate with the key associated with it\n",
167     " -in file        - The input PEM encoded certificate request(s)\n",
168     " -out file       - Where to put the output file(s)\n",
169     " -outdir dir     - Where to put output certificates\n",
170     " -infiles ....   - The last argument, requests to process\n",
171     " -spkac file     - File contains DN and signed public key and challenge\n",
172     " -ss_cert file   - File contains a self signed cert to sign\n",
173     " -preserveDN     - Don't re-order the DN\n",
174     " -noemailDN      - Don't add the EMAIL field into certificate' subject\n",
175     " -batch          - Don't ask questions\n",
176     " -msie_hack      - msie modifications to handle all those universal strings\n",
177     " -revoke file    - Revoke a certificate (given in file)\n",
178     " -subj arg       - Use arg instead of request's subject\n",
179     " -utf8           - input characters are UTF8 (default ASCII)\n",
180     " -multivalue-rdn - enable support for multivalued RDNs\n",
181     " -extensions ..  - Extension section (override value in config file)\n",
182     " -extfile file   - Configuration file with X509v3 extentions to add\n",
183     " -crlexts ..     - CRL extension section (override value in config file)\n",
184 #ifndef OPENSSL_NO_ENGINE
185     " -engine e       - use engine e, possibly a hardware device.\n",
186 #endif
187     " -status serial  - Shows certificate status given the serial number\n",
188     " -updatedb       - Updates db for expired certificates\n",
189     NULL
190 };
191
192 #ifdef EFENCE
193 extern int EF_PROTECT_FREE;
194 extern int EF_PROTECT_BELOW;
195 extern int EF_ALIGNMENT;
196 #endif
197
198 static void lookup_fail(const char *name, const char *tag);
199 static int certify(X509 **xret, char *infile, EVP_PKEY *pkey, X509 *x509,
200                    const EVP_MD *dgst, STACK_OF(OPENSSL_STRING) *sigopts,
201                    STACK_OF(CONF_VALUE) *policy, CA_DB *db,
202                    BIGNUM *serial, char *subj, unsigned long chtype,
203                    int multirdn, int email_dn, char *startdate, char *enddate,
204                    long days, int batch, char *ext_sect, CONF *conf,
205                    int verbose, unsigned long certopt, unsigned long nameopt,
206                    int default_op, int ext_copy, int selfsign);
207 static int certify_cert(X509 **xret, char *infile, EVP_PKEY *pkey, X509 *x509,
208                         const EVP_MD *dgst, STACK_OF(OPENSSL_STRING) *sigopts,
209                         STACK_OF(CONF_VALUE) *policy, CA_DB *db,
210                         BIGNUM *serial, char *subj, unsigned long chtype,
211                         int multirdn, int email_dn, char *startdate,
212                         char *enddate, long days, int batch, char *ext_sect,
213                         CONF *conf, int verbose, unsigned long certopt,
214                         unsigned long nameopt, int default_op, int ext_copy,
215                         ENGINE *e);
216 static int certify_spkac(X509 **xret, char *infile, EVP_PKEY *pkey,
217                          X509 *x509, const EVP_MD *dgst,
218                          STACK_OF(OPENSSL_STRING) *sigopts,
219                          STACK_OF(CONF_VALUE) *policy, CA_DB *db,
220                          BIGNUM *serial, char *subj, unsigned long chtype,
221                          int multirdn, int email_dn, char *startdate,
222                          char *enddate, long days, char *ext_sect, CONF *conf,
223                          int verbose, unsigned long certopt,
224                          unsigned long nameopt, int default_op, int ext_copy);
225 static void write_new_certificate(BIO *bp, X509 *x, int output_der,
226                                   int notext);
227 static int do_body(X509 **xret, EVP_PKEY *pkey, X509 *x509,
228                    const EVP_MD *dgst, STACK_OF(OPENSSL_STRING) *sigopts,
229                    STACK_OF(CONF_VALUE) *policy, CA_DB *db, BIGNUM *serial,
230                    char *subj, unsigned long chtype, int multirdn,
231                    int email_dn, char *startdate, char *enddate, long days,
232                    int batch, int verbose, X509_REQ *req, char *ext_sect,
233                    CONF *conf, unsigned long certopt, unsigned long nameopt,
234                    int default_op, int ext_copy, int selfsign);
235 static int do_revoke(X509 *x509, CA_DB *db, int ext, char *extval);
236 static int get_certificate_status(const char *ser_status, CA_DB *db);
237 static int do_updatedb(CA_DB *db);
238 static int check_time_format(const char *str);
239 char *make_revocation_str(int rev_type, char *rev_arg);
240 int make_revoked(X509_REVOKED *rev, const char *str);
241 int old_entry_print(BIO *bp, ASN1_OBJECT *obj, ASN1_STRING *str);
242 static CONF *conf = NULL;
243 static CONF *extconf = NULL;
244 static char *section = NULL;
245
246 static int preserve = 0;
247 static int msie_hack = 0;
248
249 int MAIN(int, char **);
250
251 int MAIN(int argc, char **argv)
252 {
253     ENGINE *e = NULL;
254     char *key = NULL, *passargin = NULL;
255     int create_ser = 0;
256     int free_key = 0;
257     int total = 0;
258     int total_done = 0;
259     int badops = 0;
260     int ret = 1;
261     int email_dn = 1;
262     int req = 0;
263     int verbose = 0;
264     int gencrl = 0;
265     int dorevoke = 0;
266     int doupdatedb = 0;
267     long crldays = 0;
268     long crlhours = 0;
269     long crlsec = 0;
270     long errorline = -1;
271     char *configfile = NULL;
272     char *md = NULL;
273     char *policy = NULL;
274     char *keyfile = NULL;
275     char *certfile = NULL;
276     int keyform = FORMAT_PEM;
277     char *infile = NULL;
278     char *spkac_file = NULL;
279     char *ss_cert_file = NULL;
280     char *ser_status = NULL;
281     EVP_PKEY *pkey = NULL;
282     int output_der = 0;
283     char *outfile = NULL;
284     char *outdir = NULL;
285     char *serialfile = NULL;
286     char *crlnumberfile = NULL;
287     char *extensions = NULL;
288     char *extfile = NULL;
289     char *subj = NULL;
290     unsigned long chtype = MBSTRING_ASC;
291     int multirdn = 0;
292     char *tmp_email_dn = NULL;
293     char *crl_ext = NULL;
294     int rev_type = REV_NONE;
295     char *rev_arg = NULL;
296     BIGNUM *serial = NULL;
297     BIGNUM *crlnumber = NULL;
298     char *startdate = NULL;
299     char *enddate = NULL;
300     long days = 0;
301     int batch = 0;
302     int notext = 0;
303     unsigned long nameopt = 0, certopt = 0;
304     int default_op = 1;
305     int ext_copy = EXT_COPY_NONE;
306     int selfsign = 0;
307     X509 *x509 = NULL, *x509p = NULL;
308     X509 *x = NULL;
309     BIO *in = NULL, *out = NULL, *Sout = NULL, *Cout = NULL;
310     char *dbfile = NULL;
311     CA_DB *db = NULL;
312     X509_CRL *crl = NULL;
313     X509_REVOKED *r = NULL;
314     ASN1_TIME *tmptm;
315     ASN1_INTEGER *tmpser;
316     char *f;
317     const char *p;
318     char *const *pp;
319     int i, j;
320     const EVP_MD *dgst = NULL;
321     STACK_OF(CONF_VALUE) *attribs = NULL;
322     STACK_OF(X509) *cert_sk = NULL;
323     STACK_OF(OPENSSL_STRING) *sigopts = NULL;
324 #undef BSIZE
325 #define BSIZE 256
326     MS_STATIC char buf[3][BSIZE];
327     char *randfile = NULL;
328 #ifndef OPENSSL_NO_ENGINE
329     char *engine = NULL;
330 #endif
331     char *tofree = NULL;
332     DB_ATTR db_attr;
333
334 #ifdef EFENCE
335     EF_PROTECT_FREE = 1;
336     EF_PROTECT_BELOW = 1;
337     EF_ALIGNMENT = 0;
338 #endif
339
340     apps_startup();
341
342     conf = NULL;
343     key = NULL;
344     section = NULL;
345
346     preserve = 0;
347     msie_hack = 0;
348     if (bio_err == NULL)
349         if ((bio_err = BIO_new(BIO_s_file())) != NULL)
350             BIO_set_fp(bio_err, stderr, BIO_NOCLOSE | BIO_FP_TEXT);
351
352     argc--;
353     argv++;
354     while (argc >= 1) {
355         if (strcmp(*argv, "-verbose") == 0)
356             verbose = 1;
357         else if (strcmp(*argv, "-config") == 0) {
358             if (--argc < 1)
359                 goto bad;
360             configfile = *(++argv);
361         } else if (strcmp(*argv, "-name") == 0) {
362             if (--argc < 1)
363                 goto bad;
364             section = *(++argv);
365         } else if (strcmp(*argv, "-subj") == 0) {
366             if (--argc < 1)
367                 goto bad;
368             subj = *(++argv);
369             /* preserve=1; */
370         } else if (strcmp(*argv, "-utf8") == 0)
371             chtype = MBSTRING_UTF8;
372         else if (strcmp(*argv, "-create_serial") == 0)
373             create_ser = 1;
374         else if (strcmp(*argv, "-multivalue-rdn") == 0)
375             multirdn = 1;
376         else if (strcmp(*argv, "-startdate") == 0) {
377             if (--argc < 1)
378                 goto bad;
379             startdate = *(++argv);
380         } else if (strcmp(*argv, "-enddate") == 0) {
381             if (--argc < 1)
382                 goto bad;
383             enddate = *(++argv);
384         } else if (strcmp(*argv, "-days") == 0) {
385             if (--argc < 1)
386                 goto bad;
387             days = atoi(*(++argv));
388         } else if (strcmp(*argv, "-md") == 0) {
389             if (--argc < 1)
390                 goto bad;
391             md = *(++argv);
392         } else if (strcmp(*argv, "-policy") == 0) {
393             if (--argc < 1)
394                 goto bad;
395             policy = *(++argv);
396         } else if (strcmp(*argv, "-keyfile") == 0) {
397             if (--argc < 1)
398                 goto bad;
399             keyfile = *(++argv);
400         } else if (strcmp(*argv, "-keyform") == 0) {
401             if (--argc < 1)
402                 goto bad;
403             keyform = str2fmt(*(++argv));
404         } else if (strcmp(*argv, "-passin") == 0) {
405             if (--argc < 1)
406                 goto bad;
407             passargin = *(++argv);
408         } else if (strcmp(*argv, "-key") == 0) {
409             if (--argc < 1)
410                 goto bad;
411             key = *(++argv);
412         } else if (strcmp(*argv, "-cert") == 0) {
413             if (--argc < 1)
414                 goto bad;
415             certfile = *(++argv);
416         } else if (strcmp(*argv, "-selfsign") == 0)
417             selfsign = 1;
418         else if (strcmp(*argv, "-in") == 0) {
419             if (--argc < 1)
420                 goto bad;
421             infile = *(++argv);
422             req = 1;
423         } else if (strcmp(*argv, "-out") == 0) {
424             if (--argc < 1)
425                 goto bad;
426             outfile = *(++argv);
427         } else if (strcmp(*argv, "-outdir") == 0) {
428             if (--argc < 1)
429                 goto bad;
430             outdir = *(++argv);
431         } else if (strcmp(*argv, "-sigopt") == 0) {
432             if (--argc < 1)
433                 goto bad;
434             if (!sigopts)
435                 sigopts = sk_OPENSSL_STRING_new_null();
436             if (!sigopts || !sk_OPENSSL_STRING_push(sigopts, *(++argv)))
437                 goto bad;
438         } else if (strcmp(*argv, "-notext") == 0)
439             notext = 1;
440         else if (strcmp(*argv, "-batch") == 0)
441             batch = 1;
442         else if (strcmp(*argv, "-preserveDN") == 0)
443             preserve = 1;
444         else if (strcmp(*argv, "-noemailDN") == 0)
445             email_dn = 0;
446         else if (strcmp(*argv, "-gencrl") == 0)
447             gencrl = 1;
448         else if (strcmp(*argv, "-msie_hack") == 0)
449             msie_hack = 1;
450         else if (strcmp(*argv, "-crldays") == 0) {
451             if (--argc < 1)
452                 goto bad;
453             crldays = atol(*(++argv));
454         } else if (strcmp(*argv, "-crlhours") == 0) {
455             if (--argc < 1)
456                 goto bad;
457             crlhours = atol(*(++argv));
458         } else if (strcmp(*argv, "-crlsec") == 0) {
459             if (--argc < 1)
460                 goto bad;
461             crlsec = atol(*(++argv));
462         } else if (strcmp(*argv, "-infiles") == 0) {
463             argc--;
464             argv++;
465             req = 1;
466             break;
467         } else if (strcmp(*argv, "-ss_cert") == 0) {
468             if (--argc < 1)
469                 goto bad;
470             ss_cert_file = *(++argv);
471             req = 1;
472         } else if (strcmp(*argv, "-spkac") == 0) {
473             if (--argc < 1)
474                 goto bad;
475             spkac_file = *(++argv);
476             req = 1;
477         } else if (strcmp(*argv, "-revoke") == 0) {
478             if (--argc < 1)
479                 goto bad;
480             infile = *(++argv);
481             dorevoke = 1;
482         } else if (strcmp(*argv, "-extensions") == 0) {
483             if (--argc < 1)
484                 goto bad;
485             extensions = *(++argv);
486         } else if (strcmp(*argv, "-extfile") == 0) {
487             if (--argc < 1)
488                 goto bad;
489             extfile = *(++argv);
490         } else if (strcmp(*argv, "-status") == 0) {
491             if (--argc < 1)
492                 goto bad;
493             ser_status = *(++argv);
494         } else if (strcmp(*argv, "-updatedb") == 0) {
495             doupdatedb = 1;
496         } else if (strcmp(*argv, "-crlexts") == 0) {
497             if (--argc < 1)
498                 goto bad;
499             crl_ext = *(++argv);
500         } else if (strcmp(*argv, "-crl_reason") == 0) {
501             if (--argc < 1)
502                 goto bad;
503             rev_arg = *(++argv);
504             rev_type = REV_CRL_REASON;
505         } else if (strcmp(*argv, "-crl_hold") == 0) {
506             if (--argc < 1)
507                 goto bad;
508             rev_arg = *(++argv);
509             rev_type = REV_HOLD;
510         } else if (strcmp(*argv, "-crl_compromise") == 0) {
511             if (--argc < 1)
512                 goto bad;
513             rev_arg = *(++argv);
514             rev_type = REV_KEY_COMPROMISE;
515         } else if (strcmp(*argv, "-crl_CA_compromise") == 0) {
516             if (--argc < 1)
517                 goto bad;
518             rev_arg = *(++argv);
519             rev_type = REV_CA_COMPROMISE;
520         }
521 #ifndef OPENSSL_NO_ENGINE
522         else if (strcmp(*argv, "-engine") == 0) {
523             if (--argc < 1)
524                 goto bad;
525             engine = *(++argv);
526         }
527 #endif
528         else {
529  bad:
530             BIO_printf(bio_err, "unknown option %s\n", *argv);
531             badops = 1;
532             break;
533         }
534         argc--;
535         argv++;
536     }
537
538     if (badops) {
539         const char **pp2;
540
541         for (pp2 = ca_usage; (*pp2 != NULL); pp2++)
542             BIO_printf(bio_err, "%s", *pp2);
543         goto err;
544     }
545
546     ERR_load_crypto_strings();
547
548         /*****************************************************************/
549     tofree = NULL;
550     if (configfile == NULL)
551         configfile = getenv("OPENSSL_CONF");
552     if (configfile == NULL)
553         configfile = getenv("SSLEAY_CONF");
554     if (configfile == NULL) {
555         const char *s = X509_get_default_cert_area();
556         size_t len;
557
558 #ifdef OPENSSL_SYS_VMS
559         len = strlen(s) + sizeof(CONFIG_FILE);
560         tofree = OPENSSL_malloc(len);
561         if(!tofree) {
562             BIO_printf(bio_err, "Out of memory\n");
563             goto err;
564         }
565         strcpy(tofree, s);
566 #else
567         len = strlen(s) + sizeof(CONFIG_FILE) + 1;
568         tofree = OPENSSL_malloc(len);
569         if(!tofree) {
570             BIO_printf(bio_err, "Out of memory\n");
571             goto err;
572         }
573         BUF_strlcpy(tofree, s, len);
574         BUF_strlcat(tofree, "/", len);
575 #endif
576         BUF_strlcat(tofree, CONFIG_FILE, len);
577         configfile = tofree;
578     }
579
580     BIO_printf(bio_err, "Using configuration from %s\n", configfile);
581     conf = NCONF_new(NULL);
582     if (NCONF_load(conf, configfile, &errorline) <= 0) {
583         if (errorline <= 0)
584             BIO_printf(bio_err, "error loading the config file '%s'\n",
585                        configfile);
586         else
587             BIO_printf(bio_err, "error on line %ld of config file '%s'\n",
588                        errorline, configfile);
589         goto err;
590     }
591     if (tofree) {
592         OPENSSL_free(tofree);
593         tofree = NULL;
594     }
595
596     if (!load_config(bio_err, conf))
597         goto err;
598
599 #ifndef OPENSSL_NO_ENGINE
600     e = setup_engine(bio_err, engine, 0);
601 #endif
602
603     /* Lets get the config section we are using */
604     if (section == NULL) {
605         section = NCONF_get_string(conf, BASE_SECTION, ENV_DEFAULT_CA);
606         if (section == NULL) {
607             lookup_fail(BASE_SECTION, ENV_DEFAULT_CA);
608             goto err;
609         }
610     }
611
612     if (conf != NULL) {
613         p = NCONF_get_string(conf, NULL, "oid_file");
614         if (p == NULL)
615             ERR_clear_error();
616         if (p != NULL) {
617             BIO *oid_bio;
618
619             oid_bio = BIO_new_file(p, "r");
620             if (oid_bio == NULL) {
621                 /*-
622                 BIO_printf(bio_err,"problems opening %s for extra oid's\n",p);
623                 ERR_print_errors(bio_err);
624                 */
625                 ERR_clear_error();
626             } else {
627                 OBJ_create_objects(oid_bio);
628                 BIO_free(oid_bio);
629             }
630         }
631         if (!add_oid_section(bio_err, conf)) {
632             ERR_print_errors(bio_err);
633             goto err;
634         }
635     }
636
637     randfile = NCONF_get_string(conf, BASE_SECTION, "RANDFILE");
638     if (randfile == NULL)
639         ERR_clear_error();
640     app_RAND_load_file(randfile, bio_err, 0);
641
642     f = NCONF_get_string(conf, section, STRING_MASK);
643     if (!f)
644         ERR_clear_error();
645
646     if (f && !ASN1_STRING_set_default_mask_asc(f)) {
647         BIO_printf(bio_err, "Invalid global string mask setting %s\n", f);
648         goto err;
649     }
650
651     if (chtype != MBSTRING_UTF8) {
652         f = NCONF_get_string(conf, section, UTF8_IN);
653         if (!f)
654             ERR_clear_error();
655         else if (!strcmp(f, "yes"))
656             chtype = MBSTRING_UTF8;
657     }
658
659     db_attr.unique_subject = 1;
660     p = NCONF_get_string(conf, section, ENV_UNIQUE_SUBJECT);
661     if (p) {
662 #ifdef RL_DEBUG
663         BIO_printf(bio_err, "DEBUG: unique_subject = \"%s\"\n", p);
664 #endif
665         db_attr.unique_subject = parse_yesno(p, 1);
666     } else
667         ERR_clear_error();
668 #ifdef RL_DEBUG
669     if (!p)
670         BIO_printf(bio_err, "DEBUG: unique_subject undefined\n");
671 #endif
672 #ifdef RL_DEBUG
673     BIO_printf(bio_err, "DEBUG: configured unique_subject is %d\n",
674                db_attr.unique_subject);
675 #endif
676
677     in = BIO_new(BIO_s_file());
678     out = BIO_new(BIO_s_file());
679     Sout = BIO_new(BIO_s_file());
680     Cout = BIO_new(BIO_s_file());
681     if ((in == NULL) || (out == NULL) || (Sout == NULL) || (Cout == NULL)) {
682         ERR_print_errors(bio_err);
683         goto err;
684     }
685
686         /*****************************************************************/
687     /* report status of cert with serial number given on command line */
688     if (ser_status) {
689         if ((dbfile = NCONF_get_string(conf, section, ENV_DATABASE)) == NULL) {
690             lookup_fail(section, ENV_DATABASE);
691             goto err;
692         }
693         db = load_index(dbfile, &db_attr);
694         if (db == NULL)
695             goto err;
696
697         if (!index_index(db))
698             goto err;
699
700         if (get_certificate_status(ser_status, db) != 1)
701             BIO_printf(bio_err, "Error verifying serial %s!\n", ser_status);
702         goto err;
703     }
704
705         /*****************************************************************/
706     /* we definitely need a private key, so let's get it */
707
708     if ((keyfile == NULL) && ((keyfile = NCONF_get_string(conf,
709                                                           section,
710                                                           ENV_PRIVATE_KEY)) ==
711                               NULL)) {
712         lookup_fail(section, ENV_PRIVATE_KEY);
713         goto err;
714     }
715     if (!key) {
716         free_key = 1;
717         if (!app_passwd(bio_err, passargin, NULL, &key, NULL)) {
718             BIO_printf(bio_err, "Error getting password\n");
719             goto err;
720         }
721     }
722     pkey = load_key(bio_err, keyfile, keyform, 0, key, e, "CA private key");
723     if (key)
724         OPENSSL_cleanse(key, strlen(key));
725     if (pkey == NULL) {
726         /* load_key() has already printed an appropriate message */
727         goto err;
728     }
729
730         /*****************************************************************/
731     /* we need a certificate */
732     if (!selfsign || spkac_file || ss_cert_file || gencrl) {
733         if ((certfile == NULL)
734             && ((certfile = NCONF_get_string(conf,
735                                              section,
736                                              ENV_CERTIFICATE)) == NULL)) {
737             lookup_fail(section, ENV_CERTIFICATE);
738             goto err;
739         }
740         x509 = load_cert(bio_err, certfile, FORMAT_PEM, NULL, e,
741                          "CA certificate");
742         if (x509 == NULL)
743             goto err;
744
745         if (!X509_check_private_key(x509, pkey)) {
746             BIO_printf(bio_err,
747                        "CA certificate and CA private key do not match\n");
748             goto err;
749         }
750     }
751     if (!selfsign)
752         x509p = x509;
753
754     f = NCONF_get_string(conf, BASE_SECTION, ENV_PRESERVE);
755     if (f == NULL)
756         ERR_clear_error();
757     if ((f != NULL) && ((*f == 'y') || (*f == 'Y')))
758         preserve = 1;
759     f = NCONF_get_string(conf, BASE_SECTION, ENV_MSIE_HACK);
760     if (f == NULL)
761         ERR_clear_error();
762     if ((f != NULL) && ((*f == 'y') || (*f == 'Y')))
763         msie_hack = 1;
764
765     f = NCONF_get_string(conf, section, ENV_NAMEOPT);
766
767     if (f) {
768         if (!set_name_ex(&nameopt, f)) {
769             BIO_printf(bio_err, "Invalid name options: \"%s\"\n", f);
770             goto err;
771         }
772         default_op = 0;
773     } else
774         ERR_clear_error();
775
776     f = NCONF_get_string(conf, section, ENV_CERTOPT);
777
778     if (f) {
779         if (!set_cert_ex(&certopt, f)) {
780             BIO_printf(bio_err, "Invalid certificate options: \"%s\"\n", f);
781             goto err;
782         }
783         default_op = 0;
784     } else
785         ERR_clear_error();
786
787     f = NCONF_get_string(conf, section, ENV_EXTCOPY);
788
789     if (f) {
790         if (!set_ext_copy(&ext_copy, f)) {
791             BIO_printf(bio_err, "Invalid extension copy option: \"%s\"\n", f);
792             goto err;
793         }
794     } else
795         ERR_clear_error();
796
797         /*****************************************************************/
798     /* lookup where to write new certificates */
799     if ((outdir == NULL) && (req)) {
800
801         if ((outdir = NCONF_get_string(conf, section, ENV_NEW_CERTS_DIR))
802             == NULL) {
803             BIO_printf(bio_err,
804                        "there needs to be defined a directory for new certificate to be placed in\n");
805             goto err;
806         }
807 #ifndef OPENSSL_SYS_VMS
808         /*
809          * outdir is a directory spec, but access() for VMS demands a
810          * filename.  In any case, stat(), below, will catch the problem if
811          * outdir is not a directory spec, and the fopen() or open() will
812          * catch an error if there is no write access.
813          *
814          * Presumably, this problem could also be solved by using the DEC C
815          * routines to convert the directory syntax to Unixly, and give that
816          * to access().  However, time's too short to do that just now.
817          */
818 # ifndef _WIN32
819         if (access(outdir, R_OK | W_OK | X_OK) != 0)
820 # else
821         if (_access(outdir, R_OK | W_OK | X_OK) != 0)
822 # endif
823         {
824             BIO_printf(bio_err, "I am unable to access the %s directory\n",
825                        outdir);
826             perror(outdir);
827             goto err;
828         }
829
830         if (app_isdir(outdir) <= 0) {
831             BIO_printf(bio_err, "%s need to be a directory\n", outdir);
832             perror(outdir);
833             goto err;
834         }
835 #endif
836     }
837
838         /*****************************************************************/
839     /* we need to load the database file */
840     if ((dbfile = NCONF_get_string(conf, section, ENV_DATABASE)) == NULL) {
841         lookup_fail(section, ENV_DATABASE);
842         goto err;
843     }
844     db = load_index(dbfile, &db_attr);
845     if (db == NULL)
846         goto err;
847
848     /* Lets check some fields */
849     for (i = 0; i < sk_OPENSSL_PSTRING_num(db->db->data); i++) {
850         pp = sk_OPENSSL_PSTRING_value(db->db->data, i);
851         if ((pp[DB_type][0] != DB_TYPE_REV) && (pp[DB_rev_date][0] != '\0')) {
852             BIO_printf(bio_err,
853                        "entry %d: not revoked yet, but has a revocation date\n",
854                        i + 1);
855             goto err;
856         }
857         if ((pp[DB_type][0] == DB_TYPE_REV) &&
858             !make_revoked(NULL, pp[DB_rev_date])) {
859             BIO_printf(bio_err, " in entry %d\n", i + 1);
860             goto err;
861         }
862         if (!check_time_format((char *)pp[DB_exp_date])) {
863             BIO_printf(bio_err, "entry %d: invalid expiry date\n", i + 1);
864             goto err;
865         }
866         p = pp[DB_serial];
867         j = strlen(p);
868         if (*p == '-') {
869             p++;
870             j--;
871         }
872         if ((j & 1) || (j < 2)) {
873             BIO_printf(bio_err, "entry %d: bad serial number length (%d)\n",
874                        i + 1, j);
875             goto err;
876         }
877         while (*p) {
878             if (!(((*p >= '0') && (*p <= '9')) ||
879                   ((*p >= 'A') && (*p <= 'F')) ||
880                   ((*p >= 'a') && (*p <= 'f')))) {
881                 BIO_printf(bio_err,
882                            "entry %d: bad serial number characters, char pos %ld, char is '%c'\n",
883                            i + 1, (long)(p - pp[DB_serial]), *p);
884                 goto err;
885             }
886             p++;
887         }
888     }
889     if (verbose) {
890         BIO_set_fp(out, stdout, BIO_NOCLOSE | BIO_FP_TEXT); /* cannot fail */
891 #ifdef OPENSSL_SYS_VMS
892         {
893             BIO *tmpbio = BIO_new(BIO_f_linebuffer());
894             out = BIO_push(tmpbio, out);
895         }
896 #endif
897         TXT_DB_write(out, db->db);
898         BIO_printf(bio_err, "%d entries loaded from the database\n",
899                    sk_OPENSSL_PSTRING_num(db->db->data));
900         BIO_printf(bio_err, "generating index\n");
901     }
902
903     if (!index_index(db))
904         goto err;
905
906         /*****************************************************************/
907     /* Update the db file for expired certificates */
908     if (doupdatedb) {
909         if (verbose)
910             BIO_printf(bio_err, "Updating %s ...\n", dbfile);
911
912         i = do_updatedb(db);
913         if (i == -1) {
914             BIO_printf(bio_err, "Malloc failure\n");
915             goto err;
916         } else if (i == 0) {
917             if (verbose)
918                 BIO_printf(bio_err, "No entries found to mark expired\n");
919         } else {
920             if (!save_index(dbfile, "new", db))
921                 goto err;
922
923             if (!rotate_index(dbfile, "new", "old"))
924                 goto err;
925
926             if (verbose)
927                 BIO_printf(bio_err,
928                            "Done. %d entries marked as expired\n", i);
929         }
930     }
931
932         /*****************************************************************/
933     /* Read extentions config file                                   */
934     if (extfile) {
935         extconf = NCONF_new(NULL);
936         if (NCONF_load(extconf, extfile, &errorline) <= 0) {
937             if (errorline <= 0)
938                 BIO_printf(bio_err, "ERROR: loading the config file '%s'\n",
939                            extfile);
940             else
941                 BIO_printf(bio_err,
942                            "ERROR: on line %ld of config file '%s'\n",
943                            errorline, extfile);
944             ret = 1;
945             goto err;
946         }
947
948         if (verbose)
949             BIO_printf(bio_err, "Successfully loaded extensions file %s\n",
950                        extfile);
951
952         /* We can have sections in the ext file */
953         if (!extensions
954             && !(extensions =
955                  NCONF_get_string(extconf, "default", "extensions")))
956             extensions = "default";
957     }
958
959         /*****************************************************************/
960     if (req || gencrl) {
961         if (outfile != NULL) {
962             if (BIO_write_filename(Sout, outfile) <= 0) {
963                 perror(outfile);
964                 goto err;
965             }
966         } else {
967             BIO_set_fp(Sout, stdout, BIO_NOCLOSE | BIO_FP_TEXT);
968 #ifdef OPENSSL_SYS_VMS
969             {
970                 BIO *tmpbio = BIO_new(BIO_f_linebuffer());
971                 Sout = BIO_push(tmpbio, Sout);
972             }
973 #endif
974         }
975     }
976
977     if ((md == NULL) && ((md = NCONF_get_string(conf,
978                                                 section,
979                                                 ENV_DEFAULT_MD)) == NULL)) {
980         lookup_fail(section, ENV_DEFAULT_MD);
981         goto err;
982     }
983
984     if (!strcmp(md, "default")) {
985         int def_nid;
986         if (EVP_PKEY_get_default_digest_nid(pkey, &def_nid) <= 0) {
987             BIO_puts(bio_err, "no default digest\n");
988             goto err;
989         }
990         md = (char *)OBJ_nid2sn(def_nid);
991     }
992
993     if ((dgst = EVP_get_digestbyname(md)) == NULL) {
994         BIO_printf(bio_err, "%s is an unsupported message digest type\n", md);
995         goto err;
996     }
997
998     if (req) {
999         if ((email_dn == 1) && ((tmp_email_dn = NCONF_get_string(conf,
1000                                                                  section,
1001                                                                  ENV_DEFAULT_EMAIL_DN))
1002                                 != NULL)) {
1003             if (strcmp(tmp_email_dn, "no") == 0)
1004                 email_dn = 0;
1005         }
1006         if (verbose)
1007             BIO_printf(bio_err, "message digest is %s\n",
1008                        OBJ_nid2ln(dgst->type));
1009         if ((policy == NULL) && ((policy = NCONF_get_string(conf,
1010                                                             section,
1011                                                             ENV_POLICY)) ==
1012                                  NULL)) {
1013             lookup_fail(section, ENV_POLICY);
1014             goto err;
1015         }
1016         if (verbose)
1017             BIO_printf(bio_err, "policy is %s\n", policy);
1018
1019         if ((serialfile = NCONF_get_string(conf, section, ENV_SERIAL))
1020             == NULL) {
1021             lookup_fail(section, ENV_SERIAL);
1022             goto err;
1023         }
1024
1025         if (!extconf) {
1026             /*
1027              * no '-extfile' option, so we look for extensions in the main
1028              * configuration file
1029              */
1030             if (!extensions) {
1031                 extensions = NCONF_get_string(conf, section, ENV_EXTENSIONS);
1032                 if (!extensions)
1033                     ERR_clear_error();
1034             }
1035             if (extensions) {
1036                 /* Check syntax of file */
1037                 X509V3_CTX ctx;
1038                 X509V3_set_ctx_test(&ctx);
1039                 X509V3_set_nconf(&ctx, conf);
1040                 if (!X509V3_EXT_add_nconf(conf, &ctx, extensions, NULL)) {
1041                     BIO_printf(bio_err,
1042                                "Error Loading extension section %s\n",
1043                                extensions);
1044                     ret = 1;
1045                     goto err;
1046                 }
1047             }
1048         }
1049
1050         if (startdate == NULL) {
1051             startdate = NCONF_get_string(conf, section,
1052                                          ENV_DEFAULT_STARTDATE);
1053             if (startdate == NULL)
1054                 ERR_clear_error();
1055         }
1056         if (startdate && !ASN1_TIME_set_string(NULL, startdate)) {
1057             BIO_printf(bio_err,
1058                        "start date is invalid, it should be YYMMDDHHMMSSZ or YYYYMMDDHHMMSSZ\n");
1059             goto err;
1060         }
1061         if (startdate == NULL)
1062             startdate = "today";
1063
1064         if (enddate == NULL) {
1065             enddate = NCONF_get_string(conf, section, ENV_DEFAULT_ENDDATE);
1066             if (enddate == NULL)
1067                 ERR_clear_error();
1068         }
1069         if (enddate && !ASN1_TIME_set_string(NULL, enddate)) {
1070             BIO_printf(bio_err,
1071                        "end date is invalid, it should be YYMMDDHHMMSSZ or YYYYMMDDHHMMSSZ\n");
1072             goto err;
1073         }
1074
1075         if (days == 0) {
1076             if (!NCONF_get_number(conf, section, ENV_DEFAULT_DAYS, &days))
1077                 days = 0;
1078         }
1079         if (!enddate && (days == 0)) {
1080             BIO_printf(bio_err,
1081                        "cannot lookup how many days to certify for\n");
1082             goto err;
1083         }
1084
1085         if ((serial = load_serial(serialfile, create_ser, NULL)) == NULL) {
1086             BIO_printf(bio_err, "error while loading serial number\n");
1087             goto err;
1088         }
1089         if (verbose) {
1090             if (BN_is_zero(serial))
1091                 BIO_printf(bio_err, "next serial number is 00\n");
1092             else {
1093                 if ((f = BN_bn2hex(serial)) == NULL)
1094                     goto err;
1095                 BIO_printf(bio_err, "next serial number is %s\n", f);
1096                 OPENSSL_free(f);
1097             }
1098         }
1099
1100         if ((attribs = NCONF_get_section(conf, policy)) == NULL) {
1101             BIO_printf(bio_err, "unable to find 'section' for %s\n", policy);
1102             goto err;
1103         }
1104
1105         if ((cert_sk = sk_X509_new_null()) == NULL) {
1106             BIO_printf(bio_err, "Memory allocation failure\n");
1107             goto err;
1108         }
1109         if (spkac_file != NULL) {
1110             total++;
1111             j = certify_spkac(&x, spkac_file, pkey, x509, dgst, sigopts,
1112                               attribs, db, serial, subj, chtype, multirdn,
1113                               email_dn, startdate, enddate, days, extensions,
1114                               conf, verbose, certopt, nameopt, default_op,
1115                               ext_copy);
1116             if (j < 0)
1117                 goto err;
1118             if (j > 0) {
1119                 total_done++;
1120                 BIO_printf(bio_err, "\n");
1121                 if (!BN_add_word(serial, 1))
1122                     goto err;
1123                 if (!sk_X509_push(cert_sk, x)) {
1124                     BIO_printf(bio_err, "Memory allocation failure\n");
1125                     goto err;
1126                 }
1127                 if (outfile) {
1128                     output_der = 1;
1129                     batch = 1;
1130                 }
1131             }
1132         }
1133         if (ss_cert_file != NULL) {
1134             total++;
1135             j = certify_cert(&x, ss_cert_file, pkey, x509, dgst, sigopts,
1136                              attribs,
1137                              db, serial, subj, chtype, multirdn, email_dn,
1138                              startdate, enddate, days, batch, extensions,
1139                              conf, verbose, certopt, nameopt, default_op,
1140                              ext_copy, e);
1141             if (j < 0)
1142                 goto err;
1143             if (j > 0) {
1144                 total_done++;
1145                 BIO_printf(bio_err, "\n");
1146                 if (!BN_add_word(serial, 1))
1147                     goto err;
1148                 if (!sk_X509_push(cert_sk, x)) {
1149                     BIO_printf(bio_err, "Memory allocation failure\n");
1150                     goto err;
1151                 }
1152             }
1153         }
1154         if (infile != NULL) {
1155             total++;
1156             j = certify(&x, infile, pkey, x509p, dgst, sigopts, attribs, db,
1157                         serial, subj, chtype, multirdn, email_dn, startdate,
1158                         enddate, days, batch, extensions, conf, verbose,
1159                         certopt, nameopt, default_op, ext_copy, selfsign);
1160             if (j < 0)
1161                 goto err;
1162             if (j > 0) {
1163                 total_done++;
1164                 BIO_printf(bio_err, "\n");
1165                 if (!BN_add_word(serial, 1))
1166                     goto err;
1167                 if (!sk_X509_push(cert_sk, x)) {
1168                     BIO_printf(bio_err, "Memory allocation failure\n");
1169                     goto err;
1170                 }
1171             }
1172         }
1173         for (i = 0; i < argc; i++) {
1174             total++;
1175             j = certify(&x, argv[i], pkey, x509p, dgst, sigopts, attribs, db,
1176                         serial, subj, chtype, multirdn, email_dn, startdate,
1177                         enddate, days, batch, extensions, conf, verbose,
1178                         certopt, nameopt, default_op, ext_copy, selfsign);
1179             if (j < 0)
1180                 goto err;
1181             if (j > 0) {
1182                 total_done++;
1183                 BIO_printf(bio_err, "\n");
1184                 if (!BN_add_word(serial, 1))
1185                     goto err;
1186                 if (!sk_X509_push(cert_sk, x)) {
1187                     BIO_printf(bio_err, "Memory allocation failure\n");
1188                     goto err;
1189                 }
1190             }
1191         }
1192         /*
1193          * we have a stack of newly certified certificates and a data base
1194          * and serial number that need updating
1195          */
1196
1197         if (sk_X509_num(cert_sk) > 0) {
1198             if (!batch) {
1199                 BIO_printf(bio_err,
1200                            "\n%d out of %d certificate requests certified, commit? [y/n]",
1201                            total_done, total);
1202                 (void)BIO_flush(bio_err);
1203                 buf[0][0] = '\0';
1204                 if (!fgets(buf[0], 10, stdin)) {
1205                     BIO_printf(bio_err,
1206                                "CERTIFICATION CANCELED: I/O error\n");
1207                     ret = 0;
1208                     goto err;
1209                 }
1210                 if ((buf[0][0] != 'y') && (buf[0][0] != 'Y')) {
1211                     BIO_printf(bio_err, "CERTIFICATION CANCELED\n");
1212                     ret = 0;
1213                     goto err;
1214                 }
1215             }
1216
1217             BIO_printf(bio_err, "Write out database with %d new entries\n",
1218                        sk_X509_num(cert_sk));
1219
1220             if (!save_serial(serialfile, "new", serial, NULL))
1221                 goto err;
1222
1223             if (!save_index(dbfile, "new", db))
1224                 goto err;
1225         }
1226
1227         if (verbose)
1228             BIO_printf(bio_err, "writing new certificates\n");
1229         for (i = 0; i < sk_X509_num(cert_sk); i++) {
1230             int k;
1231             char *n;
1232
1233             x = sk_X509_value(cert_sk, i);
1234
1235             j = x->cert_info->serialNumber->length;
1236             p = (const char *)x->cert_info->serialNumber->data;
1237
1238             if (strlen(outdir) >= (size_t)(j ? BSIZE - j * 2 - 6 : BSIZE - 8)) {
1239                 BIO_printf(bio_err, "certificate file name too long\n");
1240                 goto err;
1241             }
1242
1243             strcpy(buf[2], outdir);
1244
1245 #ifndef OPENSSL_SYS_VMS
1246             BUF_strlcat(buf[2], "/", sizeof(buf[2]));
1247 #endif
1248
1249             n = (char *)&(buf[2][strlen(buf[2])]);
1250             if (j > 0) {
1251                 for (k = 0; k < j; k++) {
1252                     if (n >= &(buf[2][sizeof(buf[2])]))
1253                         break;
1254                     BIO_snprintf(n,
1255                                  &buf[2][0] + sizeof(buf[2]) - n,
1256                                  "%02X", (unsigned char)*(p++));
1257                     n += 2;
1258                 }
1259             } else {
1260                 *(n++) = '0';
1261                 *(n++) = '0';
1262             }
1263             *(n++) = '.';
1264             *(n++) = 'p';
1265             *(n++) = 'e';
1266             *(n++) = 'm';
1267             *n = '\0';
1268             if (verbose)
1269                 BIO_printf(bio_err, "writing %s\n", buf[2]);
1270
1271             if (BIO_write_filename(Cout, buf[2]) <= 0) {
1272                 perror(buf[2]);
1273                 goto err;
1274             }
1275             write_new_certificate(Cout, x, 0, notext);
1276             write_new_certificate(Sout, x, output_der, notext);
1277         }
1278
1279         if (sk_X509_num(cert_sk)) {
1280             /* Rename the database and the serial file */
1281             if (!rotate_serial(serialfile, "new", "old"))
1282                 goto err;
1283
1284             if (!rotate_index(dbfile, "new", "old"))
1285                 goto err;
1286
1287             BIO_printf(bio_err, "Data Base Updated\n");
1288         }
1289     }
1290
1291         /*****************************************************************/
1292     if (gencrl) {
1293         int crl_v2 = 0;
1294         if (!crl_ext) {
1295             crl_ext = NCONF_get_string(conf, section, ENV_CRLEXT);
1296             if (!crl_ext)
1297                 ERR_clear_error();
1298         }
1299         if (crl_ext) {
1300             /* Check syntax of file */
1301             X509V3_CTX ctx;
1302             X509V3_set_ctx_test(&ctx);
1303             X509V3_set_nconf(&ctx, conf);
1304             if (!X509V3_EXT_add_nconf(conf, &ctx, crl_ext, NULL)) {
1305                 BIO_printf(bio_err,
1306                            "Error Loading CRL extension section %s\n",
1307                            crl_ext);
1308                 ret = 1;
1309                 goto err;
1310             }
1311         }
1312
1313         if ((crlnumberfile = NCONF_get_string(conf, section, ENV_CRLNUMBER))
1314             != NULL)
1315             if ((crlnumber = load_serial(crlnumberfile, 0, NULL)) == NULL) {
1316                 BIO_printf(bio_err, "error while loading CRL number\n");
1317                 goto err;
1318             }
1319
1320         if (!crldays && !crlhours && !crlsec) {
1321             if (!NCONF_get_number(conf, section,
1322                                   ENV_DEFAULT_CRL_DAYS, &crldays))
1323                 crldays = 0;
1324             if (!NCONF_get_number(conf, section,
1325                                   ENV_DEFAULT_CRL_HOURS, &crlhours))
1326                 crlhours = 0;
1327             ERR_clear_error();
1328         }
1329         if ((crldays == 0) && (crlhours == 0) && (crlsec == 0)) {
1330             BIO_printf(bio_err,
1331                        "cannot lookup how long until the next CRL is issued\n");
1332             goto err;
1333         }
1334
1335         if (verbose)
1336             BIO_printf(bio_err, "making CRL\n");
1337         if ((crl = X509_CRL_new()) == NULL)
1338             goto err;
1339         if (!X509_CRL_set_issuer_name(crl, X509_get_subject_name(x509)))
1340             goto err;
1341
1342         tmptm = ASN1_TIME_new();
1343         if (!tmptm)
1344             goto err;
1345         X509_gmtime_adj(tmptm, 0);
1346         X509_CRL_set_lastUpdate(crl, tmptm);
1347         if (!X509_time_adj_ex(tmptm, crldays, crlhours * 60 * 60 + crlsec,
1348                               NULL)) {
1349             BIO_puts(bio_err, "error setting CRL nextUpdate\n");
1350             goto err;
1351         }
1352         X509_CRL_set_nextUpdate(crl, tmptm);
1353
1354         ASN1_TIME_free(tmptm);
1355
1356         for (i = 0; i < sk_OPENSSL_PSTRING_num(db->db->data); i++) {
1357             pp = sk_OPENSSL_PSTRING_value(db->db->data, i);
1358             if (pp[DB_type][0] == DB_TYPE_REV) {
1359                 if ((r = X509_REVOKED_new()) == NULL)
1360                     goto err;
1361                 j = make_revoked(r, pp[DB_rev_date]);
1362                 if (!j)
1363                     goto err;
1364                 if (j == 2)
1365                     crl_v2 = 1;
1366                 if (!BN_hex2bn(&serial, pp[DB_serial]))
1367                     goto err;
1368                 tmpser = BN_to_ASN1_INTEGER(serial, NULL);
1369                 BN_free(serial);
1370                 serial = NULL;
1371                 if (!tmpser)
1372                     goto err;
1373                 X509_REVOKED_set_serialNumber(r, tmpser);
1374                 ASN1_INTEGER_free(tmpser);
1375                 X509_CRL_add0_revoked(crl, r);
1376             }
1377         }
1378
1379         /*
1380          * sort the data so it will be written in serial number order
1381          */
1382         X509_CRL_sort(crl);
1383
1384         /* we now have a CRL */
1385         if (verbose)
1386             BIO_printf(bio_err, "signing CRL\n");
1387
1388         /* Add any extensions asked for */
1389
1390         if (crl_ext || crlnumberfile != NULL) {
1391             X509V3_CTX crlctx;
1392             X509V3_set_ctx(&crlctx, x509, NULL, NULL, crl, 0);
1393             X509V3_set_nconf(&crlctx, conf);
1394
1395             if (crl_ext)
1396                 if (!X509V3_EXT_CRL_add_nconf(conf, &crlctx, crl_ext, crl))
1397                     goto err;
1398             if (crlnumberfile != NULL) {
1399                 tmpser = BN_to_ASN1_INTEGER(crlnumber, NULL);
1400                 if (!tmpser)
1401                     goto err;
1402                 X509_CRL_add1_ext_i2d(crl, NID_crl_number, tmpser, 0, 0);
1403                 ASN1_INTEGER_free(tmpser);
1404                 crl_v2 = 1;
1405                 if (!BN_add_word(crlnumber, 1))
1406                     goto err;
1407             }
1408         }
1409         if (crl_ext || crl_v2) {
1410             if (!X509_CRL_set_version(crl, 1))
1411                 goto err;       /* version 2 CRL */
1412         }
1413
1414         /* we have a CRL number that need updating */
1415         if (crlnumberfile != NULL)
1416             if (!save_serial(crlnumberfile, "new", crlnumber, NULL))
1417                 goto err;
1418
1419         if (crlnumber) {
1420             BN_free(crlnumber);
1421             crlnumber = NULL;
1422         }
1423
1424         if (!do_X509_CRL_sign(bio_err, crl, pkey, dgst, sigopts))
1425             goto err;
1426
1427         PEM_write_bio_X509_CRL(Sout, crl);
1428
1429         if (crlnumberfile != NULL) /* Rename the crlnumber file */
1430             if (!rotate_serial(crlnumberfile, "new", "old"))
1431                 goto err;
1432
1433     }
1434         /*****************************************************************/
1435     if (dorevoke) {
1436         if (infile == NULL) {
1437             BIO_printf(bio_err, "no input files\n");
1438             goto err;
1439         } else {
1440             X509 *revcert;
1441             revcert = load_cert(bio_err, infile, FORMAT_PEM, NULL, e, infile);
1442             if (revcert == NULL)
1443                 goto err;
1444             j = do_revoke(revcert, db, rev_type, rev_arg);
1445             if (j <= 0)
1446                 goto err;
1447             X509_free(revcert);
1448
1449             if (!save_index(dbfile, "new", db))
1450                 goto err;
1451
1452             if (!rotate_index(dbfile, "new", "old"))
1453                 goto err;
1454
1455             BIO_printf(bio_err, "Data Base Updated\n");
1456         }
1457     }
1458         /*****************************************************************/
1459     ret = 0;
1460  err:
1461     if (tofree)
1462         OPENSSL_free(tofree);
1463     BIO_free_all(Cout);
1464     BIO_free_all(Sout);
1465     BIO_free_all(out);
1466     BIO_free_all(in);
1467
1468     if (cert_sk)
1469         sk_X509_pop_free(cert_sk, X509_free);
1470
1471     if (ret)
1472         ERR_print_errors(bio_err);
1473     app_RAND_write_file(randfile, bio_err);
1474     if (free_key && key)
1475         OPENSSL_free(key);
1476     BN_free(serial);
1477     BN_free(crlnumber);
1478     free_index(db);
1479     if (sigopts)
1480         sk_OPENSSL_STRING_free(sigopts);
1481     EVP_PKEY_free(pkey);
1482     if (x509)
1483         X509_free(x509);
1484     X509_CRL_free(crl);
1485     NCONF_free(conf);
1486     NCONF_free(extconf);
1487     OBJ_cleanup();
1488     apps_shutdown();
1489     OPENSSL_EXIT(ret);
1490 }
1491
1492 static void lookup_fail(const char *name, const char *tag)
1493 {
1494     BIO_printf(bio_err, "variable lookup failed for %s::%s\n", name, tag);
1495 }
1496
1497 static int certify(X509 **xret, char *infile, EVP_PKEY *pkey, X509 *x509,
1498                    const EVP_MD *dgst, STACK_OF(OPENSSL_STRING) *sigopts,
1499                    STACK_OF(CONF_VALUE) *policy, CA_DB *db,
1500                    BIGNUM *serial, char *subj, unsigned long chtype,
1501                    int multirdn, int email_dn, char *startdate, char *enddate,
1502                    long days, int batch, char *ext_sect, CONF *lconf,
1503                    int verbose, unsigned long certopt, unsigned long nameopt,
1504                    int default_op, int ext_copy, int selfsign)
1505 {
1506     X509_REQ *req = NULL;
1507     BIO *in = NULL;
1508     EVP_PKEY *pktmp = NULL;
1509     int ok = -1, i;
1510
1511     in = BIO_new(BIO_s_file());
1512
1513     if (BIO_read_filename(in, infile) <= 0) {
1514         perror(infile);
1515         goto err;
1516     }
1517     if ((req = PEM_read_bio_X509_REQ(in, NULL, NULL, NULL)) == NULL) {
1518         BIO_printf(bio_err, "Error reading certificate request in %s\n",
1519                    infile);
1520         goto err;
1521     }
1522     if (verbose)
1523         X509_REQ_print(bio_err, req);
1524
1525     BIO_printf(bio_err, "Check that the request matches the signature\n");
1526
1527     if (selfsign && !X509_REQ_check_private_key(req, pkey)) {
1528         BIO_printf(bio_err,
1529                    "Certificate request and CA private key do not match\n");
1530         ok = 0;
1531         goto err;
1532     }
1533     if ((pktmp = X509_REQ_get_pubkey(req)) == NULL) {
1534         BIO_printf(bio_err, "error unpacking public key\n");
1535         goto err;
1536     }
1537     i = X509_REQ_verify(req, pktmp);
1538     EVP_PKEY_free(pktmp);
1539     if (i < 0) {
1540         ok = 0;
1541         BIO_printf(bio_err, "Signature verification problems....\n");
1542         ERR_print_errors(bio_err);
1543         goto err;
1544     }
1545     if (i == 0) {
1546         ok = 0;
1547         BIO_printf(bio_err,
1548                    "Signature did not match the certificate request\n");
1549         ERR_print_errors(bio_err);
1550         goto err;
1551     } else
1552         BIO_printf(bio_err, "Signature ok\n");
1553
1554     ok = do_body(xret, pkey, x509, dgst, sigopts, policy, db, serial, subj,
1555                  chtype, multirdn, email_dn, startdate, enddate, days, batch,
1556                  verbose, req, ext_sect, lconf, certopt, nameopt, default_op,
1557                  ext_copy, selfsign);
1558
1559  err:
1560     if (req != NULL)
1561         X509_REQ_free(req);
1562     if (in != NULL)
1563         BIO_free(in);
1564     return (ok);
1565 }
1566
1567 static int certify_cert(X509 **xret, char *infile, EVP_PKEY *pkey, X509 *x509,
1568                         const EVP_MD *dgst, STACK_OF(OPENSSL_STRING) *sigopts,
1569                         STACK_OF(CONF_VALUE) *policy, CA_DB *db,
1570                         BIGNUM *serial, char *subj, unsigned long chtype,
1571                         int multirdn, int email_dn, char *startdate,
1572                         char *enddate, long days, int batch, char *ext_sect,
1573                         CONF *lconf, int verbose, unsigned long certopt,
1574                         unsigned long nameopt, int default_op, int ext_copy,
1575                         ENGINE *e)
1576 {
1577     X509 *req = NULL;
1578     X509_REQ *rreq = NULL;
1579     EVP_PKEY *pktmp = NULL;
1580     int ok = -1, i;
1581
1582     if ((req =
1583          load_cert(bio_err, infile, FORMAT_PEM, NULL, e, infile)) == NULL)
1584         goto err;
1585     if (verbose)
1586         X509_print(bio_err, req);
1587
1588     BIO_printf(bio_err, "Check that the request matches the signature\n");
1589
1590     if ((pktmp = X509_get_pubkey(req)) == NULL) {
1591         BIO_printf(bio_err, "error unpacking public key\n");
1592         goto err;
1593     }
1594     i = X509_verify(req, pktmp);
1595     EVP_PKEY_free(pktmp);
1596     if (i < 0) {
1597         ok = 0;
1598         BIO_printf(bio_err, "Signature verification problems....\n");
1599         goto err;
1600     }
1601     if (i == 0) {
1602         ok = 0;
1603         BIO_printf(bio_err, "Signature did not match the certificate\n");
1604         goto err;
1605     } else
1606         BIO_printf(bio_err, "Signature ok\n");
1607
1608     if ((rreq = X509_to_X509_REQ(req, NULL, EVP_md5())) == NULL)
1609         goto err;
1610
1611     ok = do_body(xret, pkey, x509, dgst, sigopts, policy, db, serial, subj,
1612                  chtype, multirdn, email_dn, startdate, enddate, days, batch,
1613                  verbose, rreq, ext_sect, lconf, certopt, nameopt, default_op,
1614                  ext_copy, 0);
1615
1616  err:
1617     if (rreq != NULL)
1618         X509_REQ_free(rreq);
1619     if (req != NULL)
1620         X509_free(req);
1621     return (ok);
1622 }
1623
1624 static int do_body(X509 **xret, EVP_PKEY *pkey, X509 *x509,
1625                    const EVP_MD *dgst, STACK_OF(OPENSSL_STRING) *sigopts,
1626                    STACK_OF(CONF_VALUE) *policy, CA_DB *db, BIGNUM *serial,
1627                    char *subj, unsigned long chtype, int multirdn,
1628                    int email_dn, char *startdate, char *enddate, long days,
1629                    int batch, int verbose, X509_REQ *req, char *ext_sect,
1630                    CONF *lconf, unsigned long certopt, unsigned long nameopt,
1631                    int default_op, int ext_copy, int selfsign)
1632 {
1633     X509_NAME *name = NULL, *CAname = NULL, *subject = NULL, *dn_subject =
1634         NULL;
1635     ASN1_UTCTIME *tm, *tmptm;
1636     ASN1_STRING *str, *str2;
1637     ASN1_OBJECT *obj;
1638     X509 *ret = NULL;
1639     X509_CINF *ci;
1640     X509_NAME_ENTRY *ne;
1641     X509_NAME_ENTRY *tne, *push;
1642     EVP_PKEY *pktmp;
1643     int ok = -1, i, j, last, nid;
1644     const char *p;
1645     CONF_VALUE *cv;
1646     OPENSSL_STRING row[DB_NUMBER];
1647     OPENSSL_STRING *irow = NULL;
1648     OPENSSL_STRING *rrow = NULL;
1649     char buf[25];
1650
1651     tmptm = ASN1_UTCTIME_new();
1652     if (tmptm == NULL) {
1653         BIO_printf(bio_err, "malloc error\n");
1654         return (0);
1655     }
1656
1657     for (i = 0; i < DB_NUMBER; i++)
1658         row[i] = NULL;
1659
1660     if (subj) {
1661         X509_NAME *n = parse_name(subj, chtype, multirdn);
1662
1663         if (!n) {
1664             ERR_print_errors(bio_err);
1665             goto err;
1666         }
1667         X509_REQ_set_subject_name(req, n);
1668         req->req_info->enc.modified = 1;
1669         X509_NAME_free(n);
1670     }
1671
1672     if (default_op)
1673         BIO_printf(bio_err,
1674                    "The Subject's Distinguished Name is as follows\n");
1675
1676     name = X509_REQ_get_subject_name(req);
1677     for (i = 0; i < X509_NAME_entry_count(name); i++) {
1678         ne = X509_NAME_get_entry(name, i);
1679         str = X509_NAME_ENTRY_get_data(ne);
1680         obj = X509_NAME_ENTRY_get_object(ne);
1681
1682         if (msie_hack) {
1683             /* assume all type should be strings */
1684             nid = OBJ_obj2nid(ne->object);
1685
1686             if (str->type == V_ASN1_UNIVERSALSTRING)
1687                 ASN1_UNIVERSALSTRING_to_string(str);
1688
1689             if ((str->type == V_ASN1_IA5STRING) &&
1690                 (nid != NID_pkcs9_emailAddress))
1691                 str->type = V_ASN1_T61STRING;
1692
1693             if ((nid == NID_pkcs9_emailAddress) &&
1694                 (str->type == V_ASN1_PRINTABLESTRING))
1695                 str->type = V_ASN1_IA5STRING;
1696         }
1697
1698         /* If no EMAIL is wanted in the subject */
1699         if ((OBJ_obj2nid(obj) == NID_pkcs9_emailAddress) && (!email_dn))
1700             continue;
1701
1702         /* check some things */
1703         if ((OBJ_obj2nid(obj) == NID_pkcs9_emailAddress) &&
1704             (str->type != V_ASN1_IA5STRING)) {
1705             BIO_printf(bio_err,
1706                        "\nemailAddress type needs to be of type IA5STRING\n");
1707             goto err;
1708         }
1709         if ((str->type != V_ASN1_BMPSTRING)
1710             && (str->type != V_ASN1_UTF8STRING)) {
1711             j = ASN1_PRINTABLE_type(str->data, str->length);
1712             if (((j == V_ASN1_T61STRING) &&
1713                  (str->type != V_ASN1_T61STRING)) ||
1714                 ((j == V_ASN1_IA5STRING) &&
1715                  (str->type == V_ASN1_PRINTABLESTRING))) {
1716                 BIO_printf(bio_err,
1717                            "\nThe string contains characters that are illegal for the ASN.1 type\n");
1718                 goto err;
1719             }
1720         }
1721
1722         if (default_op)
1723             old_entry_print(bio_err, obj, str);
1724     }
1725
1726     /* Ok, now we check the 'policy' stuff. */
1727     if ((subject = X509_NAME_new()) == NULL) {
1728         BIO_printf(bio_err, "Memory allocation failure\n");
1729         goto err;
1730     }
1731
1732     /* take a copy of the issuer name before we mess with it. */
1733     if (selfsign)
1734         CAname = X509_NAME_dup(name);
1735     else
1736         CAname = X509_NAME_dup(x509->cert_info->subject);
1737     if (CAname == NULL)
1738         goto err;
1739     str = str2 = NULL;
1740
1741     for (i = 0; i < sk_CONF_VALUE_num(policy); i++) {
1742         cv = sk_CONF_VALUE_value(policy, i); /* get the object id */
1743         if ((j = OBJ_txt2nid(cv->name)) == NID_undef) {
1744             BIO_printf(bio_err,
1745                        "%s:unknown object type in 'policy' configuration\n",
1746                        cv->name);
1747             goto err;
1748         }
1749         obj = OBJ_nid2obj(j);
1750
1751         last = -1;
1752         for (;;) {
1753             /* lookup the object in the supplied name list */
1754             j = X509_NAME_get_index_by_OBJ(name, obj, last);
1755             if (j < 0) {
1756                 if (last != -1)
1757                     break;
1758                 tne = NULL;
1759             } else {
1760                 tne = X509_NAME_get_entry(name, j);
1761             }
1762             last = j;
1763
1764             /* depending on the 'policy', decide what to do. */
1765             push = NULL;
1766             if (strcmp(cv->value, "optional") == 0) {
1767                 if (tne != NULL)
1768                     push = tne;
1769             } else if (strcmp(cv->value, "supplied") == 0) {
1770                 if (tne == NULL) {
1771                     BIO_printf(bio_err,
1772                                "The %s field needed to be supplied and was missing\n",
1773                                cv->name);
1774                     goto err;
1775                 } else
1776                     push = tne;
1777             } else if (strcmp(cv->value, "match") == 0) {
1778                 int last2;
1779
1780                 if (tne == NULL) {
1781                     BIO_printf(bio_err,
1782                                "The mandatory %s field was missing\n",
1783                                cv->name);
1784                     goto err;
1785                 }
1786
1787                 last2 = -1;
1788
1789  again2:
1790                 j = X509_NAME_get_index_by_OBJ(CAname, obj, last2);
1791                 if ((j < 0) && (last2 == -1)) {
1792                     BIO_printf(bio_err,
1793                                "The %s field does not exist in the CA certificate,\nthe 'policy' is misconfigured\n",
1794                                cv->name);
1795                     goto err;
1796                 }
1797                 if (j >= 0) {
1798                     push = X509_NAME_get_entry(CAname, j);
1799                     str = X509_NAME_ENTRY_get_data(tne);
1800                     str2 = X509_NAME_ENTRY_get_data(push);
1801                     last2 = j;
1802                     if (ASN1_STRING_cmp(str, str2) != 0)
1803                         goto again2;
1804                 }
1805                 if (j < 0) {
1806                     BIO_printf(bio_err,
1807                                "The %s field needed to be the same in the\nCA certificate (%s) and the request (%s)\n",
1808                                cv->name,
1809                                ((str2 == NULL) ? "NULL" : (char *)str2->data),
1810                                ((str == NULL) ? "NULL" : (char *)str->data));
1811                     goto err;
1812                 }
1813             } else {
1814                 BIO_printf(bio_err,
1815                            "%s:invalid type in 'policy' configuration\n",
1816                            cv->value);
1817                 goto err;
1818             }
1819
1820             if (push != NULL) {
1821                 if (!X509_NAME_add_entry(subject, push, -1, 0)) {
1822                     if (push != NULL)
1823                         X509_NAME_ENTRY_free(push);
1824                     BIO_printf(bio_err, "Memory allocation failure\n");
1825                     goto err;
1826                 }
1827             }
1828             if (j < 0)
1829                 break;
1830         }
1831     }
1832
1833     if (preserve) {
1834         X509_NAME_free(subject);
1835         /* subject=X509_NAME_dup(X509_REQ_get_subject_name(req)); */
1836         subject = X509_NAME_dup(name);
1837         if (subject == NULL)
1838             goto err;
1839     }
1840
1841     if (verbose)
1842         BIO_printf(bio_err,
1843                    "The subject name appears to be ok, checking data base for clashes\n");
1844
1845     /* Build the correct Subject if no e-mail is wanted in the subject */
1846     /*
1847      * and add it later on because of the method extensions are added
1848      * (altName)
1849      */
1850
1851     if (email_dn)
1852         dn_subject = subject;
1853     else {
1854         X509_NAME_ENTRY *tmpne;
1855         /*
1856          * Its best to dup the subject DN and then delete any email addresses
1857          * because this retains its structure.
1858          */
1859         if (!(dn_subject = X509_NAME_dup(subject))) {
1860             BIO_printf(bio_err, "Memory allocation failure\n");
1861             goto err;
1862         }
1863         while ((i = X509_NAME_get_index_by_NID(dn_subject,
1864                                                NID_pkcs9_emailAddress,
1865                                                -1)) >= 0) {
1866             tmpne = X509_NAME_get_entry(dn_subject, i);
1867             X509_NAME_delete_entry(dn_subject, i);
1868             X509_NAME_ENTRY_free(tmpne);
1869         }
1870     }
1871
1872     if (BN_is_zero(serial))
1873         row[DB_serial] = BUF_strdup("00");
1874     else
1875         row[DB_serial] = BN_bn2hex(serial);
1876     if (row[DB_serial] == NULL) {
1877         BIO_printf(bio_err, "Memory allocation failure\n");
1878         goto err;
1879     }
1880
1881     if (db->attributes.unique_subject) {
1882         OPENSSL_STRING *crow = row;
1883
1884         rrow = TXT_DB_get_by_index(db->db, DB_name, crow);
1885         if (rrow != NULL) {
1886             BIO_printf(bio_err,
1887                        "ERROR:There is already a certificate for %s\n",
1888                        row[DB_name]);
1889         }
1890     }
1891     if (rrow == NULL) {
1892         rrow = TXT_DB_get_by_index(db->db, DB_serial, row);
1893         if (rrow != NULL) {
1894             BIO_printf(bio_err,
1895                        "ERROR:Serial number %s has already been issued,\n",
1896                        row[DB_serial]);
1897             BIO_printf(bio_err,
1898                        "      check the database/serial_file for corruption\n");
1899         }
1900     }
1901
1902     if (rrow != NULL) {
1903         BIO_printf(bio_err, "The matching entry has the following details\n");
1904         if (rrow[DB_type][0] == 'E')
1905             p = "Expired";
1906         else if (rrow[DB_type][0] == 'R')
1907             p = "Revoked";
1908         else if (rrow[DB_type][0] == 'V')
1909             p = "Valid";
1910         else
1911             p = "\ninvalid type, Data base error\n";
1912         BIO_printf(bio_err, "Type          :%s\n", p);;
1913         if (rrow[DB_type][0] == 'R') {
1914             p = rrow[DB_exp_date];
1915             if (p == NULL)
1916                 p = "undef";
1917             BIO_printf(bio_err, "Was revoked on:%s\n", p);
1918         }
1919         p = rrow[DB_exp_date];
1920         if (p == NULL)
1921             p = "undef";
1922         BIO_printf(bio_err, "Expires on    :%s\n", p);
1923         p = rrow[DB_serial];
1924         if (p == NULL)
1925             p = "undef";
1926         BIO_printf(bio_err, "Serial Number :%s\n", p);
1927         p = rrow[DB_file];
1928         if (p == NULL)
1929             p = "undef";
1930         BIO_printf(bio_err, "File name     :%s\n", p);
1931         p = rrow[DB_name];
1932         if (p == NULL)
1933             p = "undef";
1934         BIO_printf(bio_err, "Subject Name  :%s\n", p);
1935         ok = -1;                /* This is now a 'bad' error. */
1936         goto err;
1937     }
1938
1939     /* We are now totally happy, lets make and sign the certificate */
1940     if (verbose)
1941         BIO_printf(bio_err,
1942                    "Everything appears to be ok, creating and signing the certificate\n");
1943
1944     if ((ret = X509_new()) == NULL)
1945         goto err;
1946     ci = ret->cert_info;
1947
1948 #ifdef X509_V3
1949     /* Make it an X509 v3 certificate. */
1950     if (!X509_set_version(ret, 2))
1951         goto err;
1952 #endif
1953
1954     if (BN_to_ASN1_INTEGER(serial, ci->serialNumber) == NULL)
1955         goto err;
1956     if (selfsign) {
1957         if (!X509_set_issuer_name(ret, subject))
1958             goto err;
1959     } else {
1960         if (!X509_set_issuer_name(ret, X509_get_subject_name(x509)))
1961             goto err;
1962     }
1963
1964     if (strcmp(startdate, "today") == 0)
1965         X509_gmtime_adj(X509_get_notBefore(ret), 0);
1966     else
1967         ASN1_TIME_set_string(X509_get_notBefore(ret), startdate);
1968
1969     if (enddate == NULL)
1970         X509_time_adj_ex(X509_get_notAfter(ret), days, 0, NULL);
1971     else
1972         ASN1_TIME_set_string(X509_get_notAfter(ret), enddate);
1973
1974     if (!X509_set_subject_name(ret, subject))
1975         goto err;
1976
1977     pktmp = X509_REQ_get_pubkey(req);
1978     i = X509_set_pubkey(ret, pktmp);
1979     EVP_PKEY_free(pktmp);
1980     if (!i)
1981         goto err;
1982
1983     /* Lets add the extensions, if there are any */
1984     if (ext_sect) {
1985         X509V3_CTX ctx;
1986         if (ci->version == NULL)
1987             if ((ci->version = ASN1_INTEGER_new()) == NULL)
1988                 goto err;
1989         ASN1_INTEGER_set(ci->version, 2); /* version 3 certificate */
1990
1991         /*
1992          * Free the current entries if any, there should not be any I believe
1993          */
1994         if (ci->extensions != NULL)
1995             sk_X509_EXTENSION_pop_free(ci->extensions, X509_EXTENSION_free);
1996
1997         ci->extensions = NULL;
1998
1999         /* Initialize the context structure */
2000         if (selfsign)
2001             X509V3_set_ctx(&ctx, ret, ret, req, NULL, 0);
2002         else
2003             X509V3_set_ctx(&ctx, x509, ret, req, NULL, 0);
2004
2005         if (extconf) {
2006             if (verbose)
2007                 BIO_printf(bio_err, "Extra configuration file found\n");
2008
2009             /* Use the extconf configuration db LHASH */
2010             X509V3_set_nconf(&ctx, extconf);
2011
2012             /* Test the structure (needed?) */
2013             /* X509V3_set_ctx_test(&ctx); */
2014
2015             /* Adds exts contained in the configuration file */
2016             if (!X509V3_EXT_add_nconf(extconf, &ctx, ext_sect, ret)) {
2017                 BIO_printf(bio_err,
2018                            "ERROR: adding extensions in section %s\n",
2019                            ext_sect);
2020                 ERR_print_errors(bio_err);
2021                 goto err;
2022             }
2023             if (verbose)
2024                 BIO_printf(bio_err,
2025                            "Successfully added extensions from file.\n");
2026         } else if (ext_sect) {
2027             /* We found extensions to be set from config file */
2028             X509V3_set_nconf(&ctx, lconf);
2029
2030             if (!X509V3_EXT_add_nconf(lconf, &ctx, ext_sect, ret)) {
2031                 BIO_printf(bio_err,
2032                            "ERROR: adding extensions in section %s\n",
2033                            ext_sect);
2034                 ERR_print_errors(bio_err);
2035                 goto err;
2036             }
2037
2038             if (verbose)
2039                 BIO_printf(bio_err,
2040                            "Successfully added extensions from config\n");
2041         }
2042     }
2043
2044     /* Copy extensions from request (if any) */
2045
2046     if (!copy_extensions(ret, req, ext_copy)) {
2047         BIO_printf(bio_err, "ERROR: adding extensions from request\n");
2048         ERR_print_errors(bio_err);
2049         goto err;
2050     }
2051
2052     /* Set the right value for the noemailDN option */
2053     if (email_dn == 0) {
2054         if (!X509_set_subject_name(ret, dn_subject))
2055             goto err;
2056     }
2057
2058     if (!default_op) {
2059         BIO_printf(bio_err, "Certificate Details:\n");
2060         /*
2061          * Never print signature details because signature not present
2062          */
2063         certopt |= X509_FLAG_NO_SIGDUMP | X509_FLAG_NO_SIGNAME;
2064         X509_print_ex(bio_err, ret, nameopt, certopt);
2065     }
2066
2067     BIO_printf(bio_err, "Certificate is to be certified until ");
2068     ASN1_TIME_print(bio_err, X509_get_notAfter(ret));
2069     if (days)
2070         BIO_printf(bio_err, " (%ld days)", days);
2071     BIO_printf(bio_err, "\n");
2072
2073     if (!batch) {
2074
2075         BIO_printf(bio_err, "Sign the certificate? [y/n]:");
2076         (void)BIO_flush(bio_err);
2077         buf[0] = '\0';
2078         if (!fgets(buf, sizeof(buf) - 1, stdin)) {
2079             BIO_printf(bio_err,
2080                        "CERTIFICATE WILL NOT BE CERTIFIED: I/O error\n");
2081             ok = 0;
2082             goto err;
2083         }
2084         if (!((buf[0] == 'y') || (buf[0] == 'Y'))) {
2085             BIO_printf(bio_err, "CERTIFICATE WILL NOT BE CERTIFIED\n");
2086             ok = 0;
2087             goto err;
2088         }
2089     }
2090
2091     pktmp = X509_get_pubkey(ret);
2092     if (EVP_PKEY_missing_parameters(pktmp) &&
2093         !EVP_PKEY_missing_parameters(pkey))
2094         EVP_PKEY_copy_parameters(pktmp, pkey);
2095     EVP_PKEY_free(pktmp);
2096
2097     if (!do_X509_sign(bio_err, ret, pkey, dgst, sigopts))
2098         goto err;
2099
2100     /* We now just add it to the database */
2101     row[DB_type] = (char *)OPENSSL_malloc(2);
2102
2103     tm = X509_get_notAfter(ret);
2104     row[DB_exp_date] = (char *)OPENSSL_malloc(tm->length + 1);
2105     memcpy(row[DB_exp_date], tm->data, tm->length);
2106     row[DB_exp_date][tm->length] = '\0';
2107
2108     row[DB_rev_date] = NULL;
2109
2110     /* row[DB_serial] done already */
2111     row[DB_file] = (char *)OPENSSL_malloc(8);
2112     row[DB_name] = X509_NAME_oneline(X509_get_subject_name(ret), NULL, 0);
2113
2114     if ((row[DB_type] == NULL) || (row[DB_exp_date] == NULL) ||
2115         (row[DB_file] == NULL) || (row[DB_name] == NULL)) {
2116         BIO_printf(bio_err, "Memory allocation failure\n");
2117         goto err;
2118     }
2119     BUF_strlcpy(row[DB_file], "unknown", 8);
2120     row[DB_type][0] = 'V';
2121     row[DB_type][1] = '\0';
2122
2123     if ((irow =
2124          (char **)OPENSSL_malloc(sizeof(char *) * (DB_NUMBER + 1))) == NULL) {
2125         BIO_printf(bio_err, "Memory allocation failure\n");
2126         goto err;
2127     }
2128
2129     for (i = 0; i < DB_NUMBER; i++) {
2130         irow[i] = row[i];
2131         row[i] = NULL;
2132     }
2133     irow[DB_NUMBER] = NULL;
2134
2135     if (!TXT_DB_insert(db->db, irow)) {
2136         BIO_printf(bio_err, "failed to update database\n");
2137         BIO_printf(bio_err, "TXT_DB error number %ld\n", db->db->error);
2138         goto err;
2139     }
2140     ok = 1;
2141  err:
2142     for (i = 0; i < DB_NUMBER; i++)
2143         if (row[i] != NULL)
2144             OPENSSL_free(row[i]);
2145
2146     if (CAname != NULL)
2147         X509_NAME_free(CAname);
2148     if (subject != NULL)
2149         X509_NAME_free(subject);
2150     if ((dn_subject != NULL) && !email_dn)
2151         X509_NAME_free(dn_subject);
2152     if (tmptm != NULL)
2153         ASN1_UTCTIME_free(tmptm);
2154     if (ok <= 0) {
2155         if (ret != NULL)
2156             X509_free(ret);
2157         ret = NULL;
2158     } else
2159         *xret = ret;
2160     return (ok);
2161 }
2162
2163 static void write_new_certificate(BIO *bp, X509 *x, int output_der,
2164                                   int notext)
2165 {
2166
2167     if (output_der) {
2168         (void)i2d_X509_bio(bp, x);
2169         return;
2170     }
2171 #if 0
2172     /* ??? Not needed since X509_print prints all this stuff anyway */
2173     f = X509_NAME_oneline(X509_get_issuer_name(x), buf, 256);
2174     BIO_printf(bp, "issuer :%s\n", f);
2175
2176     f = X509_NAME_oneline(X509_get_subject_name(x), buf, 256);
2177     BIO_printf(bp, "subject:%s\n", f);
2178
2179     BIO_puts(bp, "serial :");
2180     i2a_ASN1_INTEGER(bp, x->cert_info->serialNumber);
2181     BIO_puts(bp, "\n\n");
2182 #endif
2183     if (!notext)
2184         X509_print(bp, x);
2185     PEM_write_bio_X509(bp, x);
2186 }
2187
2188 static int certify_spkac(X509 **xret, char *infile, EVP_PKEY *pkey,
2189                          X509 *x509, const EVP_MD *dgst,
2190                          STACK_OF(OPENSSL_STRING) *sigopts,
2191                          STACK_OF(CONF_VALUE) *policy, CA_DB *db,
2192                          BIGNUM *serial, char *subj, unsigned long chtype,
2193                          int multirdn, int email_dn, char *startdate,
2194                          char *enddate, long days, char *ext_sect,
2195                          CONF *lconf, int verbose, unsigned long certopt,
2196                          unsigned long nameopt, int default_op, int ext_copy)
2197 {
2198     STACK_OF(CONF_VALUE) *sk = NULL;
2199     LHASH_OF(CONF_VALUE) *parms = NULL;
2200     X509_REQ *req = NULL;
2201     CONF_VALUE *cv = NULL;
2202     NETSCAPE_SPKI *spki = NULL;
2203     X509_REQ_INFO *ri;
2204     char *type, *buf;
2205     EVP_PKEY *pktmp = NULL;
2206     X509_NAME *n = NULL;
2207     X509_NAME_ENTRY *ne = NULL;
2208     int ok = -1, i, j;
2209     long errline;
2210     int nid;
2211
2212     /*
2213      * Load input file into a hash table.  (This is just an easy
2214      * way to read and parse the file, then put it into a convenient
2215      * STACK format).
2216      */
2217     parms = CONF_load(NULL, infile, &errline);
2218     if (parms == NULL) {
2219         BIO_printf(bio_err, "error on line %ld of %s\n", errline, infile);
2220         ERR_print_errors(bio_err);
2221         goto err;
2222     }
2223
2224     sk = CONF_get_section(parms, "default");
2225     if (sk_CONF_VALUE_num(sk) == 0) {
2226         BIO_printf(bio_err, "no name/value pairs found in %s\n", infile);
2227         CONF_free(parms);
2228         goto err;
2229     }
2230
2231     /*
2232      * Now create a dummy X509 request structure.  We don't actually
2233      * have an X509 request, but we have many of the components
2234      * (a public key, various DN components).  The idea is that we
2235      * put these components into the right X509 request structure
2236      * and we can use the same code as if you had a real X509 request.
2237      */
2238     req = X509_REQ_new();
2239     if (req == NULL) {
2240         ERR_print_errors(bio_err);
2241         goto err;
2242     }
2243
2244     /*
2245      * Build up the subject name set.
2246      */
2247     ri = req->req_info;
2248     n = ri->subject;
2249
2250     for (i = 0;; i++) {
2251         if (sk_CONF_VALUE_num(sk) <= i)
2252             break;
2253
2254         cv = sk_CONF_VALUE_value(sk, i);
2255         type = cv->name;
2256         /*
2257          * Skip past any leading X. X: X, etc to allow for multiple instances
2258          */
2259         for (buf = cv->name; *buf; buf++)
2260             if ((*buf == ':') || (*buf == ',') || (*buf == '.')) {
2261                 buf++;
2262                 if (*buf)
2263                     type = buf;
2264                 break;
2265             }
2266
2267         buf = cv->value;
2268         if ((nid = OBJ_txt2nid(type)) == NID_undef) {
2269             if (strcmp(type, "SPKAC") == 0) {
2270                 spki = NETSCAPE_SPKI_b64_decode(cv->value, -1);
2271                 if (spki == NULL) {
2272                     BIO_printf(bio_err,
2273                                "unable to load Netscape SPKAC structure\n");
2274                     ERR_print_errors(bio_err);
2275                     goto err;
2276                 }
2277             }
2278             continue;
2279         }
2280
2281         if (!X509_NAME_add_entry_by_NID(n, nid, chtype,
2282                                         (unsigned char *)buf, -1, -1, 0))
2283             goto err;
2284     }
2285     if (spki == NULL) {
2286         BIO_printf(bio_err, "Netscape SPKAC structure not found in %s\n",
2287                    infile);
2288         goto err;
2289     }
2290
2291     /*
2292      * Now extract the key from the SPKI structure.
2293      */
2294
2295     BIO_printf(bio_err,
2296                "Check that the SPKAC request matches the signature\n");
2297
2298     if ((pktmp = NETSCAPE_SPKI_get_pubkey(spki)) == NULL) {
2299         BIO_printf(bio_err, "error unpacking SPKAC public key\n");
2300         goto err;
2301     }
2302
2303     j = NETSCAPE_SPKI_verify(spki, pktmp);
2304     if (j <= 0) {
2305         BIO_printf(bio_err,
2306                    "signature verification failed on SPKAC public key\n");
2307         goto err;
2308     }
2309     BIO_printf(bio_err, "Signature ok\n");
2310
2311     X509_REQ_set_pubkey(req, pktmp);
2312     EVP_PKEY_free(pktmp);
2313     ok = do_body(xret, pkey, x509, dgst, sigopts, policy, db, serial, subj,
2314                  chtype, multirdn, email_dn, startdate, enddate, days, 1,
2315                  verbose, req, ext_sect, lconf, certopt, nameopt, default_op,
2316                  ext_copy, 0);
2317  err:
2318     if (req != NULL)
2319         X509_REQ_free(req);
2320     if (parms != NULL)
2321         CONF_free(parms);
2322     if (spki != NULL)
2323         NETSCAPE_SPKI_free(spki);
2324     if (ne != NULL)
2325         X509_NAME_ENTRY_free(ne);
2326
2327     return (ok);
2328 }
2329
2330 static int check_time_format(const char *str)
2331 {
2332     return ASN1_TIME_set_string(NULL, str);
2333 }
2334
2335 static int do_revoke(X509 *x509, CA_DB *db, int type, char *value)
2336 {
2337     ASN1_UTCTIME *tm = NULL;
2338     char *row[DB_NUMBER], **rrow, **irow;
2339     char *rev_str = NULL;
2340     BIGNUM *bn = NULL;
2341     int ok = -1, i;
2342
2343     for (i = 0; i < DB_NUMBER; i++)
2344         row[i] = NULL;
2345     row[DB_name] = X509_NAME_oneline(X509_get_subject_name(x509), NULL, 0);
2346     bn = ASN1_INTEGER_to_BN(X509_get_serialNumber(x509), NULL);
2347     if (!bn)
2348         goto err;
2349     if (BN_is_zero(bn))
2350         row[DB_serial] = BUF_strdup("00");
2351     else
2352         row[DB_serial] = BN_bn2hex(bn);
2353     BN_free(bn);
2354     if ((row[DB_name] == NULL) || (row[DB_serial] == NULL)) {
2355         BIO_printf(bio_err, "Memory allocation failure\n");
2356         goto err;
2357     }
2358     /*
2359      * We have to lookup by serial number because name lookup skips revoked
2360      * certs
2361      */
2362     rrow = TXT_DB_get_by_index(db->db, DB_serial, row);
2363     if (rrow == NULL) {
2364         BIO_printf(bio_err,
2365                    "Adding Entry with serial number %s to DB for %s\n",
2366                    row[DB_serial], row[DB_name]);
2367
2368         /* We now just add it to the database */
2369         row[DB_type] = (char *)OPENSSL_malloc(2);
2370
2371         tm = X509_get_notAfter(x509);
2372         row[DB_exp_date] = (char *)OPENSSL_malloc(tm->length + 1);
2373         memcpy(row[DB_exp_date], tm->data, tm->length);
2374         row[DB_exp_date][tm->length] = '\0';
2375
2376         row[DB_rev_date] = NULL;
2377
2378         /* row[DB_serial] done already */
2379         row[DB_file] = (char *)OPENSSL_malloc(8);
2380
2381         /* row[DB_name] done already */
2382
2383         if ((row[DB_type] == NULL) || (row[DB_exp_date] == NULL) ||
2384             (row[DB_file] == NULL)) {
2385             BIO_printf(bio_err, "Memory allocation failure\n");
2386             goto err;
2387         }
2388         BUF_strlcpy(row[DB_file], "unknown", 8);
2389         row[DB_type][0] = 'V';
2390         row[DB_type][1] = '\0';
2391
2392         if ((irow =
2393              (char **)OPENSSL_malloc(sizeof(char *) * (DB_NUMBER + 1))) ==
2394             NULL) {
2395             BIO_printf(bio_err, "Memory allocation failure\n");
2396             goto err;
2397         }
2398
2399         for (i = 0; i < DB_NUMBER; i++) {
2400             irow[i] = row[i];
2401             row[i] = NULL;
2402         }
2403         irow[DB_NUMBER] = NULL;
2404
2405         if (!TXT_DB_insert(db->db, irow)) {
2406             BIO_printf(bio_err, "failed to update database\n");
2407             BIO_printf(bio_err, "TXT_DB error number %ld\n", db->db->error);
2408             goto err;
2409         }
2410
2411         /* Revoke Certificate */
2412         ok = do_revoke(x509, db, type, value);
2413
2414         goto err;
2415
2416     } else if (index_name_cmp_noconst(row, rrow)) {
2417         BIO_printf(bio_err, "ERROR:name does not match %s\n", row[DB_name]);
2418         goto err;
2419     } else if (rrow[DB_type][0] == 'R') {
2420         BIO_printf(bio_err, "ERROR:Already revoked, serial number %s\n",
2421                    row[DB_serial]);
2422         goto err;
2423     } else {
2424         BIO_printf(bio_err, "Revoking Certificate %s.\n", rrow[DB_serial]);
2425         rev_str = make_revocation_str(type, value);
2426         if (!rev_str) {
2427             BIO_printf(bio_err, "Error in revocation arguments\n");
2428             goto err;
2429         }
2430         rrow[DB_type][0] = 'R';
2431         rrow[DB_type][1] = '\0';
2432         rrow[DB_rev_date] = rev_str;
2433     }
2434     ok = 1;
2435  err:
2436     for (i = 0; i < DB_NUMBER; i++) {
2437         if (row[i] != NULL)
2438             OPENSSL_free(row[i]);
2439     }
2440     return (ok);
2441 }
2442
2443 static int get_certificate_status(const char *serial, CA_DB *db)
2444 {
2445     char *row[DB_NUMBER], **rrow;
2446     int ok = -1, i;
2447
2448     /* Free Resources */
2449     for (i = 0; i < DB_NUMBER; i++)
2450         row[i] = NULL;
2451
2452     /* Malloc needed char spaces */
2453     row[DB_serial] = OPENSSL_malloc(strlen(serial) + 2);
2454     if (row[DB_serial] == NULL) {
2455         BIO_printf(bio_err, "Malloc failure\n");
2456         goto err;
2457     }
2458
2459     if (strlen(serial) % 2) {
2460         /*
2461          * Set the first char to 0
2462          */ ;
2463         row[DB_serial][0] = '0';
2464
2465         /* Copy String from serial to row[DB_serial] */
2466         memcpy(row[DB_serial] + 1, serial, strlen(serial));
2467         row[DB_serial][strlen(serial) + 1] = '\0';
2468     } else {
2469         /* Copy String from serial to row[DB_serial] */
2470         memcpy(row[DB_serial], serial, strlen(serial));
2471         row[DB_serial][strlen(serial)] = '\0';
2472     }
2473
2474     /* Make it Upper Case */
2475     for (i = 0; row[DB_serial][i] != '\0'; i++)
2476         row[DB_serial][i] = toupper((unsigned char)row[DB_serial][i]);
2477
2478     ok = 1;
2479
2480     /* Search for the certificate */
2481     rrow = TXT_DB_get_by_index(db->db, DB_serial, row);
2482     if (rrow == NULL) {
2483         BIO_printf(bio_err, "Serial %s not present in db.\n", row[DB_serial]);
2484         ok = -1;
2485         goto err;
2486     } else if (rrow[DB_type][0] == 'V') {
2487         BIO_printf(bio_err, "%s=Valid (%c)\n",
2488                    row[DB_serial], rrow[DB_type][0]);
2489         goto err;
2490     } else if (rrow[DB_type][0] == 'R') {
2491         BIO_printf(bio_err, "%s=Revoked (%c)\n",
2492                    row[DB_serial], rrow[DB_type][0]);
2493         goto err;
2494     } else if (rrow[DB_type][0] == 'E') {
2495         BIO_printf(bio_err, "%s=Expired (%c)\n",
2496                    row[DB_serial], rrow[DB_type][0]);
2497         goto err;
2498     } else if (rrow[DB_type][0] == 'S') {
2499         BIO_printf(bio_err, "%s=Suspended (%c)\n",
2500                    row[DB_serial], rrow[DB_type][0]);
2501         goto err;
2502     } else {
2503         BIO_printf(bio_err, "%s=Unknown (%c).\n",
2504                    row[DB_serial], rrow[DB_type][0]);
2505         ok = -1;
2506     }
2507  err:
2508     for (i = 0; i < DB_NUMBER; i++) {
2509         if (row[i] != NULL)
2510             OPENSSL_free(row[i]);
2511     }
2512     return (ok);
2513 }
2514
2515 static int do_updatedb(CA_DB *db)
2516 {
2517     ASN1_UTCTIME *a_tm = NULL;
2518     int i, cnt = 0;
2519     int db_y2k, a_y2k;          /* flags = 1 if y >= 2000 */
2520     char **rrow, *a_tm_s;
2521
2522     a_tm = ASN1_UTCTIME_new();
2523
2524     /* get actual time and make a string */
2525     a_tm = X509_gmtime_adj(a_tm, 0);
2526     a_tm_s = (char *)OPENSSL_malloc(a_tm->length + 1);
2527     if (a_tm_s == NULL) {
2528         cnt = -1;
2529         goto err;
2530     }
2531
2532     memcpy(a_tm_s, a_tm->data, a_tm->length);
2533     a_tm_s[a_tm->length] = '\0';
2534
2535     if (strncmp(a_tm_s, "49", 2) <= 0)
2536         a_y2k = 1;
2537     else
2538         a_y2k = 0;
2539
2540     for (i = 0; i < sk_OPENSSL_PSTRING_num(db->db->data); i++) {
2541         rrow = sk_OPENSSL_PSTRING_value(db->db->data, i);
2542
2543         if (rrow[DB_type][0] == 'V') {
2544             /* ignore entries that are not valid */
2545             if (strncmp(rrow[DB_exp_date], "49", 2) <= 0)
2546                 db_y2k = 1;
2547             else
2548                 db_y2k = 0;
2549
2550             if (db_y2k == a_y2k) {
2551                 /* all on the same y2k side */
2552                 if (strcmp(rrow[DB_exp_date], a_tm_s) <= 0) {
2553                     rrow[DB_type][0] = 'E';
2554                     rrow[DB_type][1] = '\0';
2555                     cnt++;
2556
2557                     BIO_printf(bio_err, "%s=Expired\n", rrow[DB_serial]);
2558                 }
2559             } else if (db_y2k < a_y2k) {
2560                 rrow[DB_type][0] = 'E';
2561                 rrow[DB_type][1] = '\0';
2562                 cnt++;
2563
2564                 BIO_printf(bio_err, "%s=Expired\n", rrow[DB_serial]);
2565             }
2566
2567         }
2568     }
2569
2570  err:
2571
2572     ASN1_UTCTIME_free(a_tm);
2573     OPENSSL_free(a_tm_s);
2574
2575     return (cnt);
2576 }
2577
2578 static const char *crl_reasons[] = {
2579     /* CRL reason strings */
2580     "unspecified",
2581     "keyCompromise",
2582     "CACompromise",
2583     "affiliationChanged",
2584     "superseded",
2585     "cessationOfOperation",
2586     "certificateHold",
2587     "removeFromCRL",
2588     /* Additional pseudo reasons */
2589     "holdInstruction",
2590     "keyTime",
2591     "CAkeyTime"
2592 };
2593
2594 #define NUM_REASONS (sizeof(crl_reasons) / sizeof(char *))
2595
2596 /*
2597  * Given revocation information convert to a DB string. The format of the
2598  * string is: revtime[,reason,extra]. Where 'revtime' is the revocation time
2599  * (the current time). 'reason' is the optional CRL reason and 'extra' is any
2600  * additional argument
2601  */
2602
2603 char *make_revocation_str(int rev_type, char *rev_arg)
2604 {
2605     char *other = NULL, *str;
2606     const char *reason = NULL;
2607     ASN1_OBJECT *otmp;
2608     ASN1_UTCTIME *revtm = NULL;
2609     int i;
2610     switch (rev_type) {
2611     case REV_NONE:
2612         break;
2613
2614     case REV_CRL_REASON:
2615         for (i = 0; i < 8; i++) {
2616             if (!strcasecmp(rev_arg, crl_reasons[i])) {
2617                 reason = crl_reasons[i];
2618                 break;
2619             }
2620         }
2621         if (reason == NULL) {
2622             BIO_printf(bio_err, "Unknown CRL reason %s\n", rev_arg);
2623             return NULL;
2624         }
2625         break;
2626
2627     case REV_HOLD:
2628         /* Argument is an OID */
2629
2630         otmp = OBJ_txt2obj(rev_arg, 0);
2631         ASN1_OBJECT_free(otmp);
2632
2633         if (otmp == NULL) {
2634             BIO_printf(bio_err, "Invalid object identifier %s\n", rev_arg);
2635             return NULL;
2636         }
2637
2638         reason = "holdInstruction";
2639         other = rev_arg;
2640         break;
2641
2642     case REV_KEY_COMPROMISE:
2643     case REV_CA_COMPROMISE:
2644
2645         /* Argument is the key compromise time  */
2646         if (!ASN1_GENERALIZEDTIME_set_string(NULL, rev_arg)) {
2647             BIO_printf(bio_err,
2648                        "Invalid time format %s. Need YYYYMMDDHHMMSSZ\n",
2649                        rev_arg);
2650             return NULL;
2651         }
2652         other = rev_arg;
2653         if (rev_type == REV_KEY_COMPROMISE)
2654             reason = "keyTime";
2655         else
2656             reason = "CAkeyTime";
2657
2658         break;
2659
2660     }
2661
2662     revtm = X509_gmtime_adj(NULL, 0);
2663
2664     if (!revtm)
2665         return NULL;
2666
2667     i = revtm->length + 1;
2668
2669     if (reason)
2670         i += strlen(reason) + 1;
2671     if (other)
2672         i += strlen(other) + 1;
2673
2674     str = OPENSSL_malloc(i);
2675
2676     if (!str)
2677         return NULL;
2678
2679     BUF_strlcpy(str, (char *)revtm->data, i);
2680     if (reason) {
2681         BUF_strlcat(str, ",", i);
2682         BUF_strlcat(str, reason, i);
2683     }
2684     if (other) {
2685         BUF_strlcat(str, ",", i);
2686         BUF_strlcat(str, other, i);
2687     }
2688     ASN1_UTCTIME_free(revtm);
2689     return str;
2690 }
2691
2692 /*-
2693  * Convert revocation field to X509_REVOKED entry
2694  * return code:
2695  * 0 error
2696  * 1 OK
2697  * 2 OK and some extensions added (i.e. V2 CRL)
2698  */
2699
2700 int make_revoked(X509_REVOKED *rev, const char *str)
2701 {
2702     char *tmp = NULL;
2703     int reason_code = -1;
2704     int i, ret = 0;
2705     ASN1_OBJECT *hold = NULL;
2706     ASN1_GENERALIZEDTIME *comp_time = NULL;
2707     ASN1_ENUMERATED *rtmp = NULL;
2708
2709     ASN1_TIME *revDate = NULL;
2710
2711     i = unpack_revinfo(&revDate, &reason_code, &hold, &comp_time, str);
2712
2713     if (i == 0)
2714         goto err;
2715
2716     if (rev && !X509_REVOKED_set_revocationDate(rev, revDate))
2717         goto err;
2718
2719     if (rev && (reason_code != OCSP_REVOKED_STATUS_NOSTATUS)) {
2720         rtmp = ASN1_ENUMERATED_new();
2721         if (!rtmp || !ASN1_ENUMERATED_set(rtmp, reason_code))
2722             goto err;
2723         if (!X509_REVOKED_add1_ext_i2d(rev, NID_crl_reason, rtmp, 0, 0))
2724             goto err;
2725     }
2726
2727     if (rev && comp_time) {
2728         if (!X509_REVOKED_add1_ext_i2d
2729             (rev, NID_invalidity_date, comp_time, 0, 0))
2730             goto err;
2731     }
2732     if (rev && hold) {
2733         if (!X509_REVOKED_add1_ext_i2d
2734             (rev, NID_hold_instruction_code, hold, 0, 0))
2735             goto err;
2736     }
2737
2738     if (reason_code != OCSP_REVOKED_STATUS_NOSTATUS)
2739         ret = 2;
2740     else
2741         ret = 1;
2742
2743  err:
2744
2745     if (tmp)
2746         OPENSSL_free(tmp);
2747     ASN1_OBJECT_free(hold);
2748     ASN1_GENERALIZEDTIME_free(comp_time);
2749     ASN1_ENUMERATED_free(rtmp);
2750     ASN1_TIME_free(revDate);
2751
2752     return ret;
2753 }
2754
2755 int old_entry_print(BIO *bp, ASN1_OBJECT *obj, ASN1_STRING *str)
2756 {
2757     char buf[25], *pbuf, *p;
2758     int j;
2759     j = i2a_ASN1_OBJECT(bp, obj);
2760     pbuf = buf;
2761     for (j = 22 - j; j > 0; j--)
2762         *(pbuf++) = ' ';
2763     *(pbuf++) = ':';
2764     *(pbuf++) = '\0';
2765     BIO_puts(bp, buf);
2766
2767     if (str->type == V_ASN1_PRINTABLESTRING)
2768         BIO_printf(bp, "PRINTABLE:'");
2769     else if (str->type == V_ASN1_T61STRING)
2770         BIO_printf(bp, "T61STRING:'");
2771     else if (str->type == V_ASN1_IA5STRING)
2772         BIO_printf(bp, "IA5STRING:'");
2773     else if (str->type == V_ASN1_UNIVERSALSTRING)
2774         BIO_printf(bp, "UNIVERSALSTRING:'");
2775     else
2776         BIO_printf(bp, "ASN.1 %2d:'", str->type);
2777
2778     p = (char *)str->data;
2779     for (j = str->length; j > 0; j--) {
2780         if ((*p >= ' ') && (*p <= '~'))
2781             BIO_printf(bp, "%c", *p);
2782         else if (*p & 0x80)
2783             BIO_printf(bp, "\\0x%02X", *p);
2784         else if ((unsigned char)*p == 0xf7)
2785             BIO_printf(bp, "^?");
2786         else
2787             BIO_printf(bp, "^%c", *p + '@');
2788         p++;
2789     }
2790     BIO_printf(bp, "'\n");
2791     return 1;
2792 }
2793
2794 int unpack_revinfo(ASN1_TIME **prevtm, int *preason, ASN1_OBJECT **phold,
2795                    ASN1_GENERALIZEDTIME **pinvtm, const char *str)
2796 {
2797     char *tmp = NULL;
2798     char *rtime_str, *reason_str = NULL, *arg_str = NULL, *p;
2799     int reason_code = -1;
2800     int ret = 0;
2801     unsigned int i;
2802     ASN1_OBJECT *hold = NULL;
2803     ASN1_GENERALIZEDTIME *comp_time = NULL;
2804     tmp = BUF_strdup(str);
2805
2806     if(!tmp) {
2807         BIO_printf(bio_err, "memory allocation failure\n");
2808         goto err;
2809     }
2810
2811     p = strchr(tmp, ',');
2812
2813     rtime_str = tmp;
2814
2815     if (p) {
2816         *p = '\0';
2817         p++;
2818         reason_str = p;
2819         p = strchr(p, ',');
2820         if (p) {
2821             *p = '\0';
2822             arg_str = p + 1;
2823         }
2824     }
2825
2826     if (prevtm) {
2827         *prevtm = ASN1_UTCTIME_new();
2828         if(!*prevtm) {
2829             BIO_printf(bio_err, "memory allocation failure\n");
2830             goto err;
2831         }
2832         if (!ASN1_UTCTIME_set_string(*prevtm, rtime_str)) {
2833             BIO_printf(bio_err, "invalid revocation date %s\n", rtime_str);
2834             goto err;
2835         }
2836     }
2837     if (reason_str) {
2838         for (i = 0; i < NUM_REASONS; i++) {
2839             if (!strcasecmp(reason_str, crl_reasons[i])) {
2840                 reason_code = i;
2841                 break;
2842             }
2843         }
2844         if (reason_code == OCSP_REVOKED_STATUS_NOSTATUS) {
2845             BIO_printf(bio_err, "invalid reason code %s\n", reason_str);
2846             goto err;
2847         }
2848
2849         if (reason_code == 7)
2850             reason_code = OCSP_REVOKED_STATUS_REMOVEFROMCRL;
2851         else if (reason_code == 8) { /* Hold instruction */
2852             if (!arg_str) {
2853                 BIO_printf(bio_err, "missing hold instruction\n");
2854                 goto err;
2855             }
2856             reason_code = OCSP_REVOKED_STATUS_CERTIFICATEHOLD;
2857             hold = OBJ_txt2obj(arg_str, 0);
2858
2859             if (!hold) {
2860                 BIO_printf(bio_err, "invalid object identifier %s\n",
2861                            arg_str);
2862                 goto err;
2863             }
2864             if (phold)
2865                 *phold = hold;
2866         } else if ((reason_code == 9) || (reason_code == 10)) {
2867             if (!arg_str) {
2868                 BIO_printf(bio_err, "missing compromised time\n");
2869                 goto err;
2870             }
2871             comp_time = ASN1_GENERALIZEDTIME_new();
2872             if(!comp_time) {
2873                 BIO_printf(bio_err, "memory allocation failure\n");
2874                 goto err;
2875             }
2876             if (!ASN1_GENERALIZEDTIME_set_string(comp_time, arg_str)) {
2877                 BIO_printf(bio_err, "invalid compromised time %s\n", arg_str);
2878                 goto err;
2879             }
2880             if (reason_code == 9)
2881                 reason_code = OCSP_REVOKED_STATUS_KEYCOMPROMISE;
2882             else
2883                 reason_code = OCSP_REVOKED_STATUS_CACOMPROMISE;
2884         }
2885     }
2886
2887     if (preason)
2888         *preason = reason_code;
2889     if (pinvtm)
2890         *pinvtm = comp_time;
2891     else
2892         ASN1_GENERALIZEDTIME_free(comp_time);
2893
2894     ret = 1;
2895
2896  err:
2897
2898     if (tmp)
2899         OPENSSL_free(tmp);
2900     if (!phold)
2901         ASN1_OBJECT_free(hold);
2902     if (!pinvtm)
2903         ASN1_GENERALIZEDTIME_free(comp_time);
2904
2905     return ret;
2906 }