apps/req.c

   1 /*
   2  * Copyright 1995-2024 The OpenSSL Project Authors. All Rights Reserved.
   3  *
   4  * Licensed under the Apache License 2.0 (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 <ctype.h>
  15 #include "apps.h"
  16 #include "progs.h"
  17 #include <openssl/core_names.h>
  18 #include <openssl/bio.h>
  19 #include <openssl/evp.h>
  20 #include <openssl/conf.h>
  21 #include <openssl/err.h>
  22 #include <openssl/asn1.h>
  23 #include <openssl/x509.h>
  24 #include <openssl/x509v3.h>
  25 #include <openssl/objects.h>
  26 #include <openssl/pem.h>
  27 #include <openssl/bn.h>
  28 #include <openssl/lhash.h>
  29 #include <openssl/rsa.h>
  30 #ifndef OPENSSL_NO_DSA
  31 # include <openssl/dsa.h>
  32 #endif
  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 #define DEFAULT_DAYS       30 /* default certificate validity period in days */
  47 #define UNSET_DAYS         -2 /* -1 may be used for testing expiration checks */
  48 #define EXT_COPY_UNSET     -1
  49
  50 static int make_REQ(X509_REQ *req, EVP_PKEY *pkey, X509_NAME *fsubj,
  51                     int mutlirdn, int attribs, unsigned long chtype);
  52 static int prompt_info(X509_REQ *req,
  53                        STACK_OF(CONF_VALUE) *dn_sk, const char *dn_sect,
  54                        STACK_OF(CONF_VALUE) *attr_sk, const char *attr_sect,
  55                        int attribs, unsigned long chtype);
  56 static int auto_info(X509_REQ *req, STACK_OF(CONF_VALUE) *sk,
  57                      STACK_OF(CONF_VALUE) *attr, int attribs,
  58                      unsigned long chtype);
  59 static int add_attribute_object(X509_REQ *req, char *text, const char *def,
  60                                 char *value, int nid, int n_min, int n_max,
  61                                 unsigned long chtype);
  62 static int add_DN_object(X509_NAME *n, char *text, const char *def,
  63                          char *value, int nid, int n_min, int n_max,
  64                          unsigned long chtype, int mval);
  65 static int build_data(char *text, const char *def, char *value,
  66                       int n_min, int n_max, char *buf, const int buf_size,
  67                       const char *desc1, const char *desc2);
  68 static int req_check_len(int len, int n_min, int n_max);
  69 static int check_end(const char *str, const char *end);
  70 static int join(char buf[], size_t buf_size, const char *name,
  71                 const char *tail, const char *desc);
  72 static EVP_PKEY_CTX *set_keygen_ctx(const char *gstr,
  73                                     char **pkeytype, long *pkeylen,
  74                                     ENGINE *keygen_engine);
  75
  76 static const char *section = "req";
  77 static CONF *req_conf = NULL;
  78 static CONF *addext_conf = NULL;
  79 static int batch = 0;
  80
  81 typedef enum OPTION_choice {
  82     OPT_COMMON,
  83     OPT_INFORM, OPT_OUTFORM, OPT_ENGINE, OPT_KEYGEN_ENGINE, OPT_KEY,
  84     OPT_PUBKEY, OPT_NEW, OPT_CONFIG, OPT_KEYFORM, OPT_IN, OPT_OUT,
  85     OPT_KEYOUT, OPT_PASSIN, OPT_PASSOUT, OPT_NEWKEY,
  86     OPT_PKEYOPT, OPT_SIGOPT, OPT_VFYOPT, OPT_BATCH, OPT_NEWHDR, OPT_MODULUS,
  87     OPT_VERIFY, OPT_NOENC, OPT_NODES, OPT_NOOUT, OPT_VERBOSE, OPT_UTF8,
  88     OPT_NAMEOPT, OPT_REQOPT, OPT_SUBJ, OPT_SUBJECT, OPT_TEXT,
  89     OPT_X509, OPT_X509V1, OPT_CA, OPT_CAKEY,
  90     OPT_MULTIVALUE_RDN, OPT_NOT_BEFORE, OPT_NOT_AFTER, OPT_DAYS, OPT_SET_SERIAL,
  91     OPT_COPY_EXTENSIONS, OPT_EXTENSIONS, OPT_REQEXTS, OPT_ADDEXT,
  92     OPT_PRECERT, OPT_MD,
  93     OPT_SECTION, OPT_QUIET,
  94     OPT_R_ENUM, OPT_PROV_ENUM
  95 } OPTION_CHOICE;
  96
  97 const OPTIONS req_options[] = {
  98     OPT_SECTION("General"),
  99     {"help", OPT_HELP, '-', "Display this summary"},
 100 #ifndef OPENSSL_NO_ENGINE
 101     {"engine", OPT_ENGINE, 's', "Use engine, possibly a hardware device"},
 102     {"keygen_engine", OPT_KEYGEN_ENGINE, 's',
 103      "Specify engine to be used for key generation operations"},
 104 #endif
 105     {"in", OPT_IN, '<', "X.509 request input file (default stdin)"},
 106     {"inform", OPT_INFORM, 'F',
 107      "CSR input format to use (PEM or DER; by default try PEM first)"},
 108     {"verify", OPT_VERIFY, '-', "Verify self-signature on the request"},
 109
 110     OPT_SECTION("Certificate"),
 111     {"new", OPT_NEW, '-', "New request"},
 112     {"config", OPT_CONFIG, '<', "Request template file"},
 113     {"section", OPT_SECTION, 's', "Config section to use (default \"req\")"},
 114     {"utf8", OPT_UTF8, '-', "Input characters are UTF8 (default ASCII)"},
 115     {"nameopt", OPT_NAMEOPT, 's', "Certificate subject/issuer name printing options"},
 116     {"reqopt", OPT_REQOPT, 's', "Various request text options"},
 117     {"text", OPT_TEXT, '-', "Text form of request"},
 118     {"x509", OPT_X509, '-',
 119      "Output an X.509 certificate structure instead of a cert request"},
 120     {"x509v1", OPT_X509V1, '-', "Request cert generation with X.509 version 1"},
 121     {"CA", OPT_CA, '<', "Issuer cert to use for signing a cert, implies -x509"},
 122     {"CAkey", OPT_CAKEY, 's',
 123      "Issuer private key to use with -CA; default is -CA arg"},
 124     {OPT_MORE_STR, 1, 1, "(Required by some CA's)"},
 125     {"subj", OPT_SUBJ, 's', "Set or modify subject of request or cert"},
 126     {"subject", OPT_SUBJECT, '-',
 127      "Print the subject of the output request or cert"},
 128     {"multivalue-rdn", OPT_MULTIVALUE_RDN, '-',
 129      "Deprecated; multi-valued RDNs support is always on."},
 130     {"not_before", OPT_NOT_BEFORE, 's',
 131      "[CC]YYMMDDHHMMSSZ value for notBefore certificate field"},
 132     {"not_after", OPT_NOT_AFTER, 's',
 133      "[CC]YYMMDDHHMMSSZ value for notAfter certificate field, overrides -days"},
 134     {"days", OPT_DAYS, 'p', "Number of days certificate is valid for"},
 135     {"set_serial", OPT_SET_SERIAL, 's', "Serial number to use"},
 136     {"copy_extensions", OPT_COPY_EXTENSIONS, 's',
 137      "copy extensions from request when using -x509"},
 138     {"extensions", OPT_EXTENSIONS, 's',
 139      "Cert or request extension section (override value in config file)"},
 140     {"reqexts", OPT_REQEXTS, 's', "An alias for -extensions"},
 141     {"addext", OPT_ADDEXT, 's',
 142      "Additional cert extension key=value pair (may be given more than once)"},
 143     {"precert", OPT_PRECERT, '-', "Add a poison extension to generated cert (implies -new)"},
 144
 145     OPT_SECTION("Keys and Signing"),
 146     {"key", OPT_KEY, 's', "Key for signing, and to include unless -in given"},
 147     {"keyform", OPT_KEYFORM, 'f', "Key file format (ENGINE, other values ignored)"},
 148     {"pubkey", OPT_PUBKEY, '-', "Output public key"},
 149     {"keyout", OPT_KEYOUT, '>', "File to write private key to"},
 150     {"passin", OPT_PASSIN, 's', "Private key and certificate password source"},
 151     {"passout", OPT_PASSOUT, 's', "Output file pass phrase source"},
 152     {"newkey", OPT_NEWKEY, 's',
 153      "Generate new key with [<alg>:]<nbits> or <alg>[:<file>] or param:<file>"},
 154     {"pkeyopt", OPT_PKEYOPT, 's', "Public key options as opt:value"},
 155     {"sigopt", OPT_SIGOPT, 's', "Signature parameter in n:v form"},
 156     {"vfyopt", OPT_VFYOPT, 's', "Verification parameter in n:v form"},
 157     {"", OPT_MD, '-', "Any supported digest"},
 158
 159     OPT_SECTION("Output"),
 160     {"out", OPT_OUT, '>', "Output file"},
 161     {"outform", OPT_OUTFORM, 'F', "Output format - DER or PEM"},
 162     {"batch", OPT_BATCH, '-',
 163      "Do not ask anything during request generation"},
 164     {"verbose", OPT_VERBOSE, '-', "Verbose output"},
 165     {"quiet", OPT_QUIET, '-', "Terse output"},
 166     {"noenc", OPT_NOENC, '-', "Don't encrypt private keys"},
 167     {"nodes", OPT_NODES, '-', "Don't encrypt private keys; deprecated"},
 168     {"noout", OPT_NOOUT, '-', "Do not output REQ"},
 169     {"newhdr", OPT_NEWHDR, '-', "Output \"NEW\" in the header lines"},
 170     {"modulus", OPT_MODULUS, '-', "RSA modulus"},
 171
 172     OPT_R_OPTIONS,
 173     OPT_PROV_OPTIONS,
 174     {NULL}
 175 };
 176
 177 /*
 178  * An LHASH of strings, where each string is an extension name.
 179  */
 180 static unsigned long ext_name_hash(const OPENSSL_STRING *a)
 181 {
 182     return OPENSSL_LH_strhash((const char *)a);
 183 }
 184
 185 static int ext_name_cmp(const OPENSSL_STRING *a, const OPENSSL_STRING *b)
 186 {
 187     return strcmp((const char *)a, (const char *)b);
 188 }
 189
 190 static void exts_cleanup(OPENSSL_STRING *x)
 191 {
 192     OPENSSL_free((char *)x);
 193 }
 194
 195 /*
 196  * Is the |kv| key already duplicated?
 197  * Return 0 if unique, -1 on runtime error, -2 on syntax error; 1 if found.
 198  */
 199 static int duplicated(LHASH_OF(OPENSSL_STRING) *addexts, char *kv)
 200 {
 201     char *p;
 202     size_t off;
 203
 204     /* Check syntax. */
 205     /* Skip leading whitespace, make a copy. */
 206     while (isspace(_UC(*kv)))
 207         kv++;
 208     if ((p = strchr(kv, '=')) == NULL) {
 209         BIO_printf(bio_err, "Parse error on -addext: missing '='\n");
 210         return -2;
 211     }
 212     off = p - kv;
 213     if ((kv = OPENSSL_strdup(kv)) == NULL)
 214         return -1;
 215
 216     /* Skip trailing space before the equal sign. */
 217     for (p = kv + off; p > kv; --p)
 218         if (!isspace(_UC(p[-1])))
 219             break;
 220     if (p == kv) {
 221         BIO_printf(bio_err, "Parse error on -addext: missing key\n");
 222         OPENSSL_free(kv);
 223         return -2;
 224     }
 225     *p = '\0';
 226
 227     /* Finally have a clean "key"; see if it's there [by attempt to add it]. */
 228     p = (char *)lh_OPENSSL_STRING_insert(addexts, (OPENSSL_STRING *)kv);
 229     if (p != NULL) {
 230         BIO_printf(bio_err, "Duplicate extension name: %s\n", kv);
 231         OPENSSL_free(p);
 232         return 1;
 233     } else if (lh_OPENSSL_STRING_error(addexts)) {
 234         OPENSSL_free(kv);
 235         return -1;
 236     }
 237
 238     return 0;
 239 }
 240
 241 int req_main(int argc, char **argv)
 242 {
 243     ASN1_INTEGER *serial = NULL;
 244     BIO *out = NULL;
 245     ENGINE *e = NULL, *gen_eng = NULL;
 246     EVP_PKEY *pkey = NULL, *CAkey = NULL;
 247     EVP_PKEY_CTX *genctx = NULL;
 248     STACK_OF(OPENSSL_STRING) *pkeyopts = NULL, *sigopts = NULL, *vfyopts = NULL;
 249     LHASH_OF(OPENSSL_STRING) *addexts = NULL;
 250     X509 *new_x509 = NULL, *CAcert = NULL;
 251     X509_REQ *req = NULL;
 252     EVP_CIPHER *cipher = NULL;
 253     int ext_copy = EXT_COPY_UNSET;
 254     BIO *addext_bio = NULL;
 255     char *extsect = NULL;
 256     const char *infile = NULL, *CAfile = NULL, *CAkeyfile = NULL;
 257     char *outfile = NULL, *keyfile = NULL, *digest = NULL;
 258     char *keyalgstr = NULL, *p, *prog, *passargin = NULL, *passargout = NULL;
 259     char *passin = NULL, *passout = NULL;
 260     char *nofree_passin = NULL, *nofree_passout = NULL;
 261     char *subj = NULL;
 262     X509_NAME *fsubj = NULL;
 263     char *template = default_config_file, *keyout = NULL;
 264     const char *keyalg = NULL;
 265     OPTION_CHOICE o;
 266     char *not_before = NULL, *not_after = NULL;
 267     int days = UNSET_DAYS;
 268     int ret = 1, gen_x509 = 0, i = 0, newreq = 0, verbose = 0, progress = 1;
 269     int informat = FORMAT_UNDEF, outformat = FORMAT_PEM, keyform = FORMAT_UNDEF;
 270     int modulus = 0, multirdn = 1, verify = 0, noout = 0, text = 0;
 271     int noenc = 0, newhdr = 0, subject = 0, pubkey = 0, precert = 0, x509v1 = 0;
 272     long newkey_len = -1;
 273     unsigned long chtype = MBSTRING_ASC, reqflag = 0;
 274
 275 #ifndef OPENSSL_NO_DES
 276     cipher = (EVP_CIPHER *)EVP_des_ede3_cbc();
 277 #endif
 278
 279     opt_set_unknown_name("digest");
 280     prog = opt_init(argc, argv, req_options);
 281     while ((o = opt_next()) != OPT_EOF) {
 282         switch (o) {
 283         case OPT_EOF:
 284         case OPT_ERR:
 285  opthelp:
 286             BIO_printf(bio_err, "%s: Use -help for summary.\n", prog);
 287             goto end;
 288         case OPT_HELP:
 289             opt_help(req_options);
 290             ret = 0;
 291             goto end;
 292         case OPT_INFORM:
 293             if (!opt_format(opt_arg(), OPT_FMT_PEMDER, &informat))
 294                 goto opthelp;
 295             break;
 296         case OPT_OUTFORM:
 297             if (!opt_format(opt_arg(), OPT_FMT_PEMDER, &outformat))
 298                 goto opthelp;
 299             break;
 300         case OPT_ENGINE:
 301             e = setup_engine(opt_arg(), 0);
 302             break;
 303         case OPT_KEYGEN_ENGINE:
 304 #ifndef OPENSSL_NO_ENGINE
 305             gen_eng = setup_engine(opt_arg(), 0);
 306             if (gen_eng == NULL) {
 307                 BIO_printf(bio_err, "Can't find keygen engine %s\n", *argv);
 308                 goto opthelp;
 309             }
 310 #endif
 311             break;
 312         case OPT_KEY:
 313             keyfile = opt_arg();
 314             break;
 315         case OPT_PUBKEY:
 316             pubkey = 1;
 317             break;
 318         case OPT_NEW:
 319             newreq = 1;
 320             break;
 321         case OPT_CONFIG:
 322             template = opt_arg();
 323             break;
 324         case OPT_SECTION:
 325             section = opt_arg();
 326             break;
 327         case OPT_KEYFORM:
 328             if (!opt_format(opt_arg(), OPT_FMT_ANY, &keyform))
 329                 goto opthelp;
 330             break;
 331         case OPT_IN:
 332             infile = opt_arg();
 333             break;
 334         case OPT_OUT:
 335             outfile = opt_arg();
 336             break;
 337         case OPT_KEYOUT:
 338             keyout = opt_arg();
 339             break;
 340         case OPT_PASSIN:
 341             passargin = opt_arg();
 342             break;
 343         case OPT_PASSOUT:
 344             passargout = opt_arg();
 345             break;
 346         case OPT_R_CASES:
 347             if (!opt_rand(o))
 348                 goto end;
 349             break;
 350         case OPT_PROV_CASES:
 351             if (!opt_provider(o))
 352                 goto end;
 353             break;
 354         case OPT_NEWKEY:
 355             keyalg = opt_arg();
 356             newreq = 1;
 357             break;
 358         case OPT_PKEYOPT:
 359             if (pkeyopts == NULL)
 360                 pkeyopts = sk_OPENSSL_STRING_new_null();
 361             if (pkeyopts == NULL
 362                     || !sk_OPENSSL_STRING_push(pkeyopts, opt_arg()))
 363                 goto opthelp;
 364             break;
 365         case OPT_SIGOPT:
 366             if (!sigopts)
 367                 sigopts = sk_OPENSSL_STRING_new_null();
 368             if (!sigopts || !sk_OPENSSL_STRING_push(sigopts, opt_arg()))
 369                 goto opthelp;
 370             break;
 371         case OPT_VFYOPT:
 372             if (!vfyopts)
 373                 vfyopts = sk_OPENSSL_STRING_new_null();
 374             if (!vfyopts || !sk_OPENSSL_STRING_push(vfyopts, opt_arg()))
 375                 goto opthelp;
 376             break;
 377         case OPT_BATCH:
 378             batch = 1;
 379             break;
 380         case OPT_NEWHDR:
 381             newhdr = 1;
 382             break;
 383         case OPT_MODULUS:
 384             modulus = 1;
 385             break;
 386         case OPT_VERIFY:
 387             verify = 1;
 388             break;
 389         case OPT_NODES:
 390         case OPT_NOENC:
 391             noenc = 1;
 392             break;
 393         case OPT_NOOUT:
 394             noout = 1;
 395             break;
 396         case OPT_VERBOSE:
 397             verbose = 1;
 398             progress = 1;
 399             break;
 400         case OPT_QUIET:
 401             verbose = 0;
 402             progress = 0;
 403             break;
 404         case OPT_UTF8:
 405             chtype = MBSTRING_UTF8;
 406             break;
 407         case OPT_NAMEOPT:
 408             if (!set_nameopt(opt_arg()))
 409                 goto opthelp;
 410             break;
 411         case OPT_REQOPT:
 412             if (!set_cert_ex(&reqflag, opt_arg()))
 413                 goto opthelp;
 414             break;
 415         case OPT_TEXT:
 416             text = 1;
 417             break;
 418         case OPT_X509V1:
 419             x509v1 = 1;
 420             /* fall thru */
 421         case OPT_X509:
 422             gen_x509 = 1;
 423             break;
 424         case OPT_CA:
 425             CAfile = opt_arg();
 426             gen_x509 = 1;
 427             break;
 428         case OPT_CAKEY:
 429             CAkeyfile = opt_arg();
 430             break;
 431         case OPT_NOT_BEFORE:
 432             not_before = opt_arg();
 433             break;
 434         case OPT_NOT_AFTER:
 435             not_after = opt_arg();
 436             break;
 437         case OPT_DAYS:
 438             days = atoi(opt_arg());
 439             if (days <= UNSET_DAYS) {
 440                 BIO_printf(bio_err, "%s: -days parameter arg must be >= -1\n",
 441                            prog);
 442                 goto end;
 443             }
 444             break;
 445         case OPT_SET_SERIAL:
 446             if (serial != NULL) {
 447                 BIO_printf(bio_err, "Serial number supplied twice\n");
 448                 goto opthelp;
 449             }
 450             serial = s2i_ASN1_INTEGER(NULL, opt_arg());
 451             if (serial == NULL)
 452                 goto opthelp;
 453             break;
 454         case OPT_SUBJECT:
 455             subject = 1;
 456             break;
 457         case OPT_SUBJ:
 458             subj = opt_arg();
 459             break;
 460         case OPT_MULTIVALUE_RDN:
 461             /* obsolete */
 462             break;
 463         case OPT_COPY_EXTENSIONS:
 464             if (!set_ext_copy(&ext_copy, opt_arg())) {
 465                 BIO_printf(bio_err, "Invalid extension copy option: \"%s\"\n",
 466                            opt_arg());
 467                 goto end;
 468             }
 469             break;
 470         case OPT_EXTENSIONS:
 471         case OPT_REQEXTS:
 472             extsect = opt_arg();
 473             break;
 474         case OPT_ADDEXT:
 475             p = opt_arg();
 476             if (addexts == NULL) {
 477                 addexts = lh_OPENSSL_STRING_new(ext_name_hash, ext_name_cmp);
 478                 addext_bio = BIO_new(BIO_s_mem());
 479                 if (addexts == NULL || addext_bio == NULL)
 480                     goto end;
 481             }
 482             i = duplicated(addexts, p);
 483             if (i == 1)
 484                 goto opthelp;
 485             if (i == -1)
 486                 BIO_printf(bio_err, "Internal error handling -addext %s\n", p);
 487             if (i < 0 || BIO_printf(addext_bio, "%s\n", p) < 0)
 488                 goto end;
 489             break;
 490         case OPT_PRECERT:
 491             newreq = precert = 1;
 492             break;
 493         case OPT_MD:
 494             digest = opt_unknown();
 495             break;
 496         }
 497     }
 498
 499     /* No extra arguments. */
 500     if (!opt_check_rest_arg(NULL))
 501         goto opthelp;
 502
 503     if (!app_RAND_load())
 504         goto end;
 505
 506     if (!gen_x509) {
 507         if (days != UNSET_DAYS)
 508             BIO_printf(bio_err, "Warning: Ignoring -days without -x509; not generating a certificate\n");
 509         if (not_before != NULL)
 510             BIO_printf(bio_err, "Warning: Ignoring -not_before without -x509; not generating a certificate\n");
 511         if (not_after != NULL)
 512             BIO_printf(bio_err, "Warning: Ignoring -not_after without -x509; not generating a certificate\n");
 513         if (ext_copy == EXT_COPY_NONE)
 514             BIO_printf(bio_err, "Warning: Ignoring -copy_extensions 'none' when -x509 is not given\n");
 515     }
 516     if (infile == NULL) {
 517         if (gen_x509)
 518             newreq = 1;
 519         else if (!newreq)
 520             BIO_printf(bio_err,
 521                        "Warning: Will read cert request from stdin since no -in option is given\n");
 522     }
 523
 524     if (!app_passwd(passargin, passargout, &passin, &passout)) {
 525         BIO_printf(bio_err, "Error getting passwords\n");
 526         goto end;
 527     }
 528
 529     if ((req_conf = app_load_config_verbose(template, verbose)) == NULL)
 530         goto end;
 531     if (addext_bio != NULL) {
 532         if (verbose)
 533             BIO_printf(bio_err,
 534                        "Using additional configuration from -addext options\n");
 535         if ((addext_conf = app_load_config_bio(addext_bio, NULL)) == NULL)
 536             goto end;
 537     }
 538     if (template != default_config_file && !app_load_modules(req_conf))
 539         goto end;
 540
 541     if (req_conf != NULL) {
 542         p = app_conf_try_string(req_conf, NULL, "oid_file");
 543         if (p != NULL) {
 544             BIO *oid_bio = BIO_new_file(p, "r");
 545
 546             if (oid_bio == NULL) {
 547                 if (verbose)
 548                     BIO_printf(bio_err,
 549                                "Problems opening '%s' for extra OIDs\n", p);
 550             } else {
 551                 OBJ_create_objects(oid_bio);
 552                 BIO_free(oid_bio);
 553             }
 554         }
 555     }
 556     if (!add_oid_section(req_conf))
 557         goto end;
 558
 559     /* Check that any specified digest is fetchable */
 560     if (digest != NULL) {
 561         if (!opt_check_md(digest))
 562             goto opthelp;
 563     } else {
 564         /* No digest specified, default to configuration */
 565         p = app_conf_try_string(req_conf, section, "default_md");
 566         if (p != NULL)
 567             digest = p;
 568     }
 569
 570     if (extsect == NULL)
 571         extsect = app_conf_try_string(req_conf, section,
 572                                    gen_x509 ? V3_EXTENSIONS : REQ_EXTENSIONS);
 573     if (extsect != NULL) {
 574         /* Check syntax of extension section in config file */
 575         X509V3_CTX ctx;
 576
 577         X509V3_set_ctx_test(&ctx);
 578         X509V3_set_nconf(&ctx, req_conf);
 579         if (!X509V3_EXT_add_nconf(req_conf, &ctx, extsect, NULL)) {
 580             BIO_printf(bio_err,
 581                        "Error checking %s extension section %s\n",
 582                        gen_x509 ? "x509" : "request", extsect);
 583             goto end;
 584         }
 585     }
 586     if (addext_conf != NULL) {
 587         /* Check syntax of command line extensions */
 588         X509V3_CTX ctx;
 589
 590         X509V3_set_ctx_test(&ctx);
 591         X509V3_set_nconf(&ctx, req_conf);
 592         if (!X509V3_EXT_add_nconf(addext_conf, &ctx, "default", NULL)) {
 593             BIO_printf(bio_err, "Error checking extensions defined using -addext\n");
 594             goto end;
 595         }
 596     }
 597
 598     if (passin == NULL)
 599         passin = nofree_passin =
 600             app_conf_try_string(req_conf, section, "input_password");
 601
 602     if (passout == NULL)
 603         passout = nofree_passout =
 604             app_conf_try_string(req_conf, section, "output_password");
 605
 606     p = app_conf_try_string(req_conf, section, STRING_MASK);
 607     if (p != NULL && !ASN1_STRING_set_default_mask_asc(p)) {
 608         BIO_printf(bio_err, "Invalid global string mask setting %s\n", p);
 609         goto end;
 610     }
 611
 612     if (chtype != MBSTRING_UTF8) {
 613         p = app_conf_try_string(req_conf, section, UTF8_IN);
 614         if (p != NULL && strcmp(p, "yes") == 0)
 615             chtype = MBSTRING_UTF8;
 616     }
 617
 618     if (keyfile != NULL) {
 619         pkey = load_key(keyfile, keyform, 0, passin, e, "private key");
 620         if (pkey == NULL)
 621             goto end;
 622         app_RAND_load_conf(req_conf, section);
 623     }
 624     if (keyalg != NULL && pkey != NULL) {
 625         BIO_printf(bio_err,
 626                    "Warning: Not generating key via given -newkey option since -key is given\n");
 627         /* Better throw an error in this case */
 628     }
 629     if (newreq && pkey == NULL) {
 630         app_RAND_load_conf(req_conf, section);
 631
 632         if (!app_conf_try_number(req_conf, section, BITS, &newkey_len))
 633             newkey_len = DEFAULT_KEY_LENGTH;
 634
 635         genctx = set_keygen_ctx(keyalg, &keyalgstr, &newkey_len, gen_eng);
 636         if (genctx == NULL)
 637             goto end;
 638
 639         if (newkey_len < MIN_KEY_LENGTH
 640             && (EVP_PKEY_CTX_is_a(genctx, "RSA")
 641                 || EVP_PKEY_CTX_is_a(genctx, "RSA-PSS")
 642                 || EVP_PKEY_CTX_is_a(genctx, "DSA"))) {
 643             BIO_printf(bio_err, "Private key length too short, needs to be at least %d bits, not %ld.\n",
 644                        MIN_KEY_LENGTH, newkey_len);
 645             goto end;
 646         }
 647
 648         if (newkey_len > OPENSSL_RSA_MAX_MODULUS_BITS
 649             && (EVP_PKEY_CTX_is_a(genctx, "RSA")
 650                 || EVP_PKEY_CTX_is_a(genctx, "RSA-PSS")))
 651             BIO_printf(bio_err,
 652                        "Warning: It is not recommended to use more than %d bit for RSA keys.\n"
 653                        "         Your key size is %ld! Larger key size may behave not as expected.\n",
 654                        OPENSSL_RSA_MAX_MODULUS_BITS, newkey_len);
 655
 656 #ifndef OPENSSL_NO_DSA
 657         if (EVP_PKEY_CTX_is_a(genctx, "DSA")
 658                 && newkey_len > OPENSSL_DSA_MAX_MODULUS_BITS)
 659             BIO_printf(bio_err,
 660                        "Warning: It is not recommended to use more than %d bit for DSA keys.\n"
 661                        "         Your key size is %ld! Larger key size may behave not as expected.\n",
 662                        OPENSSL_DSA_MAX_MODULUS_BITS, newkey_len);
 663 #endif
 664
 665         if (pkeyopts != NULL) {
 666             char *genopt;
 667             for (i = 0; i < sk_OPENSSL_STRING_num(pkeyopts); i++) {
 668                 genopt = sk_OPENSSL_STRING_value(pkeyopts, i);
 669                 if (pkey_ctrl_string(genctx, genopt) <= 0) {
 670                     BIO_printf(bio_err, "Key parameter error \"%s\"\n", genopt);
 671                     goto end;
 672                 }
 673             }
 674         }
 675
 676         EVP_PKEY_CTX_set_app_data(genctx, bio_err);
 677         if (progress)
 678             EVP_PKEY_CTX_set_cb(genctx, progress_cb);
 679
 680         pkey = app_keygen(genctx, keyalgstr, newkey_len, verbose);
 681         if (pkey == NULL)
 682             goto end;
 683
 684         EVP_PKEY_CTX_free(genctx);
 685         genctx = NULL;
 686     }
 687     if (keyout == NULL && keyfile == NULL)
 688         keyout = app_conf_try_string(req_conf, section, KEYFILE);
 689
 690     if (pkey != NULL && (keyfile == NULL || keyout != NULL)) {
 691         if (verbose) {
 692             BIO_printf(bio_err, "Writing private key to ");
 693             if (keyout == NULL)
 694                 BIO_printf(bio_err, "stdout\n");
 695             else
 696                 BIO_printf(bio_err, "'%s'\n", keyout);
 697         }
 698         out = bio_open_owner(keyout, outformat, newreq);
 699         if (out == NULL)
 700             goto end;
 701
 702         p = app_conf_try_string(req_conf, section, "encrypt_rsa_key");
 703         if (p == NULL)
 704             p = app_conf_try_string(req_conf, section, "encrypt_key");
 705         if (p != NULL && strcmp(p, "no") == 0)
 706             cipher = NULL;
 707         if (noenc)
 708             cipher = NULL;
 709
 710         i = 0;
 711  loop:
 712         if (!PEM_write_bio_PrivateKey(out, pkey, cipher,
 713                                       NULL, 0, NULL, passout)) {
 714             if ((ERR_GET_REASON(ERR_peek_error()) ==
 715                  PEM_R_PROBLEMS_GETTING_PASSWORD) && (i < 3)) {
 716                 ERR_clear_error();
 717                 i++;
 718                 goto loop;
 719             }
 720             goto end;
 721         }
 722         BIO_free_all(out);
 723         out = NULL;
 724         BIO_printf(bio_err, "-----\n");
 725     }
 726
 727     /*
 728      * subj is expected to be in the format /type0=value0/type1=value1/type2=...
 729      * where characters may be escaped by \
 730      */
 731     if (subj != NULL
 732             && (fsubj = parse_name(subj, chtype, multirdn, "subject")) == NULL)
 733         goto end;
 734
 735     if (!newreq) {
 736         if (keyfile != NULL)
 737             BIO_printf(bio_err,
 738                        "Warning: Not placing -key in cert or request since request is used\n");
 739         req = load_csr_autofmt(infile /* if NULL, reads from stdin */,
 740                                informat, vfyopts, "X509 request");
 741         if (req == NULL)
 742             goto end;
 743     } else if (infile != NULL) {
 744         BIO_printf(bio_err,
 745                    "Warning: Ignoring -in option since -new or -newkey or -precert is given\n");
 746         /* Better throw an error in this case, as done in the x509 app */
 747     }
 748
 749     if (CAkeyfile == NULL)
 750         CAkeyfile = CAfile;
 751     if (CAkeyfile != NULL) {
 752         if (CAfile == NULL) {
 753             BIO_printf(bio_err,
 754                        "Warning: Ignoring -CAkey option since no -CA option is given\n");
 755         } else {
 756             if ((CAkey = load_key(CAkeyfile, FORMAT_UNDEF,
 757                                   0, passin, e,
 758                                   CAkeyfile != CAfile
 759                                   ? "issuer private key from -CAkey arg"
 760                                   : "issuer private key from -CA arg")) == NULL)
 761                 goto end;
 762         }
 763     }
 764     if (CAfile != NULL) {
 765         if ((CAcert = load_cert_pass(CAfile, FORMAT_UNDEF, 1, passin,
 766                                      "issuer cert from -CA arg")) == NULL)
 767             goto end;
 768         if (!X509_check_private_key(CAcert, CAkey)) {
 769             BIO_printf(bio_err,
 770                        "Issuer CA certificate and key do not match\n");
 771             goto end;
 772         }
 773     }
 774     if (newreq || gen_x509) {
 775         if (CAcert == NULL && pkey == NULL) {
 776             BIO_printf(bio_err, "Must provide a signature key using -key or"
 777                 " provide -CA / -CAkey\n");
 778             goto end;
 779         }
 780
 781         if (req == NULL) {
 782             req = X509_REQ_new_ex(app_get0_libctx(), app_get0_propq());
 783             if (req == NULL) {
 784                 goto end;
 785             }
 786
 787             if (!make_REQ(req, pkey, fsubj, multirdn, !gen_x509, chtype)) {
 788                 BIO_printf(bio_err, "Error making certificate request\n");
 789                 goto end;
 790             }
 791             /* Note that -x509 can take over -key and -subj option values. */
 792         }
 793         if (gen_x509) {
 794             EVP_PKEY *pub_key = X509_REQ_get0_pubkey(req);
 795             EVP_PKEY *issuer_key = CAcert != NULL ? CAkey : pkey;
 796             X509V3_CTX ext_ctx;
 797             X509_NAME *issuer = CAcert != NULL ? X509_get_subject_name(CAcert) :
 798                 X509_REQ_get_subject_name(req);
 799             X509_NAME *n_subj = fsubj != NULL ? fsubj :
 800                 X509_REQ_get_subject_name(req);
 801
 802             if (CAcert != NULL && keyfile != NULL)
 803                 BIO_printf(bio_err,
 804                            "Warning: Not using -key or -newkey for signing since -CA option is given\n");
 805
 806             if ((new_x509 = X509_new_ex(app_get0_libctx(),
 807                                         app_get0_propq())) == NULL)
 808                 goto end;
 809
 810             if (serial != NULL) {
 811                 if (!X509_set_serialNumber(new_x509, serial))
 812                     goto end;
 813             } else {
 814                 if (!rand_serial(NULL, X509_get_serialNumber(new_x509)))
 815                     goto end;
 816             }
 817
 818             if (!X509_set_issuer_name(new_x509, issuer))
 819                 goto end;
 820             if (days == UNSET_DAYS)
 821                 days = DEFAULT_DAYS;
 822             else if (not_after != NULL)
 823                 BIO_printf(bio_err,"Warning: -not_after option overriding -days option\n");
 824             if (!set_cert_times(new_x509, not_before, not_after, days, 1))
 825                 goto end;
 826             if (!X509_set_subject_name(new_x509, n_subj))
 827                 goto end;
 828             if (!pub_key || !X509_set_pubkey(new_x509, pub_key))
 829                 goto end;
 830             if (ext_copy == EXT_COPY_UNSET) {
 831                 if (infile != NULL)
 832                     BIO_printf(bio_err, "Warning: No -copy_extensions given; ignoring any extensions in the request\n");
 833             } else if (!copy_extensions(new_x509, req, ext_copy)) {
 834                 BIO_printf(bio_err, "Error copying extensions from request\n");
 835                 goto end;
 836             }
 837
 838             /* Set up V3 context struct */
 839             X509V3_set_ctx(&ext_ctx, CAcert != NULL ? CAcert : new_x509,
 840                            new_x509, NULL, NULL, X509V3_CTX_REPLACE);
 841             /* prepare fallback for AKID, but only if issuer cert == new_x509 */
 842             if (CAcert == NULL) {
 843                 if (!X509V3_set_issuer_pkey(&ext_ctx, issuer_key))
 844                     goto end;
 845                 if (!cert_matches_key(new_x509, issuer_key))
 846                     BIO_printf(bio_err,
 847                                "Warning: Signature key and public key of cert do not match\n");
 848             }
 849             X509V3_set_nconf(&ext_ctx, req_conf);
 850
 851             /* Add extensions */
 852             if (extsect != NULL
 853                 && !X509V3_EXT_add_nconf(req_conf, &ext_ctx, extsect, new_x509)) {
 854                 BIO_printf(bio_err, "Error adding x509 extensions from section %s\n",
 855                            extsect);
 856                 goto end;
 857             }
 858             if (addext_conf != NULL
 859                 && !X509V3_EXT_add_nconf(addext_conf, &ext_ctx, "default",
 860                                          new_x509)) {
 861                 BIO_printf(bio_err, "Error adding x509 extensions defined via -addext\n");
 862                 goto end;
 863             }
 864
 865             /* If a pre-cert was requested, we need to add a poison extension */
 866             if (precert) {
 867                 if (X509_add1_ext_i2d(new_x509, NID_ct_precert_poison,
 868                                       NULL, 1, 0) != 1) {
 869                     BIO_printf(bio_err, "Error adding poison extension\n");
 870                     goto end;
 871                 }
 872             }
 873
 874             i = do_X509_sign(new_x509, x509v1, issuer_key, digest, sigopts,
 875                              &ext_ctx);
 876             if (!i)
 877                 goto end;
 878         } else {
 879             X509V3_CTX ext_ctx;
 880
 881             if (precert) {
 882                 BIO_printf(bio_err,
 883                            "Warning: Ignoring -precert flag since no cert is produced\n");
 884             }
 885             /* Set up V3 context struct */
 886             X509V3_set_ctx(&ext_ctx, NULL, NULL, req, NULL, X509V3_CTX_REPLACE);
 887             X509V3_set_nconf(&ext_ctx, req_conf);
 888
 889             /* Add extensions */
 890             if (extsect != NULL
 891                 && !X509V3_EXT_REQ_add_nconf(req_conf, &ext_ctx, extsect, req)) {
 892                 BIO_printf(bio_err, "Error adding request extensions from section %s\n",
 893                            extsect);
 894                 goto end;
 895             }
 896             if (addext_conf != NULL
 897                 && !X509V3_EXT_REQ_add_nconf(addext_conf, &ext_ctx, "default",
 898                                              req)) {
 899                 BIO_printf(bio_err, "Error adding request extensions defined via -addext\n");
 900                 goto end;
 901             }
 902             i = do_X509_REQ_sign(req, pkey, digest, sigopts);
 903             if (!i)
 904                 goto end;
 905         }
 906     }
 907
 908     if (subj != NULL && !newreq && !gen_x509) {
 909         if (verbose) {
 910             BIO_printf(out, "Modifying subject of certificate request\n");
 911             print_name(out, "Old subject=", X509_REQ_get_subject_name(req));
 912         }
 913
 914         if (!X509_REQ_set_subject_name(req, fsubj)) {
 915             BIO_printf(bio_err, "Error modifying subject of certificate request\n");
 916             goto end;
 917         }
 918
 919         if (verbose) {
 920             print_name(out, "New subject=", X509_REQ_get_subject_name(req));
 921         }
 922     }
 923
 924     if (verify) {
 925         EVP_PKEY *tpubkey = pkey;
 926
 927         if (tpubkey == NULL) {
 928             tpubkey = X509_REQ_get0_pubkey(req);
 929             if (tpubkey == NULL)
 930                 goto end;
 931         }
 932
 933         i = do_X509_REQ_verify(req, tpubkey, vfyopts);
 934
 935         if (i < 0)
 936             goto end;
 937         if (i == 0) {
 938             BIO_printf(bio_err, "Certificate request self-signature verify failure\n");
 939             goto end;
 940         } else /* i > 0 */
 941             BIO_printf(bio_out, "Certificate request self-signature verify OK\n");
 942     }
 943
 944     if (noout && !text && !modulus && !subject && !pubkey) {
 945         ret = 0;
 946         goto end;
 947     }
 948
 949     out = bio_open_default(outfile,
 950                            keyout != NULL && outfile != NULL &&
 951                            strcmp(keyout, outfile) == 0 ? 'a' : 'w',
 952                            outformat);
 953     if (out == NULL)
 954         goto end;
 955
 956     if (pubkey) {
 957         EVP_PKEY *tpubkey = X509_REQ_get0_pubkey(req);
 958
 959         if (tpubkey == NULL) {
 960             BIO_printf(bio_err, "Error getting public key\n");
 961             goto end;
 962         }
 963         PEM_write_bio_PUBKEY(out, tpubkey);
 964     }
 965
 966     if (text) {
 967         if (gen_x509)
 968             ret = X509_print_ex(out, new_x509, get_nameopt(), reqflag);
 969         else
 970             ret = X509_REQ_print_ex(out, req, get_nameopt(), reqflag);
 971
 972         if (ret == 0) {
 973             if (gen_x509)
 974                 BIO_printf(bio_err, "Error printing certificate\n");
 975             else
 976                 BIO_printf(bio_err, "Error printing certificate request\n");
 977             goto end;
 978         }
 979     }
 980
 981     if (subject) {
 982         print_name(out, "subject=", gen_x509
 983                    ? X509_get_subject_name(new_x509)
 984                    : X509_REQ_get_subject_name(req));
 985     }
 986
 987     if (modulus) {
 988         EVP_PKEY *tpubkey;
 989
 990         if (gen_x509)
 991             tpubkey = X509_get0_pubkey(new_x509);
 992         else
 993             tpubkey = X509_REQ_get0_pubkey(req);
 994         if (tpubkey == NULL) {
 995             BIO_puts(bio_err, "Modulus is unavailable\n");
 996             goto end;
 997         }
 998         BIO_puts(out, "Modulus=");
 999         if (EVP_PKEY_is_a(tpubkey, "RSA") || EVP_PKEY_is_a(tpubkey, "RSA-PSS")) {
1000             BIGNUM *n = NULL;
1001
1002             if (!EVP_PKEY_get_bn_param(tpubkey, "n", &n))
1003                 goto end;
1004             BN_print(out, n);
1005             BN_free(n);
1006         } else {
1007             BIO_puts(out, "Wrong Algorithm type");
1008         }
1009         BIO_puts(out, "\n");
1010     }
1011
1012     if (!noout && !gen_x509) {
1013         if (outformat == FORMAT_ASN1)
1014             i = i2d_X509_REQ_bio(out, req);
1015         else if (newhdr)
1016             i = PEM_write_bio_X509_REQ_NEW(out, req);
1017         else
1018             i = PEM_write_bio_X509_REQ(out, req);
1019         if (!i) {
1020             BIO_printf(bio_err, "Unable to write certificate request\n");
1021             goto end;
1022         }
1023     }
1024     if (!noout && gen_x509 && new_x509 != NULL) {
1025         if (outformat == FORMAT_ASN1)
1026             i = i2d_X509_bio(out, new_x509);
1027         else
1028             i = PEM_write_bio_X509(out, new_x509);
1029         if (!i) {
1030             BIO_printf(bio_err, "Unable to write X509 certificate\n");
1031             goto end;
1032         }
1033     }
1034     ret = 0;
1035  end:
1036     if (ret) {
1037         ERR_print_errors(bio_err);
1038     }
1039     NCONF_free(req_conf);
1040     NCONF_free(addext_conf);
1041     BIO_free(addext_bio);
1042     BIO_free_all(out);
1043     EVP_PKEY_free(pkey);
1044     EVP_PKEY_CTX_free(genctx);
1045     sk_OPENSSL_STRING_free(pkeyopts);
1046     sk_OPENSSL_STRING_free(sigopts);
1047     sk_OPENSSL_STRING_free(vfyopts);
1048     lh_OPENSSL_STRING_doall(addexts, exts_cleanup);
1049     lh_OPENSSL_STRING_free(addexts);
1050 #ifndef OPENSSL_NO_ENGINE
1051     release_engine(gen_eng);
1052 #endif
1053     OPENSSL_free(keyalgstr);
1054     X509_REQ_free(req);
1055     X509_NAME_free(fsubj);
1056     X509_free(new_x509);
1057     X509_free(CAcert);
1058     EVP_PKEY_free(CAkey);
1059     ASN1_INTEGER_free(serial);
1060     release_engine(e);
1061     if (passin != nofree_passin)
1062         OPENSSL_free(passin);
1063     if (passout != nofree_passout)
1064         OPENSSL_free(passout);
1065     return ret;
1066 }
1067
1068 static int make_REQ(X509_REQ *req, EVP_PKEY *pkey, X509_NAME *fsubj,
1069                     int multirdn, int attribs, unsigned long chtype)
1070 {
1071     int ret = 0, i;
1072     char no_prompt = 0;
1073     STACK_OF(CONF_VALUE) *dn_sk = NULL, *attr_sk = NULL;
1074     char *tmp, *dn_sect, *attr_sect;
1075
1076     tmp = app_conf_try_string(req_conf, section, PROMPT);
1077     if (tmp != NULL && strcmp(tmp, "no") == 0)
1078         no_prompt = 1;
1079
1080     dn_sect = app_conf_try_string(req_conf, section, DISTINGUISHED_NAME);
1081     if (dn_sect != NULL) {
1082         dn_sk = NCONF_get_section(req_conf, dn_sect);
1083         if (dn_sk == NULL) {
1084             BIO_printf(bio_err, "Unable to get '%s' section\n", dn_sect);
1085             goto err;
1086         }
1087     }
1088
1089     attr_sect = app_conf_try_string(req_conf, section, ATTRIBUTES);
1090     if (attr_sect != NULL) {
1091         attr_sk = NCONF_get_section(req_conf, attr_sect);
1092         if (attr_sk == NULL) {
1093             BIO_printf(bio_err, "Unable to get '%s' section\n", attr_sect);
1094             goto err;
1095         }
1096     }
1097
1098     /* so far there is only version 1 */
1099     if (!X509_REQ_set_version(req, X509_REQ_VERSION_1))
1100         goto err;
1101
1102     if (fsubj != NULL)
1103         i = X509_REQ_set_subject_name(req, fsubj);
1104     else if (no_prompt)
1105         i = auto_info(req, dn_sk, attr_sk, attribs, chtype);
1106     else
1107         i = prompt_info(req, dn_sk, dn_sect, attr_sk, attr_sect, attribs,
1108                         chtype);
1109     if (!i)
1110         goto err;
1111
1112     if (!X509_REQ_set_pubkey(req, pkey))
1113         goto err;
1114
1115     ret = 1;
1116  err:
1117     return ret;
1118 }
1119
1120 static int prompt_info(X509_REQ *req,
1121                        STACK_OF(CONF_VALUE) *dn_sk, const char *dn_sect,
1122                        STACK_OF(CONF_VALUE) *attr_sk, const char *attr_sect,
1123                        int attribs, unsigned long chtype)
1124 {
1125     int i;
1126     char *p, *q;
1127     char buf[100];
1128     int nid, mval;
1129     long n_min, n_max;
1130     char *type, *value;
1131     const char *def;
1132     CONF_VALUE *v;
1133     X509_NAME *subj = X509_REQ_get_subject_name(req);
1134
1135     if (!batch) {
1136         BIO_printf(bio_err,
1137                    "You are about to be asked to enter information that will be incorporated\n");
1138         BIO_printf(bio_err, "into your certificate request.\n");
1139         BIO_printf(bio_err,
1140                    "What you are about to enter is what is called a Distinguished Name or a DN.\n");
1141         BIO_printf(bio_err,
1142                    "There are quite a few fields but you can leave some blank\n");
1143         BIO_printf(bio_err,
1144                    "For some fields there will be a default value,\n");
1145         BIO_printf(bio_err,
1146                    "If you enter '.', the field will be left blank.\n");
1147         BIO_printf(bio_err, "-----\n");
1148     }
1149
1150     if (sk_CONF_VALUE_num(dn_sk)) {
1151         i = -1;
1152  start:
1153         for (;;) {
1154             i++;
1155             if (sk_CONF_VALUE_num(dn_sk) <= i)
1156                 break;
1157
1158             v = sk_CONF_VALUE_value(dn_sk, i);
1159             p = q = NULL;
1160             type = v->name;
1161             if (!check_end(type, "_min") || !check_end(type, "_max") ||
1162                 !check_end(type, "_default") || !check_end(type, "_value"))
1163                 continue;
1164             /*
1165              * Skip past any leading X. X: X, etc to allow for multiple
1166              * instances
1167              */
1168             for (p = v->name; *p; p++)
1169                 if ((*p == ':') || (*p == ',') || (*p == '.')) {
1170                     p++;
1171                     if (*p)
1172                         type = p;
1173                     break;
1174                 }
1175             if (*type == '+') {
1176                 mval = -1;
1177                 type++;
1178             } else {
1179                 mval = 0;
1180             }
1181             /* If OBJ not recognised ignore it */
1182             if ((nid = OBJ_txt2nid(type)) == NID_undef)
1183                 goto start;
1184             if (!join(buf, sizeof(buf), v->name, "_default", "Name"))
1185                 return 0;
1186             if ((def = app_conf_try_string(req_conf, dn_sect, buf)) == NULL)
1187                 def = "";
1188
1189             if (!join(buf, sizeof(buf), v->name, "_value", "Name"))
1190                 return 0;
1191             if ((value = app_conf_try_string(req_conf, dn_sect, buf)) == NULL)
1192                 value = NULL;
1193
1194             if (!join(buf, sizeof(buf), v->name, "_min", "Name"))
1195                 return 0;
1196             if (!app_conf_try_number(req_conf, dn_sect, buf, &n_min))
1197                 n_min = -1;
1198
1199             if (!join(buf, sizeof(buf), v->name, "_max", "Name"))
1200                 return 0;
1201             if (!app_conf_try_number(req_conf, dn_sect, buf, &n_max))
1202                 n_max = -1;
1203
1204             if (!add_DN_object(subj, v->value, def, value, nid,
1205                                n_min, n_max, chtype, mval))
1206                 return 0;
1207         }
1208         if (X509_NAME_entry_count(subj) == 0) {
1209             BIO_printf(bio_err, "Error: No objects specified in config file\n");
1210             return 0;
1211         }
1212
1213         if (attribs) {
1214             if ((attr_sk != NULL) && (sk_CONF_VALUE_num(attr_sk) > 0)
1215                 && (!batch)) {
1216                 BIO_printf(bio_err,
1217                            "\nPlease enter the following 'extra' attributes\n");
1218                 BIO_printf(bio_err,
1219                            "to be sent with your certificate request\n");
1220             }
1221
1222             i = -1;
1223  start2:
1224             for (;;) {
1225                 i++;
1226                 if ((attr_sk == NULL) || (sk_CONF_VALUE_num(attr_sk) <= i))
1227                     break;
1228
1229                 v = sk_CONF_VALUE_value(attr_sk, i);
1230                 type = v->name;
1231                 if ((nid = OBJ_txt2nid(type)) == NID_undef)
1232                     goto start2;
1233
1234                 if (!join(buf, sizeof(buf), type, "_default", "Name"))
1235                     return 0;
1236                 def = app_conf_try_string(req_conf, attr_sect, buf);
1237                 if (def == NULL)
1238                     def = "";
1239
1240                 if (!join(buf, sizeof(buf), type, "_value", "Name"))
1241                     return 0;
1242                 value = app_conf_try_string(req_conf, attr_sect, buf);
1243
1244                 if (!join(buf, sizeof(buf), type, "_min", "Name"))
1245                     return 0;
1246                 if (!app_conf_try_number(req_conf, attr_sect, buf, &n_min))
1247                     n_min = -1;
1248
1249                 if (!join(buf, sizeof(buf), type, "_max", "Name"))
1250                     return 0;
1251                 if (!app_conf_try_number(req_conf, attr_sect, buf, &n_max))
1252                     n_max = -1;
1253
1254                 if (!add_attribute_object(req,
1255                                           v->value, def, value, nid, n_min,
1256                                           n_max, chtype))
1257                     return 0;
1258             }
1259         }
1260     } else {
1261         BIO_printf(bio_err, "No template, please set one up.\n");
1262         return 0;
1263     }
1264
1265     return 1;
1266
1267 }
1268
1269 static int auto_info(X509_REQ *req, STACK_OF(CONF_VALUE) *dn_sk,
1270                      STACK_OF(CONF_VALUE) *attr_sk, int attribs,
1271                      unsigned long chtype)
1272 {
1273     int i, spec_char, plus_char;
1274     char *p, *q;
1275     char *type;
1276     CONF_VALUE *v;
1277     X509_NAME *subj;
1278
1279     subj = X509_REQ_get_subject_name(req);
1280
1281     for (i = 0; i < sk_CONF_VALUE_num(dn_sk); i++) {
1282         int mval;
1283         v = sk_CONF_VALUE_value(dn_sk, i);
1284         p = q = NULL;
1285         type = v->name;
1286         /*
1287          * Skip past any leading X. X: X, etc to allow for multiple instances
1288          */
1289         for (p = v->name; *p; p++) {
1290 #ifndef CHARSET_EBCDIC
1291             spec_char = (*p == ':' || *p == ',' || *p == '.');
1292 #else
1293             spec_char = (*p == os_toascii[':'] || *p == os_toascii[',']
1294                          || *p == os_toascii['.']);
1295 #endif
1296             if (spec_char) {
1297                 p++;
1298                 if (*p)
1299                     type = p;
1300                 break;
1301             }
1302         }
1303 #ifndef CHARSET_EBCDIC
1304         plus_char = (*type == '+');
1305 #else
1306         plus_char = (*type == os_toascii['+']);
1307 #endif
1308         if (plus_char) {
1309             type++;
1310             mval = -1;
1311         } else {
1312             mval = 0;
1313         }
1314         if (!X509_NAME_add_entry_by_txt(subj, type, chtype,
1315                                         (unsigned char *)v->value, -1, -1,
1316                                         mval))
1317             return 0;
1318
1319     }
1320
1321     if (!X509_NAME_entry_count(subj)) {
1322         BIO_printf(bio_err, "Error: No objects specified in config file\n");
1323         return 0;
1324     }
1325     if (attribs) {
1326         for (i = 0; i < sk_CONF_VALUE_num(attr_sk); i++) {
1327             v = sk_CONF_VALUE_value(attr_sk, i);
1328             if (!X509_REQ_add1_attr_by_txt(req, v->name, chtype,
1329                                            (unsigned char *)v->value, -1))
1330                 return 0;
1331         }
1332     }
1333     return 1;
1334 }
1335
1336 static int add_DN_object(X509_NAME *n, char *text, const char *def,
1337                          char *value, int nid, int n_min, int n_max,
1338                          unsigned long chtype, int mval)
1339 {
1340     int ret = 0;
1341     char buf[1024];
1342
1343     ret = build_data(text, def, value, n_min, n_max, buf, sizeof(buf),
1344                      "DN value", "DN default");
1345     if ((ret == 0) || (ret == 1))
1346         return ret;
1347     ret = 1;
1348
1349     if (!X509_NAME_add_entry_by_NID(n, nid, chtype,
1350                                     (unsigned char *)buf, -1, -1, mval))
1351         ret = 0;
1352
1353     return ret;
1354 }
1355
1356 static int add_attribute_object(X509_REQ *req, char *text, const char *def,
1357                                 char *value, int nid, int n_min,
1358                                 int n_max, unsigned long chtype)
1359 {
1360     int ret = 0;
1361     char buf[1024];
1362
1363     ret = build_data(text, def, value, n_min, n_max, buf, sizeof(buf),
1364                      "Attribute value", "Attribute default");
1365     if ((ret == 0) || (ret == 1))
1366         return ret;
1367     ret = 1;
1368
1369     if (!X509_REQ_add1_attr_by_NID(req, nid, chtype,
1370                                    (unsigned char *)buf, -1)) {
1371         BIO_printf(bio_err, "Error adding attribute\n");
1372         ret = 0;
1373     }
1374
1375     return ret;
1376 }
1377
1378 static int build_data(char *text, const char *def, char *value,
1379                       int n_min, int n_max, char *buf, const int buf_size,
1380                       const char *desc1, const char *desc2)
1381 {
1382     int i;
1383  start:
1384     if (!batch)
1385         BIO_printf(bio_err, "%s [%s]:", text, def);
1386     (void)BIO_flush(bio_err);
1387     if (value != NULL) {
1388         if (!join(buf, buf_size, value, "\n", desc1))
1389             return 0;
1390         BIO_printf(bio_err, "%s\n", value);
1391     } else {
1392         buf[0] = '\0';
1393         if (!batch) {
1394             if (!fgets(buf, buf_size, stdin))
1395                 return 0;
1396         } else {
1397             buf[0] = '\n';
1398             buf[1] = '\0';
1399         }
1400     }
1401
1402     if (buf[0] == '\0')
1403         return 0;
1404     if (buf[0] == '\n') {
1405         if ((def == NULL) || (def[0] == '\0'))
1406             return 1;
1407         if (!join(buf, buf_size, def, "\n", desc2))
1408             return 0;
1409     } else if ((buf[0] == '.') && (buf[1] == '\n')) {
1410         return 1;
1411     }
1412
1413     i = strlen(buf);
1414     if (buf[i - 1] != '\n') {
1415         BIO_printf(bio_err, "Missing newline at end of input\n");
1416         return 0;
1417     }
1418     buf[--i] = '\0';
1419 #ifdef CHARSET_EBCDIC
1420     ebcdic2ascii(buf, buf, i);
1421 #endif
1422     if (!req_check_len(i, n_min, n_max)) {
1423         if (batch || value)
1424             return 0;
1425         goto start;
1426     }
1427     return 2;
1428 }
1429
1430 static int req_check_len(int len, int n_min, int n_max)
1431 {
1432     if (n_min > 0 && len < n_min) {
1433         BIO_printf(bio_err,
1434                    "String too short, must be at least %d bytes long\n", n_min);
1435         return 0;
1436     }
1437     if (n_max >= 0 && len > n_max) {
1438         BIO_printf(bio_err,
1439                    "String too long, must be at most %d bytes long\n", n_max);
1440         return 0;
1441     }
1442     return 1;
1443 }
1444
1445 /* Check if the end of a string matches 'end' */
1446 static int check_end(const char *str, const char *end)
1447 {
1448     size_t elen, slen;
1449     const char *tmp;
1450
1451     elen = strlen(end);
1452     slen = strlen(str);
1453     if (elen > slen)
1454         return 1;
1455     tmp = str + slen - elen;
1456     return strcmp(tmp, end);
1457 }
1458
1459 /*
1460  * Merge the two strings together into the result buffer checking for
1461  * overflow and producing an error message if there is.
1462  */
1463 static int join(char buf[], size_t buf_size, const char *name,
1464                 const char *tail, const char *desc)
1465 {
1466     const size_t name_len = strlen(name), tail_len = strlen(tail);
1467
1468     if (name_len + tail_len + 1 > buf_size) {
1469         BIO_printf(bio_err, "%s '%s' too long\n", desc, name);
1470         return 0;
1471     }
1472     memcpy(buf, name, name_len);
1473     memcpy(buf + name_len, tail, tail_len + 1);
1474     return 1;
1475 }
1476
1477 static EVP_PKEY_CTX *set_keygen_ctx(const char *gstr,
1478                                     char **pkeytype, long *pkeylen,
1479                                     ENGINE *keygen_engine)
1480 {
1481     EVP_PKEY_CTX *gctx = NULL;
1482     EVP_PKEY *param = NULL;
1483     long keylen = -1;
1484     BIO *pbio = NULL;
1485     const char *keytype = NULL;
1486     size_t keytypelen = 0;
1487     int expect_paramfile = 0;
1488     const char *paramfile = NULL;
1489
1490     /* Treat the first part of gstr, and only that */
1491     if (gstr == NULL) {
1492         /*
1493          * Special case: when no string given, default to RSA and the
1494          * key length given by |*pkeylen|.
1495          */
1496         keytype = "RSA";
1497         keylen = *pkeylen;
1498     } else if (gstr[0] >= '0' && gstr[0] <= '9') {
1499         /* Special case: only keylength given from string, so default to RSA */
1500         keytype = "RSA";
1501         /* The second part treatment will do the rest */
1502     } else {
1503         const char *p = strchr(gstr, ':');
1504         int len;
1505
1506         if (p != NULL)
1507             len = p - gstr;
1508         else
1509             len = strlen(gstr);
1510
1511         if (strncmp(gstr, "param", len) == 0) {
1512             expect_paramfile = 1;
1513             if (p == NULL) {
1514                 BIO_printf(bio_err,
1515                            "Parameter file requested but no path given: %s\n",
1516                            gstr);
1517                 return NULL;
1518             }
1519         } else {
1520             keytype = gstr;
1521             keytypelen = len;
1522         }
1523
1524         if (p != NULL)
1525             gstr = gstr + len + 1;
1526         else
1527             gstr = NULL;
1528     }
1529
1530     /* Treat the second part of gstr, if there is one */
1531     if (gstr != NULL) {
1532         /* If the second part starts with a digit, we assume it's a size */
1533         if (!expect_paramfile && gstr[0] >= '0' && gstr[0] <= '9')
1534             keylen = atol(gstr);
1535         else
1536             paramfile = gstr;
1537     }
1538
1539     if (paramfile != NULL) {
1540         pbio = BIO_new_file(paramfile, "r");
1541         if (pbio == NULL) {
1542             BIO_printf(bio_err, "Cannot open parameter file %s\n", paramfile);
1543             return NULL;
1544         }
1545         param = PEM_read_bio_Parameters(pbio, NULL);
1546
1547         if (param == NULL) {
1548             X509 *x;
1549
1550             (void)BIO_reset(pbio);
1551             x = PEM_read_bio_X509(pbio, NULL, NULL, NULL);
1552             if (x != NULL) {
1553                 param = X509_get_pubkey(x);
1554                 X509_free(x);
1555             }
1556         }
1557
1558         BIO_free(pbio);
1559
1560         if (param == NULL) {
1561             BIO_printf(bio_err, "Error reading parameter file %s\n", paramfile);
1562             return NULL;
1563         }
1564         if (keytype == NULL) {
1565             keytype = EVP_PKEY_get0_type_name(param);
1566             if (keytype == NULL) {
1567                 EVP_PKEY_free(param);
1568                 BIO_puts(bio_err, "Unable to determine key type\n");
1569                 return NULL;
1570             }
1571         }
1572     }
1573
1574     if (keytypelen > 0)
1575         *pkeytype = OPENSSL_strndup(keytype, keytypelen);
1576     else
1577         *pkeytype = OPENSSL_strdup(keytype);
1578
1579     if (*pkeytype == NULL) {
1580         BIO_printf(bio_err, "Out of memory\n");
1581         EVP_PKEY_free(param);
1582         return NULL;
1583     }
1584
1585     if (keylen >= 0)
1586         *pkeylen = keylen;
1587
1588     if (param != NULL) {
1589         if (!EVP_PKEY_is_a(param, *pkeytype)) {
1590             BIO_printf(bio_err, "Key type does not match parameters\n");
1591             EVP_PKEY_free(param);
1592             return NULL;
1593         }
1594
1595         if (keygen_engine != NULL)
1596             gctx = EVP_PKEY_CTX_new(param, keygen_engine);
1597         else
1598             gctx = EVP_PKEY_CTX_new_from_pkey(app_get0_libctx(),
1599                                               param, app_get0_propq());
1600         *pkeylen = EVP_PKEY_get_bits(param);
1601         EVP_PKEY_free(param);
1602     } else {
1603         if (keygen_engine != NULL) {
1604             int pkey_id = get_legacy_pkey_id(app_get0_libctx(), *pkeytype,
1605                                              keygen_engine);
1606
1607             if (pkey_id != NID_undef)
1608                 gctx = EVP_PKEY_CTX_new_id(pkey_id, keygen_engine);
1609         } else {
1610             gctx = EVP_PKEY_CTX_new_from_name(app_get0_libctx(),
1611                                               *pkeytype, app_get0_propq());
1612         }
1613     }
1614
1615     if (gctx == NULL) {
1616         BIO_puts(bio_err, "Error allocating keygen context\n");
1617         return NULL;
1618     }
1619
1620     if (EVP_PKEY_keygen_init(gctx) <= 0) {
1621         BIO_puts(bio_err, "Error initializing keygen context\n");
1622         EVP_PKEY_CTX_free(gctx);
1623         return NULL;
1624     }
1625     if (keylen == -1 && (EVP_PKEY_CTX_is_a(gctx, "RSA")
1626         || EVP_PKEY_CTX_is_a(gctx, "RSA-PSS")))
1627         keylen = *pkeylen;
1628
1629     if (keylen != -1) {
1630         OSSL_PARAM params[] = { OSSL_PARAM_END, OSSL_PARAM_END };
1631         size_t bits = keylen;
1632
1633         params[0] =
1634             OSSL_PARAM_construct_size_t(OSSL_PKEY_PARAM_BITS, &bits);
1635         if (EVP_PKEY_CTX_set_params(gctx, params) <= 0) {
1636             BIO_puts(bio_err, "Error setting keysize\n");
1637             EVP_PKEY_CTX_free(gctx);
1638             return NULL;
1639         }
1640     }
1641
1642     return gctx;
1643 }
1644