Set certificate times in one function.
[openssl.git] / apps / req.c
1 /*
2  * Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved.
3  *
4  * Licensed under the OpenSSL license (the "License").  You may not use
5  * this file except in compliance with the License.  You can obtain a copy
6  * in the file LICENSE in the source distribution or at
7  * https://www.openssl.org/source/license.html
8  */
9
10 #include <stdio.h>
11 #include <stdlib.h>
12 #include <time.h>
13 #include <string.h>
14 #include "apps.h"
15 #include <openssl/bio.h>
16 #include <openssl/evp.h>
17 #include <openssl/conf.h>
18 #include <openssl/err.h>
19 #include <openssl/asn1.h>
20 #include <openssl/x509.h>
21 #include <openssl/x509v3.h>
22 #include <openssl/objects.h>
23 #include <openssl/pem.h>
24 #include <openssl/bn.h>
25 #ifndef OPENSSL_NO_RSA
26 # include <openssl/rsa.h>
27 #endif
28 #ifndef OPENSSL_NO_DSA
29 # include <openssl/dsa.h>
30 #endif
31
32 #define SECTION         "req"
33
34 #define BITS            "default_bits"
35 #define KEYFILE         "default_keyfile"
36 #define PROMPT          "prompt"
37 #define DISTINGUISHED_NAME      "distinguished_name"
38 #define ATTRIBUTES      "attributes"
39 #define V3_EXTENSIONS   "x509_extensions"
40 #define REQ_EXTENSIONS  "req_extensions"
41 #define STRING_MASK     "string_mask"
42 #define UTF8_IN         "utf8"
43
44 #define DEFAULT_KEY_LENGTH      2048
45 #define MIN_KEY_LENGTH          512
46
47 static int make_REQ(X509_REQ *req, EVP_PKEY *pkey, char *dn, int mutlirdn,
48                     int attribs, unsigned long chtype);
49 static int build_subject(X509_REQ *req, const char *subj, unsigned long chtype,
50                          int multirdn);
51 static int prompt_info(X509_REQ *req,
52                        STACK_OF(CONF_VALUE) *dn_sk, const char *dn_sect,
53                        STACK_OF(CONF_VALUE) *attr_sk, const char *attr_sect,
54                        int attribs, unsigned long chtype);
55 static int auto_info(X509_REQ *req, STACK_OF(CONF_VALUE) *sk,
56                      STACK_OF(CONF_VALUE) *attr, int attribs,
57                      unsigned long chtype);
58 static int add_attribute_object(X509_REQ *req, char *text, const char *def,
59                                 char *value, int nid, int n_min, int n_max,
60                                 unsigned long chtype);
61 static int add_DN_object(X509_NAME *n, char *text, const char *def,
62                          char *value, int nid, int n_min, int n_max,
63                          unsigned long chtype, int mval);
64 static int genpkey_cb(EVP_PKEY_CTX *ctx);
65 static int req_check_len(int len, int n_min, int n_max);
66 static int check_end(const char *str, const char *end);
67 static EVP_PKEY_CTX *set_keygen_ctx(const char *gstr,
68                                     int *pkey_type, long *pkeylen,
69                                     char **palgnam, ENGINE *keygen_engine);
70 static CONF *req_conf = NULL;
71 static int batch = 0;
72
73 typedef enum OPTION_choice {
74     OPT_ERR = -1, OPT_EOF = 0, OPT_HELP,
75     OPT_INFORM, OPT_OUTFORM, OPT_ENGINE, OPT_KEYGEN_ENGINE, OPT_KEY,
76     OPT_PUBKEY, OPT_NEW, OPT_CONFIG, OPT_KEYFORM, OPT_IN, OPT_OUT,
77     OPT_KEYOUT, OPT_PASSIN, OPT_PASSOUT, OPT_RAND, OPT_NEWKEY,
78     OPT_PKEYOPT, OPT_SIGOPT, OPT_BATCH, OPT_NEWHDR, OPT_MODULUS,
79     OPT_VERIFY, OPT_NODES, OPT_NOOUT, OPT_VERBOSE, OPT_UTF8,
80     OPT_NAMEOPT, OPT_REQOPT, OPT_SUBJ, OPT_SUBJECT, OPT_TEXT, OPT_X509,
81     OPT_MULTIVALUE_RDN, OPT_DAYS, OPT_SET_SERIAL, OPT_EXTENSIONS,
82     OPT_REQEXTS, OPT_MD
83 } OPTION_CHOICE;
84
85 OPTIONS req_options[] = {
86     {"help", OPT_HELP, '-', "Display this summary"},
87     {"inform", OPT_INFORM, 'F', "Input format - DER or PEM"},
88     {"outform", OPT_OUTFORM, 'F', "Output format - DER or PEM"},
89     {"in", OPT_IN, '<', "Input file"},
90     {"out", OPT_OUT, '>', "Output file"},
91     {"key", OPT_KEY, 's', "Private key to use"},
92     {"keyform", OPT_KEYFORM, 'f', "Key file format"},
93     {"pubkey", OPT_PUBKEY, '-', "Output public key"},
94     {"new", OPT_NEW, '-', "New request"},
95     {"config", OPT_CONFIG, '<', "Request template file"},
96     {"keyout", OPT_KEYOUT, '>', "File to send the key to"},
97     {"passin", OPT_PASSIN, 's', "Private key password source"},
98     {"passout", OPT_PASSOUT, 's', "Output file pass phrase source"},
99     {"rand", OPT_RAND, 's',
100      "Load the file(s) into the random number generator"},
101     {"newkey", OPT_NEWKEY, 's', "Specify as type:bits"},
102     {"pkeyopt", OPT_PKEYOPT, 's', "Public key options as opt:value"},
103     {"sigopt", OPT_SIGOPT, 's', "Signature parameter in n:v form"},
104     {"batch", OPT_BATCH, '-',
105      "Do not ask anything during request generation"},
106     {"newhdr", OPT_NEWHDR, '-', "Output \"NEW\" in the header lines"},
107     {"modulus", OPT_MODULUS, '-', "RSA modulus"},
108     {"verify", OPT_VERIFY, '-', "Verify signature on REQ"},
109     {"nodes", OPT_NODES, '-', "Don't encrypt the output key"},
110     {"noout", OPT_NOOUT, '-', "Do not output REQ"},
111     {"verbose", OPT_VERBOSE, '-', "Verbose output"},
112     {"utf8", OPT_UTF8, '-', "Input characters are UTF8 (default ASCII)"},
113     {"nameopt", OPT_NAMEOPT, 's', "Various certificate name options"},
114     {"reqopt", OPT_REQOPT, 's', "Various request text options"},
115     {"text", OPT_TEXT, '-', "Text form of request"},
116     {"x509", OPT_X509, '-',
117      "Output a x509 structure instead of a cert request"},
118     {OPT_MORE_STR, 1, 1, "(Required by some CA's)"},
119     {"subj", OPT_SUBJ, 's', "Set or modify request subject"},
120     {"subject", OPT_SUBJECT, '-', "Output the request's subject"},
121     {"multivalue-rdn", OPT_MULTIVALUE_RDN, '-',
122      "Enable support for multivalued RDNs"},
123     {"days", OPT_DAYS, 'p', "Number of days cert is valid for"},
124     {"set_serial", OPT_SET_SERIAL, 'p', "Serial number to use"},
125     {"extensions", OPT_EXTENSIONS, 's',
126      "Cert extension section (override value in config file)"},
127     {"reqexts", OPT_REQEXTS, 's',
128      "Request extension section (override value in config file)"},
129     {"", OPT_MD, '-', "Any supported digest"},
130 #ifndef OPENSSL_NO_ENGINE
131     {"engine", OPT_ENGINE, 's', "Use engine, possibly a hardware device"},
132     {"keygen_engine", OPT_KEYGEN_ENGINE, 's',
133      "Specify engine to be used for key generation operations"},
134 #endif
135     {NULL}
136 };
137
138 int req_main(int argc, char **argv)
139 {
140     ASN1_INTEGER *serial = NULL;
141     BIO *in = NULL, *out = NULL;
142     ENGINE *e = NULL, *gen_eng = NULL;
143     EVP_PKEY *pkey = NULL;
144     EVP_PKEY_CTX *genctx = NULL;
145     STACK_OF(OPENSSL_STRING) *pkeyopts = NULL, *sigopts = NULL;
146     X509 *x509ss = NULL;
147     X509_REQ *req = NULL;
148     const EVP_CIPHER *cipher = NULL;
149     const EVP_MD *md_alg = NULL, *digest = NULL;
150     char *extensions = NULL, *infile = NULL;
151     char *outfile = NULL, *keyfile = NULL, *inrand = NULL;
152     char *keyalgstr = NULL, *p, *prog, *passargin = NULL, *passargout = NULL;
153     char *passin = NULL, *passout = NULL;
154     char *nofree_passin = NULL, *nofree_passout = NULL;
155     char *req_exts = NULL, *subj = NULL;
156     char *template = default_config_file, *keyout = NULL;
157     const char *keyalg = NULL;
158     OPTION_CHOICE o;
159     int ret = 1, x509 = 0, days = 30, i = 0, newreq = 0, verbose = 0;
160     int pkey_type = -1, private = 0;
161     int informat = FORMAT_PEM, outformat = FORMAT_PEM, keyform = FORMAT_PEM;
162     int modulus = 0, multirdn = 0, verify = 0, noout = 0, text = 0;
163     int nodes = 0, newhdr = 0, subject = 0, pubkey = 0;
164     long newkey = -1;
165     unsigned long chtype = MBSTRING_ASC, nmflag = 0, reqflag = 0;
166     char nmflag_set = 0;
167
168 #ifndef OPENSSL_NO_DES
169     cipher = EVP_des_ede3_cbc();
170 #endif
171
172     prog = opt_init(argc, argv, req_options);
173     while ((o = opt_next()) != OPT_EOF) {
174         switch (o) {
175         case OPT_EOF:
176         case OPT_ERR:
177  opthelp:
178             BIO_printf(bio_err, "%s: Use -help for summary.\n", prog);
179             goto end;
180         case OPT_HELP:
181             opt_help(req_options);
182             ret = 0;
183             goto end;
184         case OPT_INFORM:
185             if (!opt_format(opt_arg(), OPT_FMT_PEMDER, &informat))
186                 goto opthelp;
187             break;
188         case OPT_OUTFORM:
189             if (!opt_format(opt_arg(), OPT_FMT_PEMDER, &outformat))
190                 goto opthelp;
191             break;
192         case OPT_ENGINE:
193             e = setup_engine(opt_arg(), 0);
194             break;
195         case OPT_KEYGEN_ENGINE:
196 #ifndef OPENSSL_NO_ENGINE
197             gen_eng = ENGINE_by_id(opt_arg());
198             if (gen_eng == NULL) {
199                 BIO_printf(bio_err, "Can't find keygen engine %s\n", *argv);
200                 goto opthelp;
201             }
202 #endif
203             break;
204         case OPT_KEY:
205             keyfile = opt_arg();
206             break;
207         case OPT_PUBKEY:
208             pubkey = 1;
209             break;
210         case OPT_NEW:
211             newreq = 1;
212             break;
213         case OPT_CONFIG:
214             template = opt_arg();
215             break;
216         case OPT_KEYFORM:
217             if (!opt_format(opt_arg(), OPT_FMT_ANY, &keyform))
218                 goto opthelp;
219             break;
220         case OPT_IN:
221             infile = opt_arg();
222             break;
223         case OPT_OUT:
224             outfile = opt_arg();
225             break;
226         case OPT_KEYOUT:
227             keyout = opt_arg();
228             break;
229         case OPT_PASSIN:
230             passargin = opt_arg();
231             break;
232         case OPT_PASSOUT:
233             passargout = opt_arg();
234             break;
235         case OPT_RAND:
236             inrand = opt_arg();
237             break;
238         case OPT_NEWKEY:
239             keyalg = opt_arg();
240             newreq = 1;
241             break;
242         case OPT_PKEYOPT:
243             if (!pkeyopts)
244                 pkeyopts = sk_OPENSSL_STRING_new_null();
245             if (!pkeyopts || !sk_OPENSSL_STRING_push(pkeyopts, opt_arg()))
246                 goto opthelp;
247             break;
248         case OPT_SIGOPT:
249             if (!sigopts)
250                 sigopts = sk_OPENSSL_STRING_new_null();
251             if (!sigopts || !sk_OPENSSL_STRING_push(sigopts, opt_arg()))
252                 goto opthelp;
253             break;
254         case OPT_BATCH:
255             batch = 1;
256             break;
257         case OPT_NEWHDR:
258             newhdr = 1;
259             break;
260         case OPT_MODULUS:
261             modulus = 1;
262             break;
263         case OPT_VERIFY:
264             verify = 1;
265             break;
266         case OPT_NODES:
267             nodes = 1;
268             break;
269         case OPT_NOOUT:
270             noout = 1;
271             break;
272         case OPT_VERBOSE:
273             verbose = 1;
274             break;
275         case OPT_UTF8:
276             chtype = MBSTRING_UTF8;
277             break;
278         case OPT_NAMEOPT:
279             nmflag_set = 1;
280             if (!set_name_ex(&nmflag, opt_arg()))
281                 goto opthelp;
282             break;
283         case OPT_REQOPT:
284             if (!set_cert_ex(&reqflag, opt_arg()))
285                 goto opthelp;
286             break;
287         case OPT_TEXT:
288             text = 1;
289             break;
290         case OPT_X509:
291             x509 = 1;
292             break;
293         case OPT_DAYS:
294             days = atoi(opt_arg());
295             break;
296         case OPT_SET_SERIAL:
297             serial = s2i_ASN1_INTEGER(NULL, opt_arg());
298             if (serial == NULL)
299                 goto opthelp;
300             break;
301         case OPT_SUBJECT:
302             subject = 1;
303             break;
304         case OPT_SUBJ:
305             subj = opt_arg();
306             break;
307         case OPT_MULTIVALUE_RDN:
308             multirdn = 1;
309             break;
310         case OPT_EXTENSIONS:
311             extensions = opt_arg();
312             break;
313         case OPT_REQEXTS:
314             req_exts = opt_arg();
315             break;
316         case OPT_MD:
317             if (!opt_md(opt_unknown(), &md_alg))
318                 goto opthelp;
319             digest = md_alg;
320             break;
321         }
322     }
323     argc = opt_num_rest();
324     if (argc != 0)
325         goto opthelp;
326
327     if (!nmflag_set)
328         nmflag = XN_FLAG_ONELINE;
329
330     /* TODO: simplify this as pkey is still always NULL here */
331     private = newreq && (pkey == NULL) ? 1 : 0;
332
333     if (!app_passwd(passargin, passargout, &passin, &passout)) {
334         BIO_printf(bio_err, "Error getting passwords\n");
335         goto end;
336     }
337
338     if (verbose)
339         BIO_printf(bio_err, "Using configuration from %s\n", template);
340     req_conf = app_load_config(template);
341     if (template != default_config_file && !app_load_modules(req_conf))
342         goto end;
343
344     if (req_conf != NULL) {
345         p = NCONF_get_string(req_conf, NULL, "oid_file");
346         if (p == NULL)
347             ERR_clear_error();
348         if (p != NULL) {
349             BIO *oid_bio;
350
351             oid_bio = BIO_new_file(p, "r");
352             if (oid_bio == NULL) {
353                 /*-
354                 BIO_printf(bio_err,"problems opening %s for extra oid's\n",p);
355                 ERR_print_errors(bio_err);
356                 */
357             } else {
358                 OBJ_create_objects(oid_bio);
359                 BIO_free(oid_bio);
360             }
361         }
362     }
363     if (!add_oid_section(req_conf))
364         goto end;
365
366     if (md_alg == NULL) {
367         p = NCONF_get_string(req_conf, SECTION, "default_md");
368         if (p == NULL)
369             ERR_clear_error();
370         else {
371             if (!opt_md(p, &md_alg))
372                 goto opthelp;
373             digest = md_alg;
374         }
375     }
376
377     if (!extensions) {
378         extensions = NCONF_get_string(req_conf, SECTION, V3_EXTENSIONS);
379         if (!extensions)
380             ERR_clear_error();
381     }
382     if (extensions) {
383         /* Check syntax of file */
384         X509V3_CTX ctx;
385         X509V3_set_ctx_test(&ctx);
386         X509V3_set_nconf(&ctx, req_conf);
387         if (!X509V3_EXT_add_nconf(req_conf, &ctx, extensions, NULL)) {
388             BIO_printf(bio_err,
389                        "Error Loading extension section %s\n", extensions);
390             goto end;
391         }
392     }
393
394     if (passin == NULL) {
395         passin = nofree_passin =
396             NCONF_get_string(req_conf, SECTION, "input_password");
397         if (passin == NULL)
398             ERR_clear_error();
399     }
400
401     if (passout == NULL) {
402         passout = nofree_passout =
403             NCONF_get_string(req_conf, SECTION, "output_password");
404         if (passout == NULL)
405             ERR_clear_error();
406     }
407
408     p = NCONF_get_string(req_conf, SECTION, STRING_MASK);
409     if (!p)
410         ERR_clear_error();
411
412     if (p && !ASN1_STRING_set_default_mask_asc(p)) {
413         BIO_printf(bio_err, "Invalid global string mask setting %s\n", p);
414         goto end;
415     }
416
417     if (chtype != MBSTRING_UTF8) {
418         p = NCONF_get_string(req_conf, SECTION, UTF8_IN);
419         if (!p)
420             ERR_clear_error();
421         else if (strcmp(p, "yes") == 0)
422             chtype = MBSTRING_UTF8;
423     }
424
425     if (!req_exts) {
426         req_exts = NCONF_get_string(req_conf, SECTION, REQ_EXTENSIONS);
427         if (!req_exts)
428             ERR_clear_error();
429     }
430     if (req_exts) {
431         /* Check syntax of file */
432         X509V3_CTX ctx;
433         X509V3_set_ctx_test(&ctx);
434         X509V3_set_nconf(&ctx, req_conf);
435         if (!X509V3_EXT_add_nconf(req_conf, &ctx, req_exts, NULL)) {
436             BIO_printf(bio_err,
437                        "Error Loading request extension section %s\n",
438                        req_exts);
439             goto end;
440         }
441     }
442
443     if (keyfile != NULL) {
444         pkey = load_key(keyfile, keyform, 0, passin, e, "Private Key");
445         if (!pkey) {
446             /* load_key() has already printed an appropriate message */
447             goto end;
448         } else {
449             char *randfile = NCONF_get_string(req_conf, SECTION, "RANDFILE");
450             if (randfile == NULL)
451                 ERR_clear_error();
452             app_RAND_load_file(randfile, 0);
453         }
454     }
455
456     if (newreq && (pkey == NULL)) {
457         char *randfile = NCONF_get_string(req_conf, SECTION, "RANDFILE");
458         if (randfile == NULL)
459             ERR_clear_error();
460         app_RAND_load_file(randfile, 0);
461         if (inrand)
462             app_RAND_load_files(inrand);
463
464         if (!NCONF_get_number(req_conf, SECTION, BITS, &newkey)) {
465             newkey = DEFAULT_KEY_LENGTH;
466         }
467
468         if (keyalg) {
469             genctx = set_keygen_ctx(keyalg, &pkey_type, &newkey,
470                                     &keyalgstr, gen_eng);
471             if (!genctx)
472                 goto end;
473         }
474
475         if (newkey < MIN_KEY_LENGTH
476             && (pkey_type == EVP_PKEY_RSA || pkey_type == EVP_PKEY_DSA)) {
477             BIO_printf(bio_err, "private key length is too short,\n");
478             BIO_printf(bio_err, "it needs to be at least %d bits, not %ld\n",
479                        MIN_KEY_LENGTH, newkey);
480             goto end;
481         }
482
483         if (!genctx) {
484             genctx = set_keygen_ctx(NULL, &pkey_type, &newkey,
485                                     &keyalgstr, gen_eng);
486             if (!genctx)
487                 goto end;
488         }
489
490         if (pkeyopts) {
491             char *genopt;
492             for (i = 0; i < sk_OPENSSL_STRING_num(pkeyopts); i++) {
493                 genopt = sk_OPENSSL_STRING_value(pkeyopts, i);
494                 if (pkey_ctrl_string(genctx, genopt) <= 0) {
495                     BIO_printf(bio_err, "parameter error \"%s\"\n", genopt);
496                     ERR_print_errors(bio_err);
497                     goto end;
498                 }
499             }
500         }
501
502         if (pkey_type == EVP_PKEY_EC) {
503             BIO_printf(bio_err, "Generating an EC private key\n");
504         } else {
505             BIO_printf(bio_err, "Generating a %ld bit %s private key\n",
506                        newkey, keyalgstr);
507         }
508
509         EVP_PKEY_CTX_set_cb(genctx, genpkey_cb);
510         EVP_PKEY_CTX_set_app_data(genctx, bio_err);
511
512         if (EVP_PKEY_keygen(genctx, &pkey) <= 0) {
513             BIO_puts(bio_err, "Error Generating Key\n");
514             goto end;
515         }
516
517         EVP_PKEY_CTX_free(genctx);
518         genctx = NULL;
519
520         app_RAND_write_file(randfile);
521
522         if (keyout == NULL) {
523             keyout = NCONF_get_string(req_conf, SECTION, KEYFILE);
524             if (keyout == NULL)
525                 ERR_clear_error();
526         }
527
528         if (keyout == NULL)
529             BIO_printf(bio_err, "writing new private key to stdout\n");
530         else
531             BIO_printf(bio_err, "writing new private key to '%s'\n", keyout);
532         out = bio_open_owner(keyout, outformat, private);
533         if (out == NULL)
534             goto end;
535
536         p = NCONF_get_string(req_conf, SECTION, "encrypt_rsa_key");
537         if (p == NULL) {
538             ERR_clear_error();
539             p = NCONF_get_string(req_conf, SECTION, "encrypt_key");
540             if (p == NULL)
541                 ERR_clear_error();
542         }
543         if ((p != NULL) && (strcmp(p, "no") == 0))
544             cipher = NULL;
545         if (nodes)
546             cipher = NULL;
547
548         i = 0;
549  loop:
550         assert(private);
551         if (!PEM_write_bio_PrivateKey(out, pkey, cipher,
552                                       NULL, 0, NULL, passout)) {
553             if ((ERR_GET_REASON(ERR_peek_error()) ==
554                  PEM_R_PROBLEMS_GETTING_PASSWORD) && (i < 3)) {
555                 ERR_clear_error();
556                 i++;
557                 goto loop;
558             }
559             goto end;
560         }
561         BIO_free(out);
562         out = NULL;
563         BIO_printf(bio_err, "-----\n");
564     }
565
566     if (!newreq) {
567         in = bio_open_default(infile, 'r', informat);
568         if (in == NULL)
569             goto end;
570
571         if (informat == FORMAT_ASN1)
572             req = d2i_X509_REQ_bio(in, NULL);
573         else
574             req = PEM_read_bio_X509_REQ(in, NULL, NULL, NULL);
575         if (req == NULL) {
576             BIO_printf(bio_err, "unable to load X509 request\n");
577             goto end;
578         }
579     }
580
581     if (newreq || x509) {
582         if (pkey == NULL) {
583             BIO_printf(bio_err, "you need to specify a private key\n");
584             goto end;
585         }
586
587         if (req == NULL) {
588             req = X509_REQ_new();
589             if (req == NULL) {
590                 goto end;
591             }
592
593             i = make_REQ(req, pkey, subj, multirdn, !x509, chtype);
594             subj = NULL;        /* done processing '-subj' option */
595             if (!i) {
596                 BIO_printf(bio_err, "problems making Certificate Request\n");
597                 goto end;
598             }
599         }
600         if (x509) {
601             EVP_PKEY *tmppkey;
602             X509V3_CTX ext_ctx;
603             if ((x509ss = X509_new()) == NULL)
604                 goto end;
605
606             /* Set version to V3 */
607             if (extensions && !X509_set_version(x509ss, 2))
608                 goto end;
609             if (serial) {
610                 if (!X509_set_serialNumber(x509ss, serial))
611                     goto end;
612             } else {
613                 if (!rand_serial(NULL, X509_get_serialNumber(x509ss)))
614                     goto end;
615             }
616
617             if (!X509_set_issuer_name(x509ss, X509_REQ_get_subject_name(req)))
618                 goto end;
619             if (!set_cert_times(x509ss, NULL, NULL, days))
620                 goto end;
621             if (!X509_set_subject_name
622                 (x509ss, X509_REQ_get_subject_name(req)))
623                 goto end;
624             tmppkey = X509_REQ_get0_pubkey(req);
625             if (!tmppkey || !X509_set_pubkey(x509ss, tmppkey))
626                 goto end;
627
628             /* Set up V3 context struct */
629
630             X509V3_set_ctx(&ext_ctx, x509ss, x509ss, NULL, NULL, 0);
631             X509V3_set_nconf(&ext_ctx, req_conf);
632
633             /* Add extensions */
634             if (extensions && !X509V3_EXT_add_nconf(req_conf,
635                                                     &ext_ctx, extensions,
636                                                     x509ss)) {
637                 BIO_printf(bio_err, "Error Loading extension section %s\n",
638                            extensions);
639                 goto end;
640             }
641
642             i = do_X509_sign(x509ss, pkey, digest, sigopts);
643             if (!i) {
644                 ERR_print_errors(bio_err);
645                 goto end;
646             }
647         } else {
648             X509V3_CTX ext_ctx;
649
650             /* Set up V3 context struct */
651
652             X509V3_set_ctx(&ext_ctx, NULL, NULL, req, NULL, 0);
653             X509V3_set_nconf(&ext_ctx, req_conf);
654
655             /* Add extensions */
656             if (req_exts && !X509V3_EXT_REQ_add_nconf(req_conf,
657                                                       &ext_ctx, req_exts,
658                                                       req)) {
659                 BIO_printf(bio_err, "Error Loading extension section %s\n",
660                            req_exts);
661                 goto end;
662             }
663             i = do_X509_REQ_sign(req, pkey, digest, sigopts);
664             if (!i) {
665                 ERR_print_errors(bio_err);
666                 goto end;
667             }
668         }
669     }
670
671     if (subj && x509) {
672         BIO_printf(bio_err, "Cannot modify certificate subject\n");
673         goto end;
674     }
675
676     if (subj && !x509) {
677         if (verbose) {
678             BIO_printf(bio_err, "Modifying Request's Subject\n");
679             print_name(bio_err, "old subject=",
680                        X509_REQ_get_subject_name(req), nmflag);
681         }
682
683         if (build_subject(req, subj, chtype, multirdn) == 0) {
684             BIO_printf(bio_err, "ERROR: cannot modify subject\n");
685             ret = 1;
686             goto end;
687         }
688
689         if (verbose) {
690             print_name(bio_err, "new subject=",
691                        X509_REQ_get_subject_name(req), nmflag);
692         }
693     }
694
695     if (verify && !x509) {
696         EVP_PKEY *tpubkey = pkey;
697
698         if (tpubkey == NULL) {
699             tpubkey = X509_REQ_get0_pubkey(req);
700             if (tpubkey == NULL)
701                 goto end;
702         }
703
704         i = X509_REQ_verify(req, tpubkey);
705
706         if (i < 0) {
707             goto end;
708         } else if (i == 0) {
709             BIO_printf(bio_err, "verify failure\n");
710             ERR_print_errors(bio_err);
711         } else                  /* if (i > 0) */
712             BIO_printf(bio_err, "verify OK\n");
713     }
714
715     if (noout && !text && !modulus && !subject && !pubkey) {
716         ret = 0;
717         goto end;
718     }
719
720     out = bio_open_default(outfile,
721                            keyout != NULL && outfile != NULL &&
722                            strcmp(keyout, outfile) == 0 ? 'a' : 'w',
723                            outformat);
724     if (out == NULL)
725         goto end;
726
727     if (pubkey) {
728         EVP_PKEY *tpubkey = X509_REQ_get0_pubkey(req);
729
730         if (tpubkey == NULL) {
731             BIO_printf(bio_err, "Error getting public key\n");
732             ERR_print_errors(bio_err);
733             goto end;
734         }
735         PEM_write_bio_PUBKEY(out, tpubkey);
736     }
737
738     if (text) {
739         if (x509)
740             X509_print_ex(out, x509ss, nmflag, reqflag);
741         else
742             X509_REQ_print_ex(out, req, nmflag, reqflag);
743     }
744
745     if (subject) {
746         if (x509)
747             print_name(out, "subject=", X509_get_subject_name(x509ss),
748                        nmflag);
749         else
750             print_name(out, "subject=", X509_REQ_get_subject_name(req),
751                        nmflag);
752     }
753
754     if (modulus) {
755         EVP_PKEY *tpubkey;
756
757         if (x509)
758             tpubkey = X509_get0_pubkey(x509ss);
759         else
760             tpubkey = X509_REQ_get0_pubkey(req);
761         if (tpubkey == NULL) {
762             fprintf(stdout, "Modulus=unavailable\n");
763             goto end;
764         }
765         fprintf(stdout, "Modulus=");
766 #ifndef OPENSSL_NO_RSA
767         if (EVP_PKEY_base_id(tpubkey) == EVP_PKEY_RSA) {
768             const BIGNUM *n;
769             RSA_get0_key(EVP_PKEY_get0_RSA(tpubkey), &n, NULL, NULL);
770             BN_print(out, n);
771         } else
772 #endif
773             fprintf(stdout, "Wrong Algorithm type");
774         fprintf(stdout, "\n");
775     }
776
777     if (!noout && !x509) {
778         if (outformat == FORMAT_ASN1)
779             i = i2d_X509_REQ_bio(out, req);
780         else if (newhdr)
781             i = PEM_write_bio_X509_REQ_NEW(out, req);
782         else
783             i = PEM_write_bio_X509_REQ(out, req);
784         if (!i) {
785             BIO_printf(bio_err, "unable to write X509 request\n");
786             goto end;
787         }
788     }
789     if (!noout && x509 && (x509ss != NULL)) {
790         if (outformat == FORMAT_ASN1)
791             i = i2d_X509_bio(out, x509ss);
792         else
793             i = PEM_write_bio_X509(out, x509ss);
794         if (!i) {
795             BIO_printf(bio_err, "unable to write X509 certificate\n");
796             goto end;
797         }
798     }
799     ret = 0;
800  end:
801     if (ret) {
802         ERR_print_errors(bio_err);
803     }
804     NCONF_free(req_conf);
805     BIO_free(in);
806     BIO_free_all(out);
807     EVP_PKEY_free(pkey);
808     EVP_PKEY_CTX_free(genctx);
809     sk_OPENSSL_STRING_free(pkeyopts);
810     sk_OPENSSL_STRING_free(sigopts);
811 #ifndef OPENSSL_NO_ENGINE
812     ENGINE_free(gen_eng);
813 #endif
814     OPENSSL_free(keyalgstr);
815     X509_REQ_free(req);
816     X509_free(x509ss);
817     ASN1_INTEGER_free(serial);
818     if (passin != nofree_passin)
819         OPENSSL_free(passin);
820     if (passout != nofree_passout)
821         OPENSSL_free(passout);
822     return (ret);
823 }
824
825 static int make_REQ(X509_REQ *req, EVP_PKEY *pkey, char *subj, int multirdn,
826                     int attribs, unsigned long chtype)
827 {
828     int ret = 0, i;
829     char no_prompt = 0;
830     STACK_OF(CONF_VALUE) *dn_sk, *attr_sk = NULL;
831     char *tmp, *dn_sect, *attr_sect;
832
833     tmp = NCONF_get_string(req_conf, SECTION, PROMPT);
834     if (tmp == NULL)
835         ERR_clear_error();
836     if ((tmp != NULL) && strcmp(tmp, "no") == 0)
837         no_prompt = 1;
838
839     dn_sect = NCONF_get_string(req_conf, SECTION, DISTINGUISHED_NAME);
840     if (dn_sect == NULL) {
841         BIO_printf(bio_err, "unable to find '%s' in config\n",
842                    DISTINGUISHED_NAME);
843         goto err;
844     }
845     dn_sk = NCONF_get_section(req_conf, dn_sect);
846     if (dn_sk == NULL) {
847         BIO_printf(bio_err, "unable to get '%s' section\n", dn_sect);
848         goto err;
849     }
850
851     attr_sect = NCONF_get_string(req_conf, SECTION, ATTRIBUTES);
852     if (attr_sect == NULL) {
853         ERR_clear_error();
854         attr_sk = NULL;
855     } else {
856         attr_sk = NCONF_get_section(req_conf, attr_sect);
857         if (attr_sk == NULL) {
858             BIO_printf(bio_err, "unable to get '%s' section\n", attr_sect);
859             goto err;
860         }
861     }
862
863     /* setup version number */
864     if (!X509_REQ_set_version(req, 0L))
865         goto err;               /* version 1 */
866
867     if (subj)
868         i = build_subject(req, subj, chtype, multirdn);
869     else if (no_prompt)
870         i = auto_info(req, dn_sk, attr_sk, attribs, chtype);
871     else
872         i = prompt_info(req, dn_sk, dn_sect, attr_sk, attr_sect, attribs,
873                         chtype);
874     if (!i)
875         goto err;
876
877     if (!X509_REQ_set_pubkey(req, pkey))
878         goto err;
879
880     ret = 1;
881  err:
882     return (ret);
883 }
884
885 /*
886  * subject is expected to be in the format /type0=value0/type1=value1/type2=...
887  * where characters may be escaped by \
888  */
889 static int build_subject(X509_REQ *req, const char *subject, unsigned long chtype,
890                          int multirdn)
891 {
892     X509_NAME *n;
893
894     if ((n = parse_name(subject, chtype, multirdn)) == NULL)
895         return 0;
896
897     if (!X509_REQ_set_subject_name(req, n)) {
898         X509_NAME_free(n);
899         return 0;
900     }
901     X509_NAME_free(n);
902     return 1;
903 }
904
905 static int prompt_info(X509_REQ *req,
906                        STACK_OF(CONF_VALUE) *dn_sk, const char *dn_sect,
907                        STACK_OF(CONF_VALUE) *attr_sk, const char *attr_sect,
908                        int attribs, unsigned long chtype)
909 {
910     int i;
911     char *p, *q;
912     char buf[100];
913     int nid, mval;
914     long n_min, n_max;
915     char *type, *value;
916     const char *def;
917     CONF_VALUE *v;
918     X509_NAME *subj;
919     subj = X509_REQ_get_subject_name(req);
920
921     if (!batch) {
922         BIO_printf(bio_err,
923                    "You are about to be asked to enter information that will be incorporated\n");
924         BIO_printf(bio_err, "into your certificate request.\n");
925         BIO_printf(bio_err,
926                    "What you are about to enter is what is called a Distinguished Name or a DN.\n");
927         BIO_printf(bio_err,
928                    "There are quite a few fields but you can leave some blank\n");
929         BIO_printf(bio_err,
930                    "For some fields there will be a default value,\n");
931         BIO_printf(bio_err,
932                    "If you enter '.', the field will be left blank.\n");
933         BIO_printf(bio_err, "-----\n");
934     }
935
936     if (sk_CONF_VALUE_num(dn_sk)) {
937         i = -1;
938  start:for (;;) {
939             i++;
940             if (sk_CONF_VALUE_num(dn_sk) <= i)
941                 break;
942
943             v = sk_CONF_VALUE_value(dn_sk, i);
944             p = q = NULL;
945             type = v->name;
946             if (!check_end(type, "_min") || !check_end(type, "_max") ||
947                 !check_end(type, "_default") || !check_end(type, "_value"))
948                 continue;
949             /*
950              * Skip past any leading X. X: X, etc to allow for multiple
951              * instances
952              */
953             for (p = v->name; *p; p++)
954                 if ((*p == ':') || (*p == ',') || (*p == '.')) {
955                     p++;
956                     if (*p)
957                         type = p;
958                     break;
959                 }
960             if (*type == '+') {
961                 mval = -1;
962                 type++;
963             } else
964                 mval = 0;
965             /* If OBJ not recognised ignore it */
966             if ((nid = OBJ_txt2nid(type)) == NID_undef)
967                 goto start;
968             if (BIO_snprintf(buf, sizeof buf, "%s_default", v->name)
969                 >= (int)sizeof(buf)) {
970                 BIO_printf(bio_err, "Name '%s' too long\n", v->name);
971                 return 0;
972             }
973
974             if ((def = NCONF_get_string(req_conf, dn_sect, buf)) == NULL) {
975                 ERR_clear_error();
976                 def = "";
977             }
978
979             BIO_snprintf(buf, sizeof buf, "%s_value", v->name);
980             if ((value = NCONF_get_string(req_conf, dn_sect, buf)) == NULL) {
981                 ERR_clear_error();
982                 value = NULL;
983             }
984
985             BIO_snprintf(buf, sizeof buf, "%s_min", v->name);
986             if (!NCONF_get_number(req_conf, dn_sect, buf, &n_min)) {
987                 ERR_clear_error();
988                 n_min = -1;
989             }
990
991             BIO_snprintf(buf, sizeof buf, "%s_max", v->name);
992             if (!NCONF_get_number(req_conf, dn_sect, buf, &n_max)) {
993                 ERR_clear_error();
994                 n_max = -1;
995             }
996
997             if (!add_DN_object(subj, v->value, def, value, nid,
998                                n_min, n_max, chtype, mval))
999                 return 0;
1000         }
1001         if (X509_NAME_entry_count(subj) == 0) {
1002             BIO_printf(bio_err,
1003                        "error, no objects specified in config file\n");
1004             return 0;
1005         }
1006
1007         if (attribs) {
1008             if ((attr_sk != NULL) && (sk_CONF_VALUE_num(attr_sk) > 0)
1009                 && (!batch)) {
1010                 BIO_printf(bio_err,
1011                            "\nPlease enter the following 'extra' attributes\n");
1012                 BIO_printf(bio_err,
1013                            "to be sent with your certificate request\n");
1014             }
1015
1016             i = -1;
1017  start2:   for (;;) {
1018                 i++;
1019                 if ((attr_sk == NULL) || (sk_CONF_VALUE_num(attr_sk) <= i))
1020                     break;
1021
1022                 v = sk_CONF_VALUE_value(attr_sk, i);
1023                 type = v->name;
1024                 if ((nid = OBJ_txt2nid(type)) == NID_undef)
1025                     goto start2;
1026
1027                 if (BIO_snprintf(buf, sizeof buf, "%s_default", type)
1028                     >= (int)sizeof(buf)) {
1029                     BIO_printf(bio_err, "Name '%s' too long\n", v->name);
1030                     return 0;
1031                 }
1032
1033                 if ((def = NCONF_get_string(req_conf, attr_sect, buf))
1034                     == NULL) {
1035                     ERR_clear_error();
1036                     def = "";
1037                 }
1038
1039                 BIO_snprintf(buf, sizeof buf, "%s_value", type);
1040                 if ((value = NCONF_get_string(req_conf, attr_sect, buf))
1041                     == NULL) {
1042                     ERR_clear_error();
1043                     value = NULL;
1044                 }
1045
1046                 BIO_snprintf(buf, sizeof buf, "%s_min", type);
1047                 if (!NCONF_get_number(req_conf, attr_sect, buf, &n_min)) {
1048                     ERR_clear_error();
1049                     n_min = -1;
1050                 }
1051
1052                 BIO_snprintf(buf, sizeof buf, "%s_max", type);
1053                 if (!NCONF_get_number(req_conf, attr_sect, buf, &n_max)) {
1054                     ERR_clear_error();
1055                     n_max = -1;
1056                 }
1057
1058                 if (!add_attribute_object(req,
1059                                           v->value, def, value, nid, n_min,
1060                                           n_max, chtype))
1061                     return 0;
1062             }
1063         }
1064     } else {
1065         BIO_printf(bio_err, "No template, please set one up.\n");
1066         return 0;
1067     }
1068
1069     return 1;
1070
1071 }
1072
1073 static int auto_info(X509_REQ *req, STACK_OF(CONF_VALUE) *dn_sk,
1074                      STACK_OF(CONF_VALUE) *attr_sk, int attribs,
1075                      unsigned long chtype)
1076 {
1077     int i, spec_char, plus_char;
1078     char *p, *q;
1079     char *type;
1080     CONF_VALUE *v;
1081     X509_NAME *subj;
1082
1083     subj = X509_REQ_get_subject_name(req);
1084
1085     for (i = 0; i < sk_CONF_VALUE_num(dn_sk); i++) {
1086         int mval;
1087         v = sk_CONF_VALUE_value(dn_sk, i);
1088         p = q = NULL;
1089         type = v->name;
1090         /*
1091          * Skip past any leading X. X: X, etc to allow for multiple instances
1092          */
1093         for (p = v->name; *p; p++) {
1094 #ifndef CHARSET_EBCDIC
1095             spec_char = ((*p == ':') || (*p == ',') || (*p == '.'));
1096 #else
1097             spec_char = ((*p == os_toascii[':']) || (*p == os_toascii[','])
1098                     || (*p == os_toascii['.']));
1099 #endif
1100             if (spec_char) {
1101                 p++;
1102                 if (*p)
1103                     type = p;
1104                 break;
1105             }
1106         }
1107 #ifndef CHARSET_EBCDIC
1108         plus_char = (*type == '+');
1109 #else
1110         plus_char = (*type == os_toascii['+']);
1111 #endif
1112         if (plus_char) {
1113             type++;
1114             mval = -1;
1115         } else
1116             mval = 0;
1117         if (!X509_NAME_add_entry_by_txt(subj, type, chtype,
1118                                         (unsigned char *)v->value, -1, -1,
1119                                         mval))
1120             return 0;
1121
1122     }
1123
1124     if (!X509_NAME_entry_count(subj)) {
1125         BIO_printf(bio_err, "error, no objects specified in config file\n");
1126         return 0;
1127     }
1128     if (attribs) {
1129         for (i = 0; i < sk_CONF_VALUE_num(attr_sk); i++) {
1130             v = sk_CONF_VALUE_value(attr_sk, i);
1131             if (!X509_REQ_add1_attr_by_txt(req, v->name, chtype,
1132                                            (unsigned char *)v->value, -1))
1133                 return 0;
1134         }
1135     }
1136     return 1;
1137 }
1138
1139 static int add_DN_object(X509_NAME *n, char *text, const char *def,
1140                          char *value, int nid, int n_min, int n_max,
1141                          unsigned long chtype, int mval)
1142 {
1143     int i, ret = 0;
1144     char buf[1024];
1145  start:
1146     if (!batch)
1147         BIO_printf(bio_err, "%s [%s]:", text, def);
1148     (void)BIO_flush(bio_err);
1149     if (value != NULL) {
1150         OPENSSL_strlcpy(buf, value, sizeof buf);
1151         OPENSSL_strlcat(buf, "\n", sizeof buf);
1152         BIO_printf(bio_err, "%s\n", value);
1153     } else {
1154         buf[0] = '\0';
1155         if (!batch) {
1156             if (!fgets(buf, sizeof buf, stdin))
1157                 return 0;
1158         } else {
1159             buf[0] = '\n';
1160             buf[1] = '\0';
1161         }
1162     }
1163
1164     if (buf[0] == '\0')
1165         return (0);
1166     else if (buf[0] == '\n') {
1167         if ((def == NULL) || (def[0] == '\0'))
1168             return (1);
1169         OPENSSL_strlcpy(buf, def, sizeof buf);
1170         OPENSSL_strlcat(buf, "\n", sizeof buf);
1171     } else if ((buf[0] == '.') && (buf[1] == '\n'))
1172         return (1);
1173
1174     i = strlen(buf);
1175     if (buf[i - 1] != '\n') {
1176         BIO_printf(bio_err, "weird input :-(\n");
1177         return (0);
1178     }
1179     buf[--i] = '\0';
1180 #ifdef CHARSET_EBCDIC
1181     ebcdic2ascii(buf, buf, i);
1182 #endif
1183     if (!req_check_len(i, n_min, n_max)) {
1184         if (batch || value)
1185             return 0;
1186         goto start;
1187     }
1188
1189     if (!X509_NAME_add_entry_by_NID(n, nid, chtype,
1190                                     (unsigned char *)buf, -1, -1, mval))
1191         goto err;
1192     ret = 1;
1193  err:
1194     return (ret);
1195 }
1196
1197 static int add_attribute_object(X509_REQ *req, char *text, const char *def,
1198                                 char *value, int nid, int n_min,
1199                                 int n_max, unsigned long chtype)
1200 {
1201     int i;
1202     static char buf[1024];
1203
1204  start:
1205     if (!batch)
1206         BIO_printf(bio_err, "%s [%s]:", text, def);
1207     (void)BIO_flush(bio_err);
1208     if (value != NULL) {
1209         OPENSSL_strlcpy(buf, value, sizeof buf);
1210         OPENSSL_strlcat(buf, "\n", sizeof buf);
1211         BIO_printf(bio_err, "%s\n", value);
1212     } else {
1213         buf[0] = '\0';
1214         if (!batch) {
1215             if (!fgets(buf, sizeof buf, stdin))
1216                 return 0;
1217         } else {
1218             buf[0] = '\n';
1219             buf[1] = '\0';
1220         }
1221     }
1222
1223     if (buf[0] == '\0')
1224         return (0);
1225     else if (buf[0] == '\n') {
1226         if ((def == NULL) || (def[0] == '\0'))
1227             return (1);
1228         OPENSSL_strlcpy(buf, def, sizeof buf);
1229         OPENSSL_strlcat(buf, "\n", sizeof buf);
1230     } else if ((buf[0] == '.') && (buf[1] == '\n'))
1231         return (1);
1232
1233     i = strlen(buf);
1234     if (buf[i - 1] != '\n') {
1235         BIO_printf(bio_err, "weird input :-(\n");
1236         return (0);
1237     }
1238     buf[--i] = '\0';
1239 #ifdef CHARSET_EBCDIC
1240     ebcdic2ascii(buf, buf, i);
1241 #endif
1242     if (!req_check_len(i, n_min, n_max)) {
1243         if (batch || value)
1244             return 0;
1245         goto start;
1246     }
1247
1248     if (!X509_REQ_add1_attr_by_NID(req, nid, chtype,
1249                                    (unsigned char *)buf, -1)) {
1250         BIO_printf(bio_err, "Error adding attribute\n");
1251         ERR_print_errors(bio_err);
1252         goto err;
1253     }
1254
1255     return (1);
1256  err:
1257     return (0);
1258 }
1259
1260 static int req_check_len(int len, int n_min, int n_max)
1261 {
1262     if ((n_min > 0) && (len < n_min)) {
1263         BIO_printf(bio_err,
1264                    "string is too short, it needs to be at least %d bytes long\n",
1265                    n_min);
1266         return (0);
1267     }
1268     if ((n_max >= 0) && (len > n_max)) {
1269         BIO_printf(bio_err,
1270                    "string is too long, it needs to be less than  %d bytes long\n",
1271                    n_max);
1272         return (0);
1273     }
1274     return (1);
1275 }
1276
1277 /* Check if the end of a string matches 'end' */
1278 static int check_end(const char *str, const char *end)
1279 {
1280     int elen, slen;
1281     const char *tmp;
1282     elen = strlen(end);
1283     slen = strlen(str);
1284     if (elen > slen)
1285         return 1;
1286     tmp = str + slen - elen;
1287     return strcmp(tmp, end);
1288 }
1289
1290 static EVP_PKEY_CTX *set_keygen_ctx(const char *gstr,
1291                                     int *pkey_type, long *pkeylen,
1292                                     char **palgnam, ENGINE *keygen_engine)
1293 {
1294     EVP_PKEY_CTX *gctx = NULL;
1295     EVP_PKEY *param = NULL;
1296     long keylen = -1;
1297     BIO *pbio = NULL;
1298     const char *paramfile = NULL;
1299
1300     if (gstr == NULL) {
1301         *pkey_type = EVP_PKEY_RSA;
1302         keylen = *pkeylen;
1303     } else if (gstr[0] >= '0' && gstr[0] <= '9') {
1304         *pkey_type = EVP_PKEY_RSA;
1305         keylen = atol(gstr);
1306         *pkeylen = keylen;
1307     } else if (strncmp(gstr, "param:", 6) == 0)
1308         paramfile = gstr + 6;
1309     else {
1310         const char *p = strchr(gstr, ':');
1311         int len;
1312         ENGINE *tmpeng;
1313         const EVP_PKEY_ASN1_METHOD *ameth;
1314
1315         if (p)
1316             len = p - gstr;
1317         else
1318             len = strlen(gstr);
1319         /*
1320          * The lookup of a the string will cover all engines so keep a note
1321          * of the implementation.
1322          */
1323
1324         ameth = EVP_PKEY_asn1_find_str(&tmpeng, gstr, len);
1325
1326         if (!ameth) {
1327             BIO_printf(bio_err, "Unknown algorithm %.*s\n", len, gstr);
1328             return NULL;
1329         }
1330
1331         EVP_PKEY_asn1_get0_info(NULL, pkey_type, NULL, NULL, NULL, ameth);
1332 #ifndef OPENSSL_NO_ENGINE
1333         ENGINE_finish(tmpeng);
1334 #endif
1335         if (*pkey_type == EVP_PKEY_RSA) {
1336             if (p) {
1337                 keylen = atol(p + 1);
1338                 *pkeylen = keylen;
1339             } else
1340                 keylen = *pkeylen;
1341         } else if (p)
1342             paramfile = p + 1;
1343     }
1344
1345     if (paramfile) {
1346         pbio = BIO_new_file(paramfile, "r");
1347         if (!pbio) {
1348             BIO_printf(bio_err, "Can't open parameter file %s\n", paramfile);
1349             return NULL;
1350         }
1351         param = PEM_read_bio_Parameters(pbio, NULL);
1352
1353         if (!param) {
1354             X509 *x;
1355             (void)BIO_reset(pbio);
1356             x = PEM_read_bio_X509(pbio, NULL, NULL, NULL);
1357             if (x) {
1358                 param = X509_get_pubkey(x);
1359                 X509_free(x);
1360             }
1361         }
1362
1363         BIO_free(pbio);
1364
1365         if (!param) {
1366             BIO_printf(bio_err, "Error reading parameter file %s\n", paramfile);
1367             return NULL;
1368         }
1369         if (*pkey_type == -1)
1370             *pkey_type = EVP_PKEY_id(param);
1371         else if (*pkey_type != EVP_PKEY_base_id(param)) {
1372             BIO_printf(bio_err, "Key Type does not match parameters\n");
1373             EVP_PKEY_free(param);
1374             return NULL;
1375         }
1376     }
1377
1378     if (palgnam) {
1379         const EVP_PKEY_ASN1_METHOD *ameth;
1380         ENGINE *tmpeng;
1381         const char *anam;
1382         ameth = EVP_PKEY_asn1_find(&tmpeng, *pkey_type);
1383         if (!ameth) {
1384             BIO_puts(bio_err, "Internal error: can't find key algorithm\n");
1385             return NULL;
1386         }
1387         EVP_PKEY_asn1_get0_info(NULL, NULL, NULL, NULL, &anam, ameth);
1388         *palgnam = OPENSSL_strdup(anam);
1389 #ifndef OPENSSL_NO_ENGINE
1390         ENGINE_finish(tmpeng);
1391 #endif
1392     }
1393
1394     if (param) {
1395         gctx = EVP_PKEY_CTX_new(param, keygen_engine);
1396         *pkeylen = EVP_PKEY_bits(param);
1397         EVP_PKEY_free(param);
1398     } else
1399         gctx = EVP_PKEY_CTX_new_id(*pkey_type, keygen_engine);
1400
1401     if (gctx == NULL) {
1402         BIO_puts(bio_err, "Error allocating keygen context\n");
1403         ERR_print_errors(bio_err);
1404         return NULL;
1405     }
1406
1407     if (EVP_PKEY_keygen_init(gctx) <= 0) {
1408         BIO_puts(bio_err, "Error initializing keygen context\n");
1409         ERR_print_errors(bio_err);
1410         EVP_PKEY_CTX_free(gctx);
1411         return NULL;
1412     }
1413 #ifndef OPENSSL_NO_RSA
1414     if ((*pkey_type == EVP_PKEY_RSA) && (keylen != -1)) {
1415         if (EVP_PKEY_CTX_set_rsa_keygen_bits(gctx, keylen) <= 0) {
1416             BIO_puts(bio_err, "Error setting RSA keysize\n");
1417             ERR_print_errors(bio_err);
1418             EVP_PKEY_CTX_free(gctx);
1419             return NULL;
1420         }
1421     }
1422 #endif
1423
1424     return gctx;
1425 }
1426
1427 static int genpkey_cb(EVP_PKEY_CTX *ctx)
1428 {
1429     char c = '*';
1430     BIO *b = EVP_PKEY_CTX_get_app_data(ctx);
1431     int p;
1432     p = EVP_PKEY_CTX_get_keygen_info(ctx, 0);
1433     if (p == 0)
1434         c = '.';
1435     if (p == 1)
1436         c = '+';
1437     if (p == 2)
1438         c = '*';
1439     if (p == 3)
1440         c = '\n';
1441     BIO_write(b, &c, 1);
1442     (void)BIO_flush(b);
1443     return 1;
1444 }
1445
1446 static int do_sign_init(EVP_MD_CTX *ctx, EVP_PKEY *pkey,
1447                         const EVP_MD *md, STACK_OF(OPENSSL_STRING) *sigopts)
1448 {
1449     EVP_PKEY_CTX *pkctx = NULL;
1450     int i;
1451
1452     if (ctx == NULL)
1453         return 0;
1454     if (!EVP_DigestSignInit(ctx, &pkctx, md, NULL, pkey))
1455         return 0;
1456     for (i = 0; i < sk_OPENSSL_STRING_num(sigopts); i++) {
1457         char *sigopt = sk_OPENSSL_STRING_value(sigopts, i);
1458         if (pkey_ctrl_string(pkctx, sigopt) <= 0) {
1459             BIO_printf(bio_err, "parameter error \"%s\"\n", sigopt);
1460             ERR_print_errors(bio_err);
1461             return 0;
1462         }
1463     }
1464     return 1;
1465 }
1466
1467 int do_X509_sign(X509 *x, EVP_PKEY *pkey, const EVP_MD *md,
1468                  STACK_OF(OPENSSL_STRING) *sigopts)
1469 {
1470     int rv;
1471     EVP_MD_CTX *mctx = EVP_MD_CTX_new();
1472
1473     rv = do_sign_init(mctx, pkey, md, sigopts);
1474     if (rv > 0)
1475         rv = X509_sign_ctx(x, mctx);
1476     EVP_MD_CTX_free(mctx);
1477     return rv > 0 ? 1 : 0;
1478 }
1479
1480 int do_X509_REQ_sign(X509_REQ *x, EVP_PKEY *pkey, const EVP_MD *md,
1481                      STACK_OF(OPENSSL_STRING) *sigopts)
1482 {
1483     int rv;
1484     EVP_MD_CTX *mctx = EVP_MD_CTX_new();
1485     rv = do_sign_init(mctx, pkey, md, sigopts);
1486     if (rv > 0)
1487         rv = X509_REQ_sign_ctx(x, mctx);
1488     EVP_MD_CTX_free(mctx);
1489     return rv > 0 ? 1 : 0;
1490 }
1491
1492 int do_X509_CRL_sign(X509_CRL *x, EVP_PKEY *pkey, const EVP_MD *md,
1493                      STACK_OF(OPENSSL_STRING) *sigopts)
1494 {
1495     int rv;
1496     EVP_MD_CTX *mctx = EVP_MD_CTX_new();
1497     rv = do_sign_init(mctx, pkey, md, sigopts);
1498     if (rv > 0)
1499         rv = X509_CRL_sign_ctx(x, mctx);
1500     EVP_MD_CTX_free(mctx);
1501     return rv > 0 ? 1 : 0;
1502 }