apps/apps.c

   1 /*
   2  * Copyright 1995-2017 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 #if !defined(_POSIX_C_SOURCE) && defined(OPENSSL_SYS_VMS)
  11 /*
  12  * On VMS, you need to define this to get the declaration of fileno().  The
  13  * value 2 is to make sure no function defined in POSIX-2 is left undefined.
  14  */
  15 # define _POSIX_C_SOURCE 2
  16 #endif
  17
  18 #include <stdio.h>
  19 #include <stdlib.h>
  20 #include <string.h>
  21 #ifndef NO_SYS_TYPES_H
  22 # include <sys/types.h>
  23 #endif
  24 #ifndef OPENSSL_NO_POSIX_IO
  25 # include <sys/stat.h>
  26 # include <fcntl.h>
  27 #endif
  28 #include <ctype.h>
  29 #include <errno.h>
  30 #include <openssl/err.h>
  31 #include <openssl/x509.h>
  32 #include <openssl/x509v3.h>
  33 #include <openssl/pem.h>
  34 #include <openssl/pkcs12.h>
  35 #include <openssl/ui.h>
  36 #include <openssl/safestack.h>
  37 #ifndef OPENSSL_NO_ENGINE
  38 # include <openssl/engine.h>
  39 #endif
  40 #ifndef OPENSSL_NO_RSA
  41 # include <openssl/rsa.h>
  42 #endif
  43 #include <openssl/bn.h>
  44 #include <openssl/ssl.h>
  45 #include "s_apps.h"
  46 #include "apps.h"
  47
  48 #ifdef _WIN32
  49 static int WIN32_rename(const char *from, const char *to);
  50 # define rename(from,to) WIN32_rename((from),(to))
  51 #endif
  52
  53 typedef struct {
  54     const char *name;
  55     unsigned long flag;
  56     unsigned long mask;
  57 } NAME_EX_TBL;
  58
  59 static UI_METHOD *ui_method = NULL;
  60 static const UI_METHOD *ui_fallback_method = NULL;
  61
  62 static int set_table_opts(unsigned long *flags, const char *arg,
  63                           const NAME_EX_TBL * in_tbl);
  64 static int set_multi_opts(unsigned long *flags, const char *arg,
  65                           const NAME_EX_TBL * in_tbl);
  66
  67 int app_init(long mesgwin);
  68
  69 int chopup_args(ARGS *arg, char *buf)
  70 {
  71     int quoted;
  72     char c = '\0', *p = NULL;
  73
  74     arg->argc = 0;
  75     if (arg->size == 0) {
  76         arg->size = 20;
  77         arg->argv = app_malloc(sizeof(*arg->argv) * arg->size, "argv space");
  78     }
  79
  80     for (p = buf;;) {
  81         /* Skip whitespace. */
  82         while (*p && isspace(_UC(*p)))
  83             p++;
  84         if (!*p)
  85             break;
  86
  87         /* The start of something good :-) */
  88         if (arg->argc >= arg->size) {
  89             char **tmp;
  90             arg->size += 20;
  91             tmp = OPENSSL_realloc(arg->argv, sizeof(*arg->argv) * arg->size);
  92             if (tmp == NULL)
  93                 return 0;
  94             arg->argv = tmp;
  95         }
  96         quoted = *p == '\'' || *p == '"';
  97         if (quoted)
  98             c = *p++;
  99         arg->argv[arg->argc++] = p;
 100
 101         /* now look for the end of this */
 102         if (quoted) {
 103             while (*p && *p != c)
 104                 p++;
 105             *p++ = '\0';
 106         } else {
 107             while (*p && !isspace(_UC(*p)))
 108                 p++;
 109             if (*p)
 110                 *p++ = '\0';
 111         }
 112     }
 113     arg->argv[arg->argc] = NULL;
 114     return (1);
 115 }
 116
 117 #ifndef APP_INIT
 118 int app_init(long mesgwin)
 119 {
 120     return (1);
 121 }
 122 #endif
 123
 124 int ctx_set_verify_locations(SSL_CTX *ctx, const char *CAfile,
 125                              const char *CApath, int noCAfile, int noCApath)
 126 {
 127     if (CAfile == NULL && CApath == NULL) {
 128         if (!noCAfile && SSL_CTX_set_default_verify_file(ctx) <= 0)
 129             return 0;
 130         if (!noCApath && SSL_CTX_set_default_verify_dir(ctx) <= 0)
 131             return 0;
 132
 133         return 1;
 134     }
 135     return SSL_CTX_load_verify_locations(ctx, CAfile, CApath);
 136 }
 137
 138 #ifndef OPENSSL_NO_CT
 139
 140 int ctx_set_ctlog_list_file(SSL_CTX *ctx, const char *path)
 141 {
 142     if (path == NULL)
 143         return SSL_CTX_set_default_ctlog_list_file(ctx);
 144
 145     return SSL_CTX_set_ctlog_list_file(ctx, path);
 146 }
 147
 148 #endif
 149
 150 static unsigned long nmflag = 0;
 151 static char nmflag_set = 0;
 152
 153 int set_nameopt(const char *arg)
 154 {
 155     int ret = set_name_ex(&nmflag, arg);
 156
 157     if (ret)
 158         nmflag_set = 1;
 159
 160     return ret;
 161 }
 162
 163 unsigned long get_nameopt(void)
 164 {
 165     return (nmflag_set) ? nmflag : XN_FLAG_ONELINE;
 166 }
 167
 168 int dump_cert_text(BIO *out, X509 *x)
 169 {
 170     print_name(out, "subject=", X509_get_subject_name(x), get_nameopt());
 171     BIO_puts(out, "\n");
 172     print_name(out, "issuer=", X509_get_issuer_name(x), get_nameopt());
 173     BIO_puts(out, "\n");
 174
 175     return 0;
 176 }
 177
 178 static int ui_open(UI *ui)
 179 {
 180     int (*opener)(UI *ui) = UI_method_get_opener(ui_fallback_method);
 181
 182     if (opener)
 183         return opener(ui);
 184     return 1;
 185 }
 186
 187 static int ui_read(UI *ui, UI_STRING *uis)
 188 {
 189     int (*reader)(UI *ui, UI_STRING *uis) = NULL;
 190
 191     if (UI_get_input_flags(uis) & UI_INPUT_FLAG_DEFAULT_PWD
 192         && UI_get0_user_data(ui)) {
 193         switch (UI_get_string_type(uis)) {
 194         case UIT_PROMPT:
 195         case UIT_VERIFY:
 196             {
 197                 const char *password =
 198                     ((PW_CB_DATA *)UI_get0_user_data(ui))->password;
 199                 if (password && password[0] != '\0') {
 200                     UI_set_result(ui, uis, password);
 201                     return 1;
 202                 }
 203             }
 204             break;
 205         case UIT_NONE:
 206         case UIT_BOOLEAN:
 207         case UIT_INFO:
 208         case UIT_ERROR:
 209             break;
 210         }
 211     }
 212
 213     reader = UI_method_get_reader(ui_fallback_method);
 214     if (reader)
 215         return reader(ui, uis);
 216     return 1;
 217 }
 218
 219 static int ui_write(UI *ui, UI_STRING *uis)
 220 {
 221     int (*writer)(UI *ui, UI_STRING *uis) = NULL;
 222
 223     if (UI_get_input_flags(uis) & UI_INPUT_FLAG_DEFAULT_PWD
 224         && UI_get0_user_data(ui)) {
 225         switch (UI_get_string_type(uis)) {
 226         case UIT_PROMPT:
 227         case UIT_VERIFY:
 228             {
 229                 const char *password =
 230                     ((PW_CB_DATA *)UI_get0_user_data(ui))->password;
 231                 if (password && password[0] != '\0')
 232                     return 1;
 233             }
 234             break;
 235         case UIT_NONE:
 236         case UIT_BOOLEAN:
 237         case UIT_INFO:
 238         case UIT_ERROR:
 239             break;
 240         }
 241     }
 242
 243     writer = UI_method_get_writer(ui_fallback_method);
 244     if (writer)
 245         return writer(ui, uis);
 246     return 1;
 247 }
 248
 249 static int ui_close(UI *ui)
 250 {
 251     int (*closer)(UI *ui) = UI_method_get_closer(ui_fallback_method);
 252
 253     if (closer)
 254         return closer(ui);
 255     return 1;
 256 }
 257
 258 int setup_ui_method(void)
 259 {
 260     ui_fallback_method = UI_null();
 261 #ifndef OPENSSL_NO_UI_CONSOLE
 262     ui_fallback_method = UI_OpenSSL();
 263 #endif
 264     ui_method = UI_create_method("OpenSSL application user interface");
 265     UI_method_set_opener(ui_method, ui_open);
 266     UI_method_set_reader(ui_method, ui_read);
 267     UI_method_set_writer(ui_method, ui_write);
 268     UI_method_set_closer(ui_method, ui_close);
 269     return 0;
 270 }
 271
 272 void destroy_ui_method(void)
 273 {
 274     if (ui_method) {
 275         UI_destroy_method(ui_method);
 276         ui_method = NULL;
 277     }
 278 }
 279
 280 const UI_METHOD *get_ui_method(void)
 281 {
 282     return ui_method;
 283 }
 284
 285 int password_callback(char *buf, int bufsiz, int verify, PW_CB_DATA *cb_tmp)
 286 {
 287     int res = 0;
 288     UI *ui = NULL;
 289     PW_CB_DATA *cb_data = (PW_CB_DATA *)cb_tmp;
 290
 291     ui = UI_new_method(ui_method);
 292     if (ui) {
 293         int ok = 0;
 294         char *buff = NULL;
 295         int ui_flags = 0;
 296         const char *prompt_info = NULL;
 297         char *prompt;
 298
 299         if (cb_data != NULL && cb_data->prompt_info != NULL)
 300             prompt_info = cb_data->prompt_info;
 301         prompt = UI_construct_prompt(ui, "pass phrase", prompt_info);
 302         if (!prompt) {
 303             BIO_printf(bio_err, "Out of memory\n");
 304             UI_free(ui);
 305             return 0;
 306         }
 307
 308         ui_flags |= UI_INPUT_FLAG_DEFAULT_PWD;
 309         UI_ctrl(ui, UI_CTRL_PRINT_ERRORS, 1, 0, 0);
 310
 311         /* We know that there is no previous user data to return to us */
 312         (void)UI_add_user_data(ui, cb_data);
 313
 314         ok = UI_add_input_string(ui, prompt, ui_flags, buf,
 315                                  PW_MIN_LENGTH, bufsiz - 1);
 316
 317         if (ok >= 0 && verify) {
 318             buff = app_malloc(bufsiz, "password buffer");
 319             ok = UI_add_verify_string(ui, prompt, ui_flags, buff,
 320                                       PW_MIN_LENGTH, bufsiz - 1, buf);
 321         }
 322         if (ok >= 0)
 323             do {
 324                 ok = UI_process(ui);
 325             } while (ok < 0 && UI_ctrl(ui, UI_CTRL_IS_REDOABLE, 0, 0, 0));
 326
 327         OPENSSL_clear_free(buff, (unsigned int)bufsiz);
 328
 329         if (ok >= 0)
 330             res = strlen(buf);
 331         if (ok == -1) {
 332             BIO_printf(bio_err, "User interface error\n");
 333             ERR_print_errors(bio_err);
 334             OPENSSL_cleanse(buf, (unsigned int)bufsiz);
 335             res = 0;
 336         }
 337         if (ok == -2) {
 338             BIO_printf(bio_err, "aborted!\n");
 339             OPENSSL_cleanse(buf, (unsigned int)bufsiz);
 340             res = 0;
 341         }
 342         UI_free(ui);
 343         OPENSSL_free(prompt);
 344     }
 345     return res;
 346 }
 347
 348 static char *app_get_pass(const char *arg, int keepbio);
 349
 350 int app_passwd(const char *arg1, const char *arg2, char **pass1, char **pass2)
 351 {
 352     int same;
 353     if (arg2 == NULL || arg1 == NULL || strcmp(arg1, arg2))
 354         same = 0;
 355     else
 356         same = 1;
 357     if (arg1 != NULL) {
 358         *pass1 = app_get_pass(arg1, same);
 359         if (*pass1 == NULL)
 360             return 0;
 361     } else if (pass1 != NULL) {
 362         *pass1 = NULL;
 363     }
 364     if (arg2 != NULL) {
 365         *pass2 = app_get_pass(arg2, same ? 2 : 0);
 366         if (*pass2 == NULL)
 367             return 0;
 368     } else if (pass2 != NULL) {
 369         *pass2 = NULL;
 370     }
 371     return 1;
 372 }
 373
 374 static char *app_get_pass(const char *arg, int keepbio)
 375 {
 376     char *tmp, tpass[APP_PASS_LEN];
 377     static BIO *pwdbio = NULL;
 378     int i;
 379
 380     if (strncmp(arg, "pass:", 5) == 0)
 381         return OPENSSL_strdup(arg + 5);
 382     if (strncmp(arg, "env:", 4) == 0) {
 383         tmp = getenv(arg + 4);
 384         if (tmp == NULL) {
 385             BIO_printf(bio_err, "Can't read environment variable %s\n", arg + 4);
 386             return NULL;
 387         }
 388         return OPENSSL_strdup(tmp);
 389     }
 390     if (!keepbio || pwdbio == NULL) {
 391         if (strncmp(arg, "file:", 5) == 0) {
 392             pwdbio = BIO_new_file(arg + 5, "r");
 393             if (pwdbio == NULL) {
 394                 BIO_printf(bio_err, "Can't open file %s\n", arg + 5);
 395                 return NULL;
 396             }
 397 #if !defined(_WIN32)
 398             /*
 399              * Under _WIN32, which covers even Win64 and CE, file
 400              * descriptors referenced by BIO_s_fd are not inherited
 401              * by child process and therefore below is not an option.
 402              * It could have been an option if bss_fd.c was operating
 403              * on real Windows descriptors, such as those obtained
 404              * with CreateFile.
 405              */
 406         } else if (strncmp(arg, "fd:", 3) == 0) {
 407             BIO *btmp;
 408             i = atoi(arg + 3);
 409             if (i >= 0)
 410                 pwdbio = BIO_new_fd(i, BIO_NOCLOSE);
 411             if ((i < 0) || !pwdbio) {
 412                 BIO_printf(bio_err, "Can't access file descriptor %s\n", arg + 3);
 413                 return NULL;
 414             }
 415             /*
 416              * Can't do BIO_gets on an fd BIO so add a buffering BIO
 417              */
 418             btmp = BIO_new(BIO_f_buffer());
 419             pwdbio = BIO_push(btmp, pwdbio);
 420 #endif
 421         } else if (strcmp(arg, "stdin") == 0) {
 422             pwdbio = dup_bio_in(FORMAT_TEXT);
 423             if (!pwdbio) {
 424                 BIO_printf(bio_err, "Can't open BIO for stdin\n");
 425                 return NULL;
 426             }
 427         } else {
 428             BIO_printf(bio_err, "Invalid password argument \"%s\"\n", arg);
 429             return NULL;
 430         }
 431     }
 432     i = BIO_gets(pwdbio, tpass, APP_PASS_LEN);
 433     if (keepbio != 1) {
 434         BIO_free_all(pwdbio);
 435         pwdbio = NULL;
 436     }
 437     if (i <= 0) {
 438         BIO_printf(bio_err, "Error reading password from BIO\n");
 439         return NULL;
 440     }
 441     tmp = strchr(tpass, '\n');
 442     if (tmp != NULL)
 443         *tmp = 0;
 444     return OPENSSL_strdup(tpass);
 445 }
 446
 447 static CONF *app_load_config_(BIO *in, const char *filename)
 448 {
 449     long errorline = -1;
 450     CONF *conf;
 451     int i;
 452
 453     conf = NCONF_new(NULL);
 454     i = NCONF_load_bio(conf, in, &errorline);
 455     if (i > 0)
 456         return conf;
 457
 458     if (errorline <= 0)
 459         BIO_printf(bio_err, "%s: Can't load config file \"%s\"\n",
 460                    opt_getprog(), filename);
 461     else
 462         BIO_printf(bio_err, "%s: Error on line %ld of config file \"%s\"\n",
 463                    opt_getprog(), errorline, filename);
 464     NCONF_free(conf);
 465     return NULL;
 466 }
 467
 468 CONF *app_load_config(const char *filename)
 469 {
 470     BIO *in;
 471     CONF *conf;
 472
 473     in = bio_open_default(filename, 'r', FORMAT_TEXT);
 474     if (in == NULL)
 475         return NULL;
 476
 477     conf = app_load_config_(in, filename);
 478     BIO_free(in);
 479     return conf;
 480 }
 481
 482 CONF *app_load_config_quiet(const char *filename)
 483 {
 484     BIO *in;
 485     CONF *conf;
 486
 487     in = bio_open_default_quiet(filename, 'r', FORMAT_TEXT);
 488     if (in == NULL)
 489         return NULL;
 490
 491     conf = app_load_config_(in, filename);
 492     BIO_free(in);
 493     return conf;
 494 }
 495
 496 int app_load_modules(const CONF *config)
 497 {
 498     CONF *to_free = NULL;
 499
 500     if (config == NULL)
 501         config = to_free = app_load_config_quiet(default_config_file);
 502     if (config == NULL)
 503         return 1;
 504
 505     if (CONF_modules_load(config, NULL, 0) <= 0) {
 506         BIO_printf(bio_err, "Error configuring OpenSSL modules\n");
 507         ERR_print_errors(bio_err);
 508         NCONF_free(to_free);
 509         return 0;
 510     }
 511     NCONF_free(to_free);
 512     return 1;
 513 }
 514
 515 int add_oid_section(CONF *conf)
 516 {
 517     char *p;
 518     STACK_OF(CONF_VALUE) *sktmp;
 519     CONF_VALUE *cnf;
 520     int i;
 521
 522     if ((p = NCONF_get_string(conf, NULL, "oid_section")) == NULL) {
 523         ERR_clear_error();
 524         return 1;
 525     }
 526     if ((sktmp = NCONF_get_section(conf, p)) == NULL) {
 527         BIO_printf(bio_err, "problem loading oid section %s\n", p);
 528         return 0;
 529     }
 530     for (i = 0; i < sk_CONF_VALUE_num(sktmp); i++) {
 531         cnf = sk_CONF_VALUE_value(sktmp, i);
 532         if (OBJ_create(cnf->value, cnf->name, cnf->name) == NID_undef) {
 533             BIO_printf(bio_err, "problem creating object %s=%s\n",
 534                        cnf->name, cnf->value);
 535             return 0;
 536         }
 537     }
 538     return 1;
 539 }
 540
 541 static int load_pkcs12(BIO *in, const char *desc,
 542                        pem_password_cb *pem_cb, void *cb_data,
 543                        EVP_PKEY **pkey, X509 **cert, STACK_OF(X509) **ca)
 544 {
 545     const char *pass;
 546     char tpass[PEM_BUFSIZE];
 547     int len, ret = 0;
 548     PKCS12 *p12;
 549     p12 = d2i_PKCS12_bio(in, NULL);
 550     if (p12 == NULL) {
 551         BIO_printf(bio_err, "Error loading PKCS12 file for %s\n", desc);
 552         goto die;
 553     }
 554     /* See if an empty password will do */
 555     if (PKCS12_verify_mac(p12, "", 0) || PKCS12_verify_mac(p12, NULL, 0)) {
 556         pass = "";
 557     } else {
 558         if (!pem_cb)
 559             pem_cb = (pem_password_cb *)password_callback;
 560         len = pem_cb(tpass, PEM_BUFSIZE, 0, cb_data);
 561         if (len < 0) {
 562             BIO_printf(bio_err, "Passphrase callback error for %s\n", desc);
 563             goto die;
 564         }
 565         if (len < PEM_BUFSIZE)
 566             tpass[len] = 0;
 567         if (!PKCS12_verify_mac(p12, tpass, len)) {
 568             BIO_printf(bio_err,
 569                        "Mac verify error (wrong password?) in PKCS12 file for %s\n",
 570                        desc);
 571             goto die;
 572         }
 573         pass = tpass;
 574     }
 575     ret = PKCS12_parse(p12, pass, pkey, cert, ca);
 576  die:
 577     PKCS12_free(p12);
 578     return ret;
 579 }
 580
 581 #if !defined(OPENSSL_NO_OCSP) && !defined(OPENSSL_NO_SOCK)
 582 static int load_cert_crl_http(const char *url, X509 **pcert, X509_CRL **pcrl)
 583 {
 584     char *host = NULL, *port = NULL, *path = NULL;
 585     BIO *bio = NULL;
 586     OCSP_REQ_CTX *rctx = NULL;
 587     int use_ssl, rv = 0;
 588     if (!OCSP_parse_url(url, &host, &port, &path, &use_ssl))
 589         goto err;
 590     if (use_ssl) {
 591         BIO_puts(bio_err, "https not supported\n");
 592         goto err;
 593     }
 594     bio = BIO_new_connect(host);
 595     if (!bio || !BIO_set_conn_port(bio, port))
 596         goto err;
 597     rctx = OCSP_REQ_CTX_new(bio, 1024);
 598     if (rctx == NULL)
 599         goto err;
 600     if (!OCSP_REQ_CTX_http(rctx, "GET", path))
 601         goto err;
 602     if (!OCSP_REQ_CTX_add1_header(rctx, "Host", host))
 603         goto err;
 604     if (pcert) {
 605         do {
 606             rv = X509_http_nbio(rctx, pcert);
 607         } while (rv == -1);
 608     } else {
 609         do {
 610             rv = X509_CRL_http_nbio(rctx, pcrl);
 611         } while (rv == -1);
 612     }
 613
 614  err:
 615     OPENSSL_free(host);
 616     OPENSSL_free(path);
 617     OPENSSL_free(port);
 618     BIO_free_all(bio);
 619     OCSP_REQ_CTX_free(rctx);
 620     if (rv != 1) {
 621         BIO_printf(bio_err, "Error loading %s from %s\n",
 622                    pcert ? "certificate" : "CRL", url);
 623         ERR_print_errors(bio_err);
 624     }
 625     return rv;
 626 }
 627 #endif
 628
 629 X509 *load_cert(const char *file, int format, const char *cert_descrip)
 630 {
 631     X509 *x = NULL;
 632     BIO *cert;
 633
 634     if (format == FORMAT_HTTP) {
 635 #if !defined(OPENSSL_NO_OCSP) && !defined(OPENSSL_NO_SOCK)
 636         load_cert_crl_http(file, &x, NULL);
 637 #endif
 638         return x;
 639     }
 640
 641     if (file == NULL) {
 642         unbuffer(stdin);
 643         cert = dup_bio_in(format);
 644     } else {
 645         cert = bio_open_default(file, 'r', format);
 646     }
 647     if (cert == NULL)
 648         goto end;
 649
 650     if (format == FORMAT_ASN1) {
 651         x = d2i_X509_bio(cert, NULL);
 652     } else if (format == FORMAT_PEM) {
 653         x = PEM_read_bio_X509_AUX(cert, NULL,
 654                                   (pem_password_cb *)password_callback, NULL);
 655     } else if (format == FORMAT_PKCS12) {
 656         if (!load_pkcs12(cert, cert_descrip, NULL, NULL, NULL, &x, NULL))
 657             goto end;
 658     } else {
 659         BIO_printf(bio_err, "bad input format specified for %s\n", cert_descrip);
 660         goto end;
 661     }
 662  end:
 663     if (x == NULL) {
 664         BIO_printf(bio_err, "unable to load certificate\n");
 665         ERR_print_errors(bio_err);
 666     }
 667     BIO_free(cert);
 668     return (x);
 669 }
 670
 671 X509_CRL *load_crl(const char *infile, int format)
 672 {
 673     X509_CRL *x = NULL;
 674     BIO *in = NULL;
 675
 676     if (format == FORMAT_HTTP) {
 677 #if !defined(OPENSSL_NO_OCSP) && !defined(OPENSSL_NO_SOCK)
 678         load_cert_crl_http(infile, NULL, &x);
 679 #endif
 680         return x;
 681     }
 682
 683     in = bio_open_default(infile, 'r', format);
 684     if (in == NULL)
 685         goto end;
 686     if (format == FORMAT_ASN1) {
 687         x = d2i_X509_CRL_bio(in, NULL);
 688     } else if (format == FORMAT_PEM) {
 689         x = PEM_read_bio_X509_CRL(in, NULL, NULL, NULL);
 690     } else {
 691         BIO_printf(bio_err, "bad input format specified for input crl\n");
 692         goto end;
 693     }
 694     if (x == NULL) {
 695         BIO_printf(bio_err, "unable to load CRL\n");
 696         ERR_print_errors(bio_err);
 697         goto end;
 698     }
 699
 700  end:
 701     BIO_free(in);
 702     return (x);
 703 }
 704
 705 EVP_PKEY *load_key(const char *file, int format, int maybe_stdin,
 706                    const char *pass, ENGINE *e, const char *key_descrip)
 707 {
 708     BIO *key = NULL;
 709     EVP_PKEY *pkey = NULL;
 710     PW_CB_DATA cb_data;
 711
 712     cb_data.password = pass;
 713     cb_data.prompt_info = file;
 714
 715     if (file == NULL && (!maybe_stdin || format == FORMAT_ENGINE)) {
 716         BIO_printf(bio_err, "no keyfile specified\n");
 717         goto end;
 718     }
 719     if (format == FORMAT_ENGINE) {
 720         if (e == NULL) {
 721             BIO_printf(bio_err, "no engine specified\n");
 722         } else {
 723 #ifndef OPENSSL_NO_ENGINE
 724             if (ENGINE_init(e)) {
 725                 pkey = ENGINE_load_private_key(e, file, ui_method, &cb_data);
 726                 ENGINE_finish(e);
 727             }
 728             if (pkey == NULL) {
 729                 BIO_printf(bio_err, "cannot load %s from engine\n", key_descrip);
 730                 ERR_print_errors(bio_err);
 731             }
 732 #else
 733             BIO_printf(bio_err, "engines not supported\n");
 734 #endif
 735         }
 736         goto end;
 737     }
 738     if (file == NULL && maybe_stdin) {
 739         unbuffer(stdin);
 740         key = dup_bio_in(format);
 741     } else {
 742         key = bio_open_default(file, 'r', format);
 743     }
 744     if (key == NULL)
 745         goto end;
 746     if (format == FORMAT_ASN1) {
 747         pkey = d2i_PrivateKey_bio(key, NULL);
 748     } else if (format == FORMAT_PEM) {
 749         pkey = PEM_read_bio_PrivateKey(key, NULL,
 750                                        (pem_password_cb *)password_callback,
 751                                        &cb_data);
 752     } else if (format == FORMAT_PKCS12) {
 753         if (!load_pkcs12(key, key_descrip,
 754                          (pem_password_cb *)password_callback, &cb_data,
 755                          &pkey, NULL, NULL))
 756             goto end;
 757 #if !defined(OPENSSL_NO_RSA) && !defined(OPENSSL_NO_DSA) && !defined (OPENSSL_NO_RC4)
 758     } else if (format == FORMAT_MSBLOB) {
 759         pkey = b2i_PrivateKey_bio(key);
 760     } else if (format == FORMAT_PVK) {
 761         pkey = b2i_PVK_bio(key, (pem_password_cb *)password_callback,
 762                            &cb_data);
 763 #endif
 764     } else {
 765         BIO_printf(bio_err, "bad input format specified for key file\n");
 766         goto end;
 767     }
 768  end:
 769     BIO_free(key);
 770     if (pkey == NULL) {
 771         BIO_printf(bio_err, "unable to load %s\n", key_descrip);
 772         ERR_print_errors(bio_err);
 773     }
 774     return (pkey);
 775 }
 776
 777 EVP_PKEY *load_pubkey(const char *file, int format, int maybe_stdin,
 778                       const char *pass, ENGINE *e, const char *key_descrip)
 779 {
 780     BIO *key = NULL;
 781     EVP_PKEY *pkey = NULL;
 782     PW_CB_DATA cb_data;
 783
 784     cb_data.password = pass;
 785     cb_data.prompt_info = file;
 786
 787     if (file == NULL && (!maybe_stdin || format == FORMAT_ENGINE)) {
 788         BIO_printf(bio_err, "no keyfile specified\n");
 789         goto end;
 790     }
 791     if (format == FORMAT_ENGINE) {
 792         if (e == NULL) {
 793             BIO_printf(bio_err, "no engine specified\n");
 794         } else {
 795 #ifndef OPENSSL_NO_ENGINE
 796             pkey = ENGINE_load_public_key(e, file, ui_method, &cb_data);
 797             if (pkey == NULL) {
 798                 BIO_printf(bio_err, "cannot load %s from engine\n", key_descrip);
 799                 ERR_print_errors(bio_err);
 800             }
 801 #else
 802             BIO_printf(bio_err, "engines not supported\n");
 803 #endif
 804         }
 805         goto end;
 806     }
 807     if (file == NULL && maybe_stdin) {
 808         unbuffer(stdin);
 809         key = dup_bio_in(format);
 810     } else {
 811         key = bio_open_default(file, 'r', format);
 812     }
 813     if (key == NULL)
 814         goto end;
 815     if (format == FORMAT_ASN1) {
 816         pkey = d2i_PUBKEY_bio(key, NULL);
 817     } else if (format == FORMAT_ASN1RSA) {
 818 #ifndef OPENSSL_NO_RSA
 819         RSA *rsa;
 820         rsa = d2i_RSAPublicKey_bio(key, NULL);
 821         if (rsa) {
 822             pkey = EVP_PKEY_new();
 823             if (pkey != NULL)
 824                 EVP_PKEY_set1_RSA(pkey, rsa);
 825             RSA_free(rsa);
 826         } else
 827 #else
 828         BIO_printf(bio_err, "RSA keys not supported\n");
 829 #endif
 830             pkey = NULL;
 831     } else if (format == FORMAT_PEMRSA) {
 832 #ifndef OPENSSL_NO_RSA
 833         RSA *rsa;
 834         rsa = PEM_read_bio_RSAPublicKey(key, NULL,
 835                                         (pem_password_cb *)password_callback,
 836                                         &cb_data);
 837         if (rsa != NULL) {
 838             pkey = EVP_PKEY_new();
 839             if (pkey != NULL)
 840                 EVP_PKEY_set1_RSA(pkey, rsa);
 841             RSA_free(rsa);
 842         } else
 843 #else
 844         BIO_printf(bio_err, "RSA keys not supported\n");
 845 #endif
 846             pkey = NULL;
 847     } else if (format == FORMAT_PEM) {
 848         pkey = PEM_read_bio_PUBKEY(key, NULL,
 849                                    (pem_password_cb *)password_callback,
 850                                    &cb_data);
 851 #if !defined(OPENSSL_NO_RSA) && !defined(OPENSSL_NO_DSA)
 852     } else if (format == FORMAT_MSBLOB) {
 853         pkey = b2i_PublicKey_bio(key);
 854 #endif
 855     }
 856  end:
 857     BIO_free(key);
 858     if (pkey == NULL)
 859         BIO_printf(bio_err, "unable to load %s\n", key_descrip);
 860     return (pkey);
 861 }
 862
 863 static int load_certs_crls(const char *file, int format,
 864                            const char *pass, const char *desc,
 865                            STACK_OF(X509) **pcerts,
 866                            STACK_OF(X509_CRL) **pcrls)
 867 {
 868     int i;
 869     BIO *bio;
 870     STACK_OF(X509_INFO) *xis = NULL;
 871     X509_INFO *xi;
 872     PW_CB_DATA cb_data;
 873     int rv = 0;
 874
 875     cb_data.password = pass;
 876     cb_data.prompt_info = file;
 877
 878     if (format != FORMAT_PEM) {
 879         BIO_printf(bio_err, "bad input format specified for %s\n", desc);
 880         return 0;
 881     }
 882
 883     bio = bio_open_default(file, 'r', FORMAT_PEM);
 884     if (bio == NULL)
 885         return 0;
 886
 887     xis = PEM_X509_INFO_read_bio(bio, NULL,
 888                                  (pem_password_cb *)password_callback,
 889                                  &cb_data);
 890
 891     BIO_free(bio);
 892
 893     if (pcerts != NULL && *pcerts == NULL) {
 894         *pcerts = sk_X509_new_null();
 895         if (*pcerts == NULL)
 896             goto end;
 897     }
 898
 899     if (pcrls != NULL && *pcrls == NULL) {
 900         *pcrls = sk_X509_CRL_new_null();
 901         if (*pcrls == NULL)
 902             goto end;
 903     }
 904
 905     for (i = 0; i < sk_X509_INFO_num(xis); i++) {
 906         xi = sk_X509_INFO_value(xis, i);
 907         if (xi->x509 != NULL && pcerts != NULL) {
 908             if (!sk_X509_push(*pcerts, xi->x509))
 909                 goto end;
 910             xi->x509 = NULL;
 911         }
 912         if (xi->crl != NULL && pcrls != NULL) {
 913             if (!sk_X509_CRL_push(*pcrls, xi->crl))
 914                 goto end;
 915             xi->crl = NULL;
 916         }
 917     }
 918
 919     if (pcerts != NULL && sk_X509_num(*pcerts) > 0)
 920         rv = 1;
 921
 922     if (pcrls != NULL && sk_X509_CRL_num(*pcrls) > 0)
 923         rv = 1;
 924
 925  end:
 926
 927     sk_X509_INFO_pop_free(xis, X509_INFO_free);
 928
 929     if (rv == 0) {
 930         if (pcerts != NULL) {
 931             sk_X509_pop_free(*pcerts, X509_free);
 932             *pcerts = NULL;
 933         }
 934         if (pcrls != NULL) {
 935             sk_X509_CRL_pop_free(*pcrls, X509_CRL_free);
 936             *pcrls = NULL;
 937         }
 938         BIO_printf(bio_err, "unable to load %s\n",
 939                    pcerts ? "certificates" : "CRLs");
 940         ERR_print_errors(bio_err);
 941     }
 942     return rv;
 943 }
 944
 945 void* app_malloc(int sz, const char *what)
 946 {
 947     void *vp = OPENSSL_malloc(sz);
 948
 949     if (vp == NULL) {
 950         BIO_printf(bio_err, "%s: Could not allocate %d bytes for %s\n",
 951                 opt_getprog(), sz, what);
 952         ERR_print_errors(bio_err);
 953         exit(1);
 954     }
 955     return vp;
 956 }
 957
 958 /*
 959  * Initialize or extend, if *certs != NULL, a certificate stack.
 960  */
 961 int load_certs(const char *file, STACK_OF(X509) **certs, int format,
 962                const char *pass, const char *desc)
 963 {
 964     return load_certs_crls(file, format, pass, desc, certs, NULL);
 965 }
 966
 967 /*
 968  * Initialize or extend, if *crls != NULL, a certificate stack.
 969  */
 970 int load_crls(const char *file, STACK_OF(X509_CRL) **crls, int format,
 971               const char *pass, const char *desc)
 972 {
 973     return load_certs_crls(file, format, pass, desc, NULL, crls);
 974 }
 975
 976 #define X509V3_EXT_UNKNOWN_MASK         (0xfL << 16)
 977 /* Return error for unknown extensions */
 978 #define X509V3_EXT_DEFAULT              0
 979 /* Print error for unknown extensions */
 980 #define X509V3_EXT_ERROR_UNKNOWN        (1L << 16)
 981 /* ASN1 parse unknown extensions */
 982 #define X509V3_EXT_PARSE_UNKNOWN        (2L << 16)
 983 /* BIO_dump unknown extensions */
 984 #define X509V3_EXT_DUMP_UNKNOWN         (3L << 16)
 985
 986 #define X509_FLAG_CA (X509_FLAG_NO_ISSUER | X509_FLAG_NO_PUBKEY | \
 987                          X509_FLAG_NO_HEADER | X509_FLAG_NO_VERSION)
 988
 989 int set_cert_ex(unsigned long *flags, const char *arg)
 990 {
 991     static const NAME_EX_TBL cert_tbl[] = {
 992         {"compatible", X509_FLAG_COMPAT, 0xffffffffl},
 993         {"ca_default", X509_FLAG_CA, 0xffffffffl},
 994         {"no_header", X509_FLAG_NO_HEADER, 0},
 995         {"no_version", X509_FLAG_NO_VERSION, 0},
 996         {"no_serial", X509_FLAG_NO_SERIAL, 0},
 997         {"no_signame", X509_FLAG_NO_SIGNAME, 0},
 998         {"no_validity", X509_FLAG_NO_VALIDITY, 0},
 999         {"no_subject", X509_FLAG_NO_SUBJECT, 0},
1000         {"no_issuer", X509_FLAG_NO_ISSUER, 0},
1001         {"no_pubkey", X509_FLAG_NO_PUBKEY, 0},
1002         {"no_extensions", X509_FLAG_NO_EXTENSIONS, 0},
1003         {"no_sigdump", X509_FLAG_NO_SIGDUMP, 0},
1004         {"no_aux", X509_FLAG_NO_AUX, 0},
1005         {"no_attributes", X509_FLAG_NO_ATTRIBUTES, 0},
1006         {"ext_default", X509V3_EXT_DEFAULT, X509V3_EXT_UNKNOWN_MASK},
1007         {"ext_error", X509V3_EXT_ERROR_UNKNOWN, X509V3_EXT_UNKNOWN_MASK},
1008         {"ext_parse", X509V3_EXT_PARSE_UNKNOWN, X509V3_EXT_UNKNOWN_MASK},
1009         {"ext_dump", X509V3_EXT_DUMP_UNKNOWN, X509V3_EXT_UNKNOWN_MASK},
1010         {NULL, 0, 0}
1011     };
1012     return set_multi_opts(flags, arg, cert_tbl);
1013 }
1014
1015 int set_name_ex(unsigned long *flags, const char *arg)
1016 {
1017     static const NAME_EX_TBL ex_tbl[] = {
1018         {"esc_2253", ASN1_STRFLGS_ESC_2253, 0},
1019         {"esc_2254", ASN1_STRFLGS_ESC_2254, 0},
1020         {"esc_ctrl", ASN1_STRFLGS_ESC_CTRL, 0},
1021         {"esc_msb", ASN1_STRFLGS_ESC_MSB, 0},
1022         {"use_quote", ASN1_STRFLGS_ESC_QUOTE, 0},
1023         {"utf8", ASN1_STRFLGS_UTF8_CONVERT, 0},
1024         {"ignore_type", ASN1_STRFLGS_IGNORE_TYPE, 0},
1025         {"show_type", ASN1_STRFLGS_SHOW_TYPE, 0},
1026         {"dump_all", ASN1_STRFLGS_DUMP_ALL, 0},
1027         {"dump_nostr", ASN1_STRFLGS_DUMP_UNKNOWN, 0},
1028         {"dump_der", ASN1_STRFLGS_DUMP_DER, 0},
1029         {"compat", XN_FLAG_COMPAT, 0xffffffffL},
1030         {"sep_comma_plus", XN_FLAG_SEP_COMMA_PLUS, XN_FLAG_SEP_MASK},
1031         {"sep_comma_plus_space", XN_FLAG_SEP_CPLUS_SPC, XN_FLAG_SEP_MASK},
1032         {"sep_semi_plus_space", XN_FLAG_SEP_SPLUS_SPC, XN_FLAG_SEP_MASK},
1033         {"sep_multiline", XN_FLAG_SEP_MULTILINE, XN_FLAG_SEP_MASK},
1034         {"dn_rev", XN_FLAG_DN_REV, 0},
1035         {"nofname", XN_FLAG_FN_NONE, XN_FLAG_FN_MASK},
1036         {"sname", XN_FLAG_FN_SN, XN_FLAG_FN_MASK},
1037         {"lname", XN_FLAG_FN_LN, XN_FLAG_FN_MASK},
1038         {"align", XN_FLAG_FN_ALIGN, 0},
1039         {"oid", XN_FLAG_FN_OID, XN_FLAG_FN_MASK},
1040         {"space_eq", XN_FLAG_SPC_EQ, 0},
1041         {"dump_unknown", XN_FLAG_DUMP_UNKNOWN_FIELDS, 0},
1042         {"RFC2253", XN_FLAG_RFC2253, 0xffffffffL},
1043         {"oneline", XN_FLAG_ONELINE, 0xffffffffL},
1044         {"multiline", XN_FLAG_MULTILINE, 0xffffffffL},
1045         {"ca_default", XN_FLAG_MULTILINE, 0xffffffffL},
1046         {NULL, 0, 0}
1047     };
1048     if (set_multi_opts(flags, arg, ex_tbl) == 0)
1049         return 0;
1050     if ((*flags & XN_FLAG_SEP_MASK) == 0)
1051         *flags |= XN_FLAG_SEP_CPLUS_SPC;
1052     return 1;
1053 }
1054
1055 int set_ext_copy(int *copy_type, const char *arg)
1056 {
1057     if (strcasecmp(arg, "none") == 0)
1058         *copy_type = EXT_COPY_NONE;
1059     else if (strcasecmp(arg, "copy") == 0)
1060         *copy_type = EXT_COPY_ADD;
1061     else if (strcasecmp(arg, "copyall") == 0)
1062         *copy_type = EXT_COPY_ALL;
1063     else
1064         return 0;
1065     return 1;
1066 }
1067
1068 int copy_extensions(X509 *x, X509_REQ *req, int copy_type)
1069 {
1070     STACK_OF(X509_EXTENSION) *exts = NULL;
1071     X509_EXTENSION *ext, *tmpext;
1072     ASN1_OBJECT *obj;
1073     int i, idx, ret = 0;
1074     if (!x || !req || (copy_type == EXT_COPY_NONE))
1075         return 1;
1076     exts = X509_REQ_get_extensions(req);
1077
1078     for (i = 0; i < sk_X509_EXTENSION_num(exts); i++) {
1079         ext = sk_X509_EXTENSION_value(exts, i);
1080         obj = X509_EXTENSION_get_object(ext);
1081         idx = X509_get_ext_by_OBJ(x, obj, -1);
1082         /* Does extension exist? */
1083         if (idx != -1) {
1084             /* If normal copy don't override existing extension */
1085             if (copy_type == EXT_COPY_ADD)
1086                 continue;
1087             /* Delete all extensions of same type */
1088             do {
1089                 tmpext = X509_get_ext(x, idx);
1090                 X509_delete_ext(x, idx);
1091                 X509_EXTENSION_free(tmpext);
1092                 idx = X509_get_ext_by_OBJ(x, obj, -1);
1093             } while (idx != -1);
1094         }
1095         if (!X509_add_ext(x, ext, -1))
1096             goto end;
1097     }
1098
1099     ret = 1;
1100
1101  end:
1102
1103     sk_X509_EXTENSION_pop_free(exts, X509_EXTENSION_free);
1104
1105     return ret;
1106 }
1107
1108 static int set_multi_opts(unsigned long *flags, const char *arg,
1109                           const NAME_EX_TBL * in_tbl)
1110 {
1111     STACK_OF(CONF_VALUE) *vals;
1112     CONF_VALUE *val;
1113     int i, ret = 1;
1114     if (!arg)
1115         return 0;
1116     vals = X509V3_parse_list(arg);
1117     for (i = 0; i < sk_CONF_VALUE_num(vals); i++) {
1118         val = sk_CONF_VALUE_value(vals, i);
1119         if (!set_table_opts(flags, val->name, in_tbl))
1120             ret = 0;
1121     }
1122     sk_CONF_VALUE_pop_free(vals, X509V3_conf_free);
1123     return ret;
1124 }
1125
1126 static int set_table_opts(unsigned long *flags, const char *arg,
1127                           const NAME_EX_TBL * in_tbl)
1128 {
1129     char c;
1130     const NAME_EX_TBL *ptbl;
1131     c = arg[0];
1132
1133     if (c == '-') {
1134         c = 0;
1135         arg++;
1136     } else if (c == '+') {
1137         c = 1;
1138         arg++;
1139     } else {
1140         c = 1;
1141     }
1142
1143     for (ptbl = in_tbl; ptbl->name; ptbl++) {
1144         if (strcasecmp(arg, ptbl->name) == 0) {
1145             *flags &= ~ptbl->mask;
1146             if (c)
1147                 *flags |= ptbl->flag;
1148             else
1149                 *flags &= ~ptbl->flag;
1150             return 1;
1151         }
1152     }
1153     return 0;
1154 }
1155
1156 void print_name(BIO *out, const char *title, X509_NAME *nm,
1157                 unsigned long lflags)
1158 {
1159     char *buf;
1160     char mline = 0;
1161     int indent = 0;
1162
1163     if (title)
1164         BIO_puts(out, title);
1165     if ((lflags & XN_FLAG_SEP_MASK) == XN_FLAG_SEP_MULTILINE) {
1166         mline = 1;
1167         indent = 4;
1168     }
1169     if (lflags == XN_FLAG_COMPAT) {
1170         buf = X509_NAME_oneline(nm, 0, 0);
1171         BIO_puts(out, buf);
1172         BIO_puts(out, "\n");
1173         OPENSSL_free(buf);
1174     } else {
1175         if (mline)
1176             BIO_puts(out, "\n");
1177         X509_NAME_print_ex(out, nm, indent, lflags);
1178         BIO_puts(out, "\n");
1179     }
1180 }
1181
1182 void print_bignum_var(BIO *out, const BIGNUM *in, const char *var,
1183                       int len, unsigned char *buffer)
1184 {
1185     BIO_printf(out, "    static unsigned char %s_%d[] = {", var, len);
1186     if (BN_is_zero(in)) {
1187         BIO_printf(out, "\n\t0x00");
1188     } else {
1189         int i, l;
1190
1191         l = BN_bn2bin(in, buffer);
1192         for (i = 0; i < l; i++) {
1193             if ((i % 10) == 0)
1194                 BIO_printf(out, "\n\t");
1195             if (i < l - 1)
1196                 BIO_printf(out, "0x%02X, ", buffer[i]);
1197             else
1198                 BIO_printf(out, "0x%02X", buffer[i]);
1199         }
1200     }
1201     BIO_printf(out, "\n    };\n");
1202 }
1203
1204 void print_array(BIO *out, const char* title, int len, const unsigned char* d)
1205 {
1206     int i;
1207
1208     BIO_printf(out, "unsigned char %s[%d] = {", title, len);
1209     for (i = 0; i < len; i++) {
1210         if ((i % 10) == 0)
1211             BIO_printf(out, "\n    ");
1212         if (i < len - 1)
1213             BIO_printf(out, "0x%02X, ", d[i]);
1214         else
1215             BIO_printf(out, "0x%02X", d[i]);
1216     }
1217     BIO_printf(out, "\n};\n");
1218 }
1219
1220 X509_STORE *setup_verify(const char *CAfile, const char *CApath, int noCAfile, int noCApath)
1221 {
1222     X509_STORE *store = X509_STORE_new();
1223     X509_LOOKUP *lookup;
1224
1225     if (store == NULL)
1226         goto end;
1227
1228     if (CAfile != NULL || !noCAfile) {
1229         lookup = X509_STORE_add_lookup(store, X509_LOOKUP_file());
1230         if (lookup == NULL)
1231             goto end;
1232         if (CAfile) {
1233             if (!X509_LOOKUP_load_file(lookup, CAfile, X509_FILETYPE_PEM)) {
1234                 BIO_printf(bio_err, "Error loading file %s\n", CAfile);
1235                 goto end;
1236             }
1237         } else {
1238             X509_LOOKUP_load_file(lookup, NULL, X509_FILETYPE_DEFAULT);
1239         }
1240     }
1241
1242     if (CApath != NULL || !noCApath) {
1243         lookup = X509_STORE_add_lookup(store, X509_LOOKUP_hash_dir());
1244         if (lookup == NULL)
1245             goto end;
1246         if (CApath) {
1247             if (!X509_LOOKUP_add_dir(lookup, CApath, X509_FILETYPE_PEM)) {
1248                 BIO_printf(bio_err, "Error loading directory %s\n", CApath);
1249                 goto end;
1250             }
1251         } else {
1252             X509_LOOKUP_add_dir(lookup, NULL, X509_FILETYPE_DEFAULT);
1253         }
1254     }
1255
1256     ERR_clear_error();
1257     return store;
1258  end:
1259     X509_STORE_free(store);
1260     return NULL;
1261 }
1262
1263 #ifndef OPENSSL_NO_ENGINE
1264 /* Try to load an engine in a shareable library */
1265 static ENGINE *try_load_engine(const char *engine)
1266 {
1267     ENGINE *e = ENGINE_by_id("dynamic");
1268     if (e) {
1269         if (!ENGINE_ctrl_cmd_string(e, "SO_PATH", engine, 0)
1270             || !ENGINE_ctrl_cmd_string(e, "LOAD", NULL, 0)) {
1271             ENGINE_free(e);
1272             e = NULL;
1273         }
1274     }
1275     return e;
1276 }
1277 #endif
1278
1279 ENGINE *setup_engine(const char *engine, int debug)
1280 {
1281     ENGINE *e = NULL;
1282
1283 #ifndef OPENSSL_NO_ENGINE
1284     if (engine != NULL) {
1285         if (strcmp(engine, "auto") == 0) {
1286             BIO_printf(bio_err, "enabling auto ENGINE support\n");
1287             ENGINE_register_all_complete();
1288             return NULL;
1289         }
1290         if ((e = ENGINE_by_id(engine)) == NULL
1291             && (e = try_load_engine(engine)) == NULL) {
1292             BIO_printf(bio_err, "invalid engine \"%s\"\n", engine);
1293             ERR_print_errors(bio_err);
1294             return NULL;
1295         }
1296         if (debug) {
1297             ENGINE_ctrl(e, ENGINE_CTRL_SET_LOGSTREAM, 0, bio_err, 0);
1298         }
1299         ENGINE_ctrl_cmd(e, "SET_USER_INTERFACE", 0, ui_method, 0, 1);
1300         if (!ENGINE_set_default(e, ENGINE_METHOD_ALL)) {
1301             BIO_printf(bio_err, "can't use that engine\n");
1302             ERR_print_errors(bio_err);
1303             ENGINE_free(e);
1304             return NULL;
1305         }
1306
1307         BIO_printf(bio_err, "engine \"%s\" set.\n", ENGINE_get_id(e));
1308     }
1309 #endif
1310     return e;
1311 }
1312
1313 void release_engine(ENGINE *e)
1314 {
1315 #ifndef OPENSSL_NO_ENGINE
1316     if (e != NULL)
1317         /* Free our "structural" reference. */
1318         ENGINE_free(e);
1319 #endif
1320 }
1321
1322 static unsigned long index_serial_hash(const OPENSSL_CSTRING *a)
1323 {
1324     const char *n;
1325
1326     n = a[DB_serial];
1327     while (*n == '0')
1328         n++;
1329     return OPENSSL_LH_strhash(n);
1330 }
1331
1332 static int index_serial_cmp(const OPENSSL_CSTRING *a,
1333                             const OPENSSL_CSTRING *b)
1334 {
1335     const char *aa, *bb;
1336
1337     for (aa = a[DB_serial]; *aa == '0'; aa++) ;
1338     for (bb = b[DB_serial]; *bb == '0'; bb++) ;
1339     return (strcmp(aa, bb));
1340 }
1341
1342 static int index_name_qual(char **a)
1343 {
1344     return (a[0][0] == 'V');
1345 }
1346
1347 static unsigned long index_name_hash(const OPENSSL_CSTRING *a)
1348 {
1349     return OPENSSL_LH_strhash(a[DB_name]);
1350 }
1351
1352 int index_name_cmp(const OPENSSL_CSTRING *a, const OPENSSL_CSTRING *b)
1353 {
1354     return (strcmp(a[DB_name], b[DB_name]));
1355 }
1356
1357 static IMPLEMENT_LHASH_HASH_FN(index_serial, OPENSSL_CSTRING)
1358 static IMPLEMENT_LHASH_COMP_FN(index_serial, OPENSSL_CSTRING)
1359 static IMPLEMENT_LHASH_HASH_FN(index_name, OPENSSL_CSTRING)
1360 static IMPLEMENT_LHASH_COMP_FN(index_name, OPENSSL_CSTRING)
1361 #undef BSIZE
1362 #define BSIZE 256
1363 BIGNUM *load_serial(const char *serialfile, int create, ASN1_INTEGER **retai)
1364 {
1365     BIO *in = NULL;
1366     BIGNUM *ret = NULL;
1367     char buf[1024];
1368     ASN1_INTEGER *ai = NULL;
1369
1370     ai = ASN1_INTEGER_new();
1371     if (ai == NULL)
1372         goto err;
1373
1374     in = BIO_new_file(serialfile, "r");
1375     if (in == NULL) {
1376         if (!create) {
1377             perror(serialfile);
1378             goto err;
1379         }
1380         ERR_clear_error();
1381         ret = BN_new();
1382         if (ret == NULL || !rand_serial(ret, ai))
1383             BIO_printf(bio_err, "Out of memory\n");
1384     } else {
1385         if (!a2i_ASN1_INTEGER(in, ai, buf, 1024)) {
1386             BIO_printf(bio_err, "unable to load number from %s\n",
1387                        serialfile);
1388             goto err;
1389         }
1390         ret = ASN1_INTEGER_to_BN(ai, NULL);
1391         if (ret == NULL) {
1392             BIO_printf(bio_err,
1393                        "error converting number from bin to BIGNUM\n");
1394             goto err;
1395         }
1396     }
1397
1398     if (ret && retai) {
1399         *retai = ai;
1400         ai = NULL;
1401     }
1402  err:
1403     BIO_free(in);
1404     ASN1_INTEGER_free(ai);
1405     return (ret);
1406 }
1407
1408 int save_serial(const char *serialfile, const char *suffix, const BIGNUM *serial,
1409                 ASN1_INTEGER **retai)
1410 {
1411     char buf[1][BSIZE];
1412     BIO *out = NULL;
1413     int ret = 0;
1414     ASN1_INTEGER *ai = NULL;
1415     int j;
1416
1417     if (suffix == NULL)
1418         j = strlen(serialfile);
1419     else
1420         j = strlen(serialfile) + strlen(suffix) + 1;
1421     if (j >= BSIZE) {
1422         BIO_printf(bio_err, "file name too long\n");
1423         goto err;
1424     }
1425
1426     if (suffix == NULL)
1427         OPENSSL_strlcpy(buf[0], serialfile, BSIZE);
1428     else {
1429 #ifndef OPENSSL_SYS_VMS
1430         j = BIO_snprintf(buf[0], sizeof buf[0], "%s.%s", serialfile, suffix);
1431 #else
1432         j = BIO_snprintf(buf[0], sizeof buf[0], "%s-%s", serialfile, suffix);
1433 #endif
1434     }
1435     out = BIO_new_file(buf[0], "w");
1436     if (out == NULL) {
1437         ERR_print_errors(bio_err);
1438         goto err;
1439     }
1440
1441     if ((ai = BN_to_ASN1_INTEGER(serial, NULL)) == NULL) {
1442         BIO_printf(bio_err, "error converting serial to ASN.1 format\n");
1443         goto err;
1444     }
1445     i2a_ASN1_INTEGER(out, ai);
1446     BIO_puts(out, "\n");
1447     ret = 1;
1448     if (retai) {
1449         *retai = ai;
1450         ai = NULL;
1451     }
1452  err:
1453     BIO_free_all(out);
1454     ASN1_INTEGER_free(ai);
1455     return (ret);
1456 }
1457
1458 int rotate_serial(const char *serialfile, const char *new_suffix,
1459                   const char *old_suffix)
1460 {
1461     char buf[2][BSIZE];
1462     int i, j;
1463
1464     i = strlen(serialfile) + strlen(old_suffix);
1465     j = strlen(serialfile) + strlen(new_suffix);
1466     if (i > j)
1467         j = i;
1468     if (j + 1 >= BSIZE) {
1469         BIO_printf(bio_err, "file name too long\n");
1470         goto err;
1471     }
1472 #ifndef OPENSSL_SYS_VMS
1473     j = BIO_snprintf(buf[0], sizeof buf[0], "%s.%s", serialfile, new_suffix);
1474     j = BIO_snprintf(buf[1], sizeof buf[1], "%s.%s", serialfile, old_suffix);
1475 #else
1476     j = BIO_snprintf(buf[0], sizeof buf[0], "%s-%s", serialfile, new_suffix);
1477     j = BIO_snprintf(buf[1], sizeof buf[1], "%s-%s", serialfile, old_suffix);
1478 #endif
1479     if (rename(serialfile, buf[1]) < 0 && errno != ENOENT
1480 #ifdef ENOTDIR
1481         && errno != ENOTDIR
1482 #endif
1483         ) {
1484         BIO_printf(bio_err,
1485                    "unable to rename %s to %s\n", serialfile, buf[1]);
1486         perror("reason");
1487         goto err;
1488     }
1489     if (rename(buf[0], serialfile) < 0) {
1490         BIO_printf(bio_err,
1491                    "unable to rename %s to %s\n", buf[0], serialfile);
1492         perror("reason");
1493         rename(buf[1], serialfile);
1494         goto err;
1495     }
1496     return 1;
1497  err:
1498     return 0;
1499 }
1500
1501 int rand_serial(BIGNUM *b, ASN1_INTEGER *ai)
1502 {
1503     BIGNUM *btmp;
1504     int ret = 0;
1505
1506     btmp = b == NULL ? BN_new() : b;
1507     if (btmp == NULL)
1508         return 0;
1509
1510     if (!BN_rand(btmp, SERIAL_RAND_BITS, BN_RAND_TOP_ANY, BN_RAND_BOTTOM_ANY))
1511         goto error;
1512     if (ai && !BN_to_ASN1_INTEGER(btmp, ai))
1513         goto error;
1514
1515     ret = 1;
1516
1517  error:
1518
1519     if (btmp != b)
1520         BN_free(btmp);
1521
1522     return ret;
1523 }
1524
1525 CA_DB *load_index(const char *dbfile, DB_ATTR *db_attr)
1526 {
1527     CA_DB *retdb = NULL;
1528     TXT_DB *tmpdb = NULL;
1529     BIO *in;
1530     CONF *dbattr_conf = NULL;
1531     char buf[BSIZE];
1532
1533     in = BIO_new_file(dbfile, "r");
1534     if (in == NULL) {
1535         ERR_print_errors(bio_err);
1536         goto err;
1537     }
1538     if ((tmpdb = TXT_DB_read(in, DB_NUMBER)) == NULL)
1539         goto err;
1540
1541 #ifndef OPENSSL_SYS_VMS
1542     BIO_snprintf(buf, sizeof buf, "%s.attr", dbfile);
1543 #else
1544     BIO_snprintf(buf, sizeof buf, "%s-attr", dbfile);
1545 #endif
1546     dbattr_conf = app_load_config(buf);
1547
1548     retdb = app_malloc(sizeof(*retdb), "new DB");
1549     retdb->db = tmpdb;
1550     tmpdb = NULL;
1551     if (db_attr)
1552         retdb->attributes = *db_attr;
1553     else {
1554         retdb->attributes.unique_subject = 1;
1555     }
1556
1557     if (dbattr_conf) {
1558         char *p = NCONF_get_string(dbattr_conf, NULL, "unique_subject");
1559         if (p) {
1560             retdb->attributes.unique_subject = parse_yesno(p, 1);
1561         }
1562     }
1563
1564  err:
1565     NCONF_free(dbattr_conf);
1566     TXT_DB_free(tmpdb);
1567     BIO_free_all(in);
1568     return retdb;
1569 }
1570
1571 int index_index(CA_DB *db)
1572 {
1573     if (!TXT_DB_create_index(db->db, DB_serial, NULL,
1574                              LHASH_HASH_FN(index_serial),
1575                              LHASH_COMP_FN(index_serial))) {
1576         BIO_printf(bio_err,
1577                    "error creating serial number index:(%ld,%ld,%ld)\n",
1578                    db->db->error, db->db->arg1, db->db->arg2);
1579         return 0;
1580     }
1581
1582     if (db->attributes.unique_subject
1583         && !TXT_DB_create_index(db->db, DB_name, index_name_qual,
1584                                 LHASH_HASH_FN(index_name),
1585                                 LHASH_COMP_FN(index_name))) {
1586         BIO_printf(bio_err, "error creating name index:(%ld,%ld,%ld)\n",
1587                    db->db->error, db->db->arg1, db->db->arg2);
1588         return 0;
1589     }
1590     return 1;
1591 }
1592
1593 int save_index(const char *dbfile, const char *suffix, CA_DB *db)
1594 {
1595     char buf[3][BSIZE];
1596     BIO *out;
1597     int j;
1598
1599     j = strlen(dbfile) + strlen(suffix);
1600     if (j + 6 >= BSIZE) {
1601         BIO_printf(bio_err, "file name too long\n");
1602         goto err;
1603     }
1604 #ifndef OPENSSL_SYS_VMS
1605     j = BIO_snprintf(buf[2], sizeof buf[2], "%s.attr", dbfile);
1606     j = BIO_snprintf(buf[1], sizeof buf[1], "%s.attr.%s", dbfile, suffix);
1607     j = BIO_snprintf(buf[0], sizeof buf[0], "%s.%s", dbfile, suffix);
1608 #else
1609     j = BIO_snprintf(buf[2], sizeof buf[2], "%s-attr", dbfile);
1610     j = BIO_snprintf(buf[1], sizeof buf[1], "%s-attr-%s", dbfile, suffix);
1611     j = BIO_snprintf(buf[0], sizeof buf[0], "%s-%s", dbfile, suffix);
1612 #endif
1613     out = BIO_new_file(buf[0], "w");
1614     if (out == NULL) {
1615         perror(dbfile);
1616         BIO_printf(bio_err, "unable to open '%s'\n", dbfile);
1617         goto err;
1618     }
1619     j = TXT_DB_write(out, db->db);
1620     BIO_free(out);
1621     if (j <= 0)
1622         goto err;
1623
1624     out = BIO_new_file(buf[1], "w");
1625     if (out == NULL) {
1626         perror(buf[2]);
1627         BIO_printf(bio_err, "unable to open '%s'\n", buf[2]);
1628         goto err;
1629     }
1630     BIO_printf(out, "unique_subject = %s\n",
1631                db->attributes.unique_subject ? "yes" : "no");
1632     BIO_free(out);
1633
1634     return 1;
1635  err:
1636     return 0;
1637 }
1638
1639 int rotate_index(const char *dbfile, const char *new_suffix,
1640                  const char *old_suffix)
1641 {
1642     char buf[5][BSIZE];
1643     int i, j;
1644
1645     i = strlen(dbfile) + strlen(old_suffix);
1646     j = strlen(dbfile) + strlen(new_suffix);
1647     if (i > j)
1648         j = i;
1649     if (j + 6 >= BSIZE) {
1650         BIO_printf(bio_err, "file name too long\n");
1651         goto err;
1652     }
1653 #ifndef OPENSSL_SYS_VMS
1654     j = BIO_snprintf(buf[4], sizeof buf[4], "%s.attr", dbfile);
1655     j = BIO_snprintf(buf[3], sizeof buf[3], "%s.attr.%s", dbfile, old_suffix);
1656     j = BIO_snprintf(buf[2], sizeof buf[2], "%s.attr.%s", dbfile, new_suffix);
1657     j = BIO_snprintf(buf[1], sizeof buf[1], "%s.%s", dbfile, old_suffix);
1658     j = BIO_snprintf(buf[0], sizeof buf[0], "%s.%s", dbfile, new_suffix);
1659 #else
1660     j = BIO_snprintf(buf[4], sizeof buf[4], "%s-attr", dbfile);
1661     j = BIO_snprintf(buf[3], sizeof buf[3], "%s-attr-%s", dbfile, old_suffix);
1662     j = BIO_snprintf(buf[2], sizeof buf[2], "%s-attr-%s", dbfile, new_suffix);
1663     j = BIO_snprintf(buf[1], sizeof buf[1], "%s-%s", dbfile, old_suffix);
1664     j = BIO_snprintf(buf[0], sizeof buf[0], "%s-%s", dbfile, new_suffix);
1665 #endif
1666     if (rename(dbfile, buf[1]) < 0 && errno != ENOENT
1667 #ifdef ENOTDIR
1668         && errno != ENOTDIR
1669 #endif
1670         ) {
1671         BIO_printf(bio_err, "unable to rename %s to %s\n", dbfile, buf[1]);
1672         perror("reason");
1673         goto err;
1674     }
1675     if (rename(buf[0], dbfile) < 0) {
1676         BIO_printf(bio_err, "unable to rename %s to %s\n", buf[0], dbfile);
1677         perror("reason");
1678         rename(buf[1], dbfile);
1679         goto err;
1680     }
1681     if (rename(buf[4], buf[3]) < 0 && errno != ENOENT
1682 #ifdef ENOTDIR
1683         && errno != ENOTDIR
1684 #endif
1685         ) {
1686         BIO_printf(bio_err, "unable to rename %s to %s\n", buf[4], buf[3]);
1687         perror("reason");
1688         rename(dbfile, buf[0]);
1689         rename(buf[1], dbfile);
1690         goto err;
1691     }
1692     if (rename(buf[2], buf[4]) < 0) {
1693         BIO_printf(bio_err, "unable to rename %s to %s\n", buf[2], buf[4]);
1694         perror("reason");
1695         rename(buf[3], buf[4]);
1696         rename(dbfile, buf[0]);
1697         rename(buf[1], dbfile);
1698         goto err;
1699     }
1700     return 1;
1701  err:
1702     return 0;
1703 }
1704
1705 void free_index(CA_DB *db)
1706 {
1707     if (db) {
1708         TXT_DB_free(db->db);
1709         OPENSSL_free(db);
1710     }
1711 }
1712
1713 int parse_yesno(const char *str, int def)
1714 {
1715     if (str) {
1716         switch (*str) {
1717         case 'f':              /* false */
1718         case 'F':              /* FALSE */
1719         case 'n':              /* no */
1720         case 'N':              /* NO */
1721         case '0':              /* 0 */
1722             return 0;
1723         case 't':              /* true */
1724         case 'T':              /* TRUE */
1725         case 'y':              /* yes */
1726         case 'Y':              /* YES */
1727         case '1':              /* 1 */
1728             return 1;
1729         }
1730     }
1731     return def;
1732 }
1733
1734 /*
1735  * name is expected to be in the format /type0=value0/type1=value1/type2=...
1736  * where characters may be escaped by \
1737  */
1738 X509_NAME *parse_name(const char *cp, long chtype, int canmulti)
1739 {
1740     int nextismulti = 0;
1741     char *work;
1742     X509_NAME *n;
1743
1744     if (*cp++ != '/')
1745         return NULL;
1746
1747     n = X509_NAME_new();
1748     if (n == NULL)
1749         return NULL;
1750     work = OPENSSL_strdup(cp);
1751     if (work == NULL)
1752         goto err;
1753
1754     while (*cp) {
1755         char *bp = work;
1756         char *typestr = bp;
1757         unsigned char *valstr;
1758         int nid;
1759         int ismulti = nextismulti;
1760         nextismulti = 0;
1761
1762         /* Collect the type */
1763         while (*cp && *cp != '=')
1764             *bp++ = *cp++;
1765         if (*cp == '\0') {
1766             BIO_printf(bio_err,
1767                     "%s: Hit end of string before finding the equals.\n",
1768                     opt_getprog());
1769             goto err;
1770         }
1771         *bp++ = '\0';
1772         ++cp;
1773
1774         /* Collect the value. */
1775         valstr = (unsigned char *)bp;
1776         for (; *cp && *cp != '/'; *bp++ = *cp++) {
1777             if (canmulti && *cp == '+') {
1778                 nextismulti = 1;
1779                 break;
1780             }
1781             if (*cp == '\\' && *++cp == '\0') {
1782                 BIO_printf(bio_err,
1783                         "%s: escape character at end of string\n",
1784                         opt_getprog());
1785                 goto err;
1786             }
1787         }
1788         *bp++ = '\0';
1789
1790         /* If not at EOS (must be + or /), move forward. */
1791         if (*cp)
1792             ++cp;
1793
1794         /* Parse */
1795         nid = OBJ_txt2nid(typestr);
1796         if (nid == NID_undef) {
1797             BIO_printf(bio_err, "%s: Skipping unknown attribute \"%s\"\n",
1798                       opt_getprog(), typestr);
1799             continue;
1800         }
1801         if (!X509_NAME_add_entry_by_NID(n, nid, chtype,
1802                                         valstr, strlen((char *)valstr),
1803                                         -1, ismulti ? -1 : 0))
1804             goto err;
1805     }
1806
1807     OPENSSL_free(work);
1808     return n;
1809
1810  err:
1811     X509_NAME_free(n);
1812     OPENSSL_free(work);
1813     return NULL;
1814 }
1815
1816 /*
1817  * Read whole contents of a BIO into an allocated memory buffer and return
1818  * it.
1819  */
1820
1821 int bio_to_mem(unsigned char **out, int maxlen, BIO *in)
1822 {
1823     BIO *mem;
1824     int len, ret;
1825     unsigned char tbuf[1024];
1826
1827     mem = BIO_new(BIO_s_mem());
1828     if (mem == NULL)
1829         return -1;
1830     for (;;) {
1831         if ((maxlen != -1) && maxlen < 1024)
1832             len = maxlen;
1833         else
1834             len = 1024;
1835         len = BIO_read(in, tbuf, len);
1836         if (len < 0) {
1837             BIO_free(mem);
1838             return -1;
1839         }
1840         if (len == 0)
1841             break;
1842         if (BIO_write(mem, tbuf, len) != len) {
1843             BIO_free(mem);
1844             return -1;
1845         }
1846         maxlen -= len;
1847
1848         if (maxlen == 0)
1849             break;
1850     }
1851     ret = BIO_get_mem_data(mem, (char **)out);
1852     BIO_set_flags(mem, BIO_FLAGS_MEM_RDONLY);
1853     BIO_free(mem);
1854     return ret;
1855 }
1856
1857 int pkey_ctrl_string(EVP_PKEY_CTX *ctx, const char *value)
1858 {
1859     int rv;
1860     char *stmp, *vtmp = NULL;
1861     stmp = OPENSSL_strdup(value);
1862     if (!stmp)
1863         return -1;
1864     vtmp = strchr(stmp, ':');
1865     if (vtmp) {
1866         *vtmp = 0;
1867         vtmp++;
1868     }
1869     rv = EVP_PKEY_CTX_ctrl_str(ctx, stmp, vtmp);
1870     OPENSSL_free(stmp);
1871     return rv;
1872 }
1873
1874 static void nodes_print(const char *name, STACK_OF(X509_POLICY_NODE) *nodes)
1875 {
1876     X509_POLICY_NODE *node;
1877     int i;
1878
1879     BIO_printf(bio_err, "%s Policies:", name);
1880     if (nodes) {
1881         BIO_puts(bio_err, "\n");
1882         for (i = 0; i < sk_X509_POLICY_NODE_num(nodes); i++) {
1883             node = sk_X509_POLICY_NODE_value(nodes, i);
1884             X509_POLICY_NODE_print(bio_err, node, 2);
1885         }
1886     } else {
1887         BIO_puts(bio_err, " <empty>\n");
1888     }
1889 }
1890
1891 void policies_print(X509_STORE_CTX *ctx)
1892 {
1893     X509_POLICY_TREE *tree;
1894     int explicit_policy;
1895     tree = X509_STORE_CTX_get0_policy_tree(ctx);
1896     explicit_policy = X509_STORE_CTX_get_explicit_policy(ctx);
1897
1898     BIO_printf(bio_err, "Require explicit Policy: %s\n",
1899                explicit_policy ? "True" : "False");
1900
1901     nodes_print("Authority", X509_policy_tree_get0_policies(tree));
1902     nodes_print("User", X509_policy_tree_get0_user_policies(tree));
1903 }
1904
1905 /*-
1906  * next_protos_parse parses a comma separated list of strings into a string
1907  * in a format suitable for passing to SSL_CTX_set_next_protos_advertised.
1908  *   outlen: (output) set to the length of the resulting buffer on success.
1909  *   err: (maybe NULL) on failure, an error message line is written to this BIO.
1910  *   in: a NUL terminated string like "abc,def,ghi"
1911  *
1912  *   returns: a malloc'd buffer or NULL on failure.
1913  */
1914 unsigned char *next_protos_parse(size_t *outlen, const char *in)
1915 {
1916     size_t len;
1917     unsigned char *out;
1918     size_t i, start = 0;
1919
1920     len = strlen(in);
1921     if (len >= 65535)
1922         return NULL;
1923
1924     out = app_malloc(strlen(in) + 1, "NPN buffer");
1925     for (i = 0; i <= len; ++i) {
1926         if (i == len || in[i] == ',') {
1927             if (i - start > 255) {
1928                 OPENSSL_free(out);
1929                 return NULL;
1930             }
1931             out[start] = i - start;
1932             start = i + 1;
1933         } else {
1934             out[i + 1] = in[i];
1935         }
1936     }
1937
1938     *outlen = len + 1;
1939     return out;
1940 }
1941
1942 void print_cert_checks(BIO *bio, X509 *x,
1943                        const char *checkhost,
1944                        const char *checkemail, const char *checkip)
1945 {
1946     if (x == NULL)
1947         return;
1948     if (checkhost) {
1949         BIO_printf(bio, "Hostname %s does%s match certificate\n",
1950                    checkhost,
1951                    X509_check_host(x, checkhost, 0, 0, NULL) == 1
1952                        ? "" : " NOT");
1953     }
1954
1955     if (checkemail) {
1956         BIO_printf(bio, "Email %s does%s match certificate\n",
1957                    checkemail, X509_check_email(x, checkemail, 0, 0)
1958                    ? "" : " NOT");
1959     }
1960
1961     if (checkip) {
1962         BIO_printf(bio, "IP %s does%s match certificate\n",
1963                    checkip, X509_check_ip_asc(x, checkip, 0) ? "" : " NOT");
1964     }
1965 }
1966
1967 /* Get first http URL from a DIST_POINT structure */
1968
1969 static const char *get_dp_url(DIST_POINT *dp)
1970 {
1971     GENERAL_NAMES *gens;
1972     GENERAL_NAME *gen;
1973     int i, gtype;
1974     ASN1_STRING *uri;
1975     if (!dp->distpoint || dp->distpoint->type != 0)
1976         return NULL;
1977     gens = dp->distpoint->name.fullname;
1978     for (i = 0; i < sk_GENERAL_NAME_num(gens); i++) {
1979         gen = sk_GENERAL_NAME_value(gens, i);
1980         uri = GENERAL_NAME_get0_value(gen, &gtype);
1981         if (gtype == GEN_URI && ASN1_STRING_length(uri) > 6) {
1982             const char *uptr = (const char *)ASN1_STRING_get0_data(uri);
1983             if (strncmp(uptr, "http://", 7) == 0)
1984                 return uptr;
1985         }
1986     }
1987     return NULL;
1988 }
1989
1990 /*
1991  * Look through a CRLDP structure and attempt to find an http URL to
1992  * downloads a CRL from.
1993  */
1994
1995 static X509_CRL *load_crl_crldp(STACK_OF(DIST_POINT) *crldp)
1996 {
1997     int i;
1998     const char *urlptr = NULL;
1999     for (i = 0; i < sk_DIST_POINT_num(crldp); i++) {
2000         DIST_POINT *dp = sk_DIST_POINT_value(crldp, i);
2001         urlptr = get_dp_url(dp);
2002         if (urlptr)
2003             return load_crl(urlptr, FORMAT_HTTP);
2004     }
2005     return NULL;
2006 }
2007
2008 /*
2009  * Example of downloading CRLs from CRLDP: not usable for real world as it
2010  * always downloads, doesn't support non-blocking I/O and doesn't cache
2011  * anything.
2012  */
2013
2014 static STACK_OF(X509_CRL) *crls_http_cb(X509_STORE_CTX *ctx, X509_NAME *nm)
2015 {
2016     X509 *x;
2017     STACK_OF(X509_CRL) *crls = NULL;
2018     X509_CRL *crl;
2019     STACK_OF(DIST_POINT) *crldp;
2020
2021     crls = sk_X509_CRL_new_null();
2022     if (!crls)
2023         return NULL;
2024     x = X509_STORE_CTX_get_current_cert(ctx);
2025     crldp = X509_get_ext_d2i(x, NID_crl_distribution_points, NULL, NULL);
2026     crl = load_crl_crldp(crldp);
2027     sk_DIST_POINT_pop_free(crldp, DIST_POINT_free);
2028     if (!crl) {
2029         sk_X509_CRL_free(crls);
2030         return NULL;
2031     }
2032     sk_X509_CRL_push(crls, crl);
2033     /* Try to download delta CRL */
2034     crldp = X509_get_ext_d2i(x, NID_freshest_crl, NULL, NULL);
2035     crl = load_crl_crldp(crldp);
2036     sk_DIST_POINT_pop_free(crldp, DIST_POINT_free);
2037     if (crl)
2038         sk_X509_CRL_push(crls, crl);
2039     return crls;
2040 }
2041
2042 void store_setup_crl_download(X509_STORE *st)
2043 {
2044     X509_STORE_set_lookup_crls_cb(st, crls_http_cb);
2045 }
2046
2047 /*
2048  * Platform-specific sections
2049  */
2050 #if defined(_WIN32)
2051 # ifdef fileno
2052 #  undef fileno
2053 #  define fileno(a) (int)_fileno(a)
2054 # endif
2055
2056 # include <windows.h>
2057 # include <tchar.h>
2058
2059 static int WIN32_rename(const char *from, const char *to)
2060 {
2061     TCHAR *tfrom = NULL, *tto;
2062     DWORD err;
2063     int ret = 0;
2064
2065     if (sizeof(TCHAR) == 1) {
2066         tfrom = (TCHAR *)from;
2067         tto = (TCHAR *)to;
2068     } else {                    /* UNICODE path */
2069
2070         size_t i, flen = strlen(from) + 1, tlen = strlen(to) + 1;
2071         tfrom = malloc(sizeof(*tfrom) * (flen + tlen));
2072         if (tfrom == NULL)
2073             goto err;
2074         tto = tfrom + flen;
2075 # if !defined(_WIN32_WCE) || _WIN32_WCE>=101
2076         if (!MultiByteToWideChar(CP_ACP, 0, from, flen, (WCHAR *)tfrom, flen))
2077 # endif
2078             for (i = 0; i < flen; i++)
2079                 tfrom[i] = (TCHAR)from[i];
2080 # if !defined(_WIN32_WCE) || _WIN32_WCE>=101
2081         if (!MultiByteToWideChar(CP_ACP, 0, to, tlen, (WCHAR *)tto, tlen))
2082 # endif
2083             for (i = 0; i < tlen; i++)
2084                 tto[i] = (TCHAR)to[i];
2085     }
2086
2087     if (MoveFile(tfrom, tto))
2088         goto ok;
2089     err = GetLastError();
2090     if (err == ERROR_ALREADY_EXISTS || err == ERROR_FILE_EXISTS) {
2091         if (DeleteFile(tto) && MoveFile(tfrom, tto))
2092             goto ok;
2093         err = GetLastError();
2094     }
2095     if (err == ERROR_FILE_NOT_FOUND || err == ERROR_PATH_NOT_FOUND)
2096         errno = ENOENT;
2097     else if (err == ERROR_ACCESS_DENIED)
2098         errno = EACCES;
2099     else
2100         errno = EINVAL;         /* we could map more codes... */
2101  err:
2102     ret = -1;
2103  ok:
2104     if (tfrom != NULL && tfrom != (TCHAR *)from)
2105         free(tfrom);
2106     return ret;
2107 }
2108 #endif
2109
2110 /* app_tminterval section */
2111 #if defined(_WIN32)
2112 double app_tminterval(int stop, int usertime)
2113 {
2114     FILETIME now;
2115     double ret = 0;
2116     static ULARGE_INTEGER tmstart;
2117     static int warning = 1;
2118 # ifdef _WIN32_WINNT
2119     static HANDLE proc = NULL;
2120
2121     if (proc == NULL) {
2122         if (check_winnt())
2123             proc = OpenProcess(PROCESS_QUERY_INFORMATION, FALSE,
2124                                GetCurrentProcessId());
2125         if (proc == NULL)
2126             proc = (HANDLE) - 1;
2127     }
2128
2129     if (usertime && proc != (HANDLE) - 1) {
2130         FILETIME junk;
2131         GetProcessTimes(proc, &junk, &junk, &junk, &now);
2132     } else
2133 # endif
2134     {
2135         SYSTEMTIME systime;
2136
2137         if (usertime && warning) {
2138             BIO_printf(bio_err, "To get meaningful results, run "
2139                        "this program on idle system.\n");
2140             warning = 0;
2141         }
2142         GetSystemTime(&systime);
2143         SystemTimeToFileTime(&systime, &now);
2144     }
2145
2146     if (stop == TM_START) {
2147         tmstart.u.LowPart = now.dwLowDateTime;
2148         tmstart.u.HighPart = now.dwHighDateTime;
2149     } else {
2150         ULARGE_INTEGER tmstop;
2151
2152         tmstop.u.LowPart = now.dwLowDateTime;
2153         tmstop.u.HighPart = now.dwHighDateTime;
2154
2155         ret = (__int64)(tmstop.QuadPart - tmstart.QuadPart) * 1e-7;
2156     }
2157
2158     return (ret);
2159 }
2160 #elif defined(OPENSSL_SYSTEM_VXWORKS)
2161 # include <time.h>
2162
2163 double app_tminterval(int stop, int usertime)
2164 {
2165     double ret = 0;
2166 # ifdef CLOCK_REALTIME
2167     static struct timespec tmstart;
2168     struct timespec now;
2169 # else
2170     static unsigned long tmstart;
2171     unsigned long now;
2172 # endif
2173     static int warning = 1;
2174
2175     if (usertime && warning) {
2176         BIO_printf(bio_err, "To get meaningful results, run "
2177                    "this program on idle system.\n");
2178         warning = 0;
2179     }
2180 # ifdef CLOCK_REALTIME
2181     clock_gettime(CLOCK_REALTIME, &now);
2182     if (stop == TM_START)
2183         tmstart = now;
2184     else
2185         ret = ((now.tv_sec + now.tv_nsec * 1e-9)
2186                - (tmstart.tv_sec + tmstart.tv_nsec * 1e-9));
2187 # else
2188     now = tickGet();
2189     if (stop == TM_START)
2190         tmstart = now;
2191     else
2192         ret = (now - tmstart) / (double)sysClkRateGet();
2193 # endif
2194     return (ret);
2195 }
2196
2197 #elif defined(OPENSSL_SYSTEM_VMS)
2198 # include <time.h>
2199 # include <times.h>
2200
2201 double app_tminterval(int stop, int usertime)
2202 {
2203     static clock_t tmstart;
2204     double ret = 0;
2205     clock_t now;
2206 # ifdef __TMS
2207     struct tms rus;
2208
2209     now = times(&rus);
2210     if (usertime)
2211         now = rus.tms_utime;
2212 # else
2213     if (usertime)
2214         now = clock();          /* sum of user and kernel times */
2215     else {
2216         struct timeval tv;
2217         gettimeofday(&tv, NULL);
2218         now = (clock_t)((unsigned long long)tv.tv_sec * CLK_TCK +
2219                         (unsigned long long)tv.tv_usec * (1000000 / CLK_TCK)
2220             );
2221     }
2222 # endif
2223     if (stop == TM_START)
2224         tmstart = now;
2225     else
2226         ret = (now - tmstart) / (double)(CLK_TCK);
2227
2228     return (ret);
2229 }
2230
2231 #elif defined(_SC_CLK_TCK)      /* by means of unistd.h */
2232 # include <sys/times.h>
2233
2234 double app_tminterval(int stop, int usertime)
2235 {
2236     double ret = 0;
2237     struct tms rus;
2238     clock_t now = times(&rus);
2239     static clock_t tmstart;
2240
2241     if (usertime)
2242         now = rus.tms_utime;
2243
2244     if (stop == TM_START) {
2245         tmstart = now;
2246     } else {
2247         long int tck = sysconf(_SC_CLK_TCK);
2248         ret = (now - tmstart) / (double)tck;
2249     }
2250
2251     return (ret);
2252 }
2253
2254 #else
2255 # include <sys/time.h>
2256 # include <sys/resource.h>
2257
2258 double app_tminterval(int stop, int usertime)
2259 {
2260     double ret = 0;
2261     struct rusage rus;
2262     struct timeval now;
2263     static struct timeval tmstart;
2264
2265     if (usertime)
2266         getrusage(RUSAGE_SELF, &rus), now = rus.ru_utime;
2267     else
2268         gettimeofday(&now, NULL);
2269
2270     if (stop == TM_START)
2271         tmstart = now;
2272     else
2273         ret = ((now.tv_sec + now.tv_usec * 1e-6)
2274                - (tmstart.tv_sec + tmstart.tv_usec * 1e-6));
2275
2276     return ret;
2277 }
2278 #endif
2279
2280 int app_access(const char* name, int flag)
2281 {
2282 #ifdef _WIN32
2283     return _access(name, flag);
2284 #else
2285     return access(name, flag);
2286 #endif
2287 }
2288
2289 /* app_isdir section */
2290 #ifdef _WIN32
2291 int app_isdir(const char *name)
2292 {
2293     DWORD attr;
2294 # if defined(UNICODE) || defined(_UNICODE)
2295     size_t i, len_0 = strlen(name) + 1;
2296     WCHAR tempname[MAX_PATH];
2297
2298     if (len_0 > MAX_PATH)
2299         return -1;
2300
2301 #  if !defined(_WIN32_WCE) || _WIN32_WCE>=101
2302     if (!MultiByteToWideChar(CP_ACP, 0, name, len_0, tempname, MAX_PATH))
2303 #  endif
2304         for (i = 0; i < len_0; i++)
2305             tempname[i] = (WCHAR)name[i];
2306
2307     attr = GetFileAttributes(tempname);
2308 # else
2309     attr = GetFileAttributes(name);
2310 # endif
2311     if (attr == INVALID_FILE_ATTRIBUTES)
2312         return -1;
2313     return ((attr & FILE_ATTRIBUTE_DIRECTORY) != 0);
2314 }
2315 #else
2316 # include <sys/stat.h>
2317 # ifndef S_ISDIR
2318 #  if defined(_S_IFMT) && defined(_S_IFDIR)
2319 #   define S_ISDIR(a)   (((a) & _S_IFMT) == _S_IFDIR)
2320 #  else
2321 #   define S_ISDIR(a)   (((a) & S_IFMT) == S_IFDIR)
2322 #  endif
2323 # endif
2324
2325 int app_isdir(const char *name)
2326 {
2327 # if defined(S_ISDIR)
2328     struct stat st;
2329
2330     if (stat(name, &st) == 0)
2331         return S_ISDIR(st.st_mode);
2332     else
2333         return -1;
2334 # else
2335     return -1;
2336 # endif
2337 }
2338 #endif
2339
2340 /* raw_read|write section */
2341 #if defined(__VMS)
2342 # include "vms_term_sock.h"
2343 static int stdin_sock = -1;
2344
2345 static void close_stdin_sock(void)
2346 {
2347     TerminalSocket (TERM_SOCK_DELETE, &stdin_sock);
2348 }
2349
2350 int fileno_stdin(void)
2351 {
2352     if (stdin_sock == -1) {
2353         TerminalSocket(TERM_SOCK_CREATE, &stdin_sock);
2354         atexit(close_stdin_sock);
2355     }
2356
2357     return stdin_sock;
2358 }
2359 #else
2360 int fileno_stdin(void)
2361 {
2362     return fileno(stdin);
2363 }
2364 #endif
2365
2366 int fileno_stdout(void)
2367 {
2368     return fileno(stdout);
2369 }
2370
2371 #if defined(_WIN32) && defined(STD_INPUT_HANDLE)
2372 int raw_read_stdin(void *buf, int siz)
2373 {
2374     DWORD n;
2375     if (ReadFile(GetStdHandle(STD_INPUT_HANDLE), buf, siz, &n, NULL))
2376         return (n);
2377     else
2378         return (-1);
2379 }
2380 #elif defined(__VMS)
2381 # include <sys/socket.h>
2382
2383 int raw_read_stdin(void *buf, int siz)
2384 {
2385     return recv(fileno_stdin(), buf, siz, 0);
2386 }
2387 #else
2388 int raw_read_stdin(void *buf, int siz)
2389 {
2390     return read(fileno_stdin(), buf, siz);
2391 }
2392 #endif
2393
2394 #if defined(_WIN32) && defined(STD_OUTPUT_HANDLE)
2395 int raw_write_stdout(const void *buf, int siz)
2396 {
2397     DWORD n;
2398     if (WriteFile(GetStdHandle(STD_OUTPUT_HANDLE), buf, siz, &n, NULL))
2399         return (n);
2400     else
2401         return (-1);
2402 }
2403 #else
2404 int raw_write_stdout(const void *buf, int siz)
2405 {
2406     return write(fileno_stdout(), buf, siz);
2407 }
2408 #endif
2409
2410 /*
2411  * Centralized handling if input and output files with format specification
2412  * The format is meant to show what the input and output is supposed to be,
2413  * and is therefore a show of intent more than anything else.  However, it
2414  * does impact behavior on some platform, such as differentiating between
2415  * text and binary input/output on non-Unix platforms
2416  */
2417 static int istext(int format)
2418 {
2419     return (format & B_FORMAT_TEXT) == B_FORMAT_TEXT;
2420 }
2421
2422 BIO *dup_bio_in(int format)
2423 {
2424     return BIO_new_fp(stdin,
2425                       BIO_NOCLOSE | (istext(format) ? BIO_FP_TEXT : 0));
2426 }
2427
2428 BIO *dup_bio_out(int format)
2429 {
2430     BIO *b = BIO_new_fp(stdout,
2431                         BIO_NOCLOSE | (istext(format) ? BIO_FP_TEXT : 0));
2432 #ifdef OPENSSL_SYS_VMS
2433     if (istext(format))
2434         b = BIO_push(BIO_new(BIO_f_linebuffer()), b);
2435 #endif
2436     return b;
2437 }
2438
2439 BIO *dup_bio_err(int format)
2440 {
2441     BIO *b = BIO_new_fp(stderr,
2442                         BIO_NOCLOSE | (istext(format) ? BIO_FP_TEXT : 0));
2443 #ifdef OPENSSL_SYS_VMS
2444     if (istext(format))
2445         b = BIO_push(BIO_new(BIO_f_linebuffer()), b);
2446 #endif
2447     return b;
2448 }
2449
2450 void unbuffer(FILE *fp)
2451 {
2452 /*
2453  * On VMS, setbuf() will only take 32-bit pointers, and a compilation
2454  * with /POINTER_SIZE=64 will give off a MAYLOSEDATA2 warning here.
2455  * However, we trust that the C RTL will never give us a FILE pointer
2456  * above the first 4 GB of memory, so we simply turn off the warning
2457  * temporarily.
2458  */
2459 #if defined(OPENSSL_SYS_VMS) && defined(__DECC)
2460 # pragma environment save
2461 # pragma message disable maylosedata2
2462 #endif
2463     setbuf(fp, NULL);
2464 #if defined(OPENSSL_SYS_VMS) && defined(__DECC)
2465 # pragma environment restore
2466 #endif
2467 }
2468
2469 static const char *modestr(char mode, int format)
2470 {
2471     OPENSSL_assert(mode == 'a' || mode == 'r' || mode == 'w');
2472
2473     switch (mode) {
2474     case 'a':
2475         return istext(format) ? "a" : "ab";
2476     case 'r':
2477         return istext(format) ? "r" : "rb";
2478     case 'w':
2479         return istext(format) ? "w" : "wb";
2480     }
2481     /* The assert above should make sure we never reach this point */
2482     return NULL;
2483 }
2484
2485 static const char *modeverb(char mode)
2486 {
2487     switch (mode) {
2488     case 'a':
2489         return "appending";
2490     case 'r':
2491         return "reading";
2492     case 'w':
2493         return "writing";
2494     }
2495     return "(doing something)";
2496 }
2497
2498 /*
2499  * Open a file for writing, owner-read-only.
2500  */
2501 BIO *bio_open_owner(const char *filename, int format, int private)
2502 {
2503     FILE *fp = NULL;
2504     BIO *b = NULL;
2505     int fd = -1, bflags, mode, textmode;
2506
2507     if (!private || filename == NULL || strcmp(filename, "-") == 0)
2508         return bio_open_default(filename, 'w', format);
2509
2510     mode = O_WRONLY;
2511 #ifdef O_CREAT
2512     mode |= O_CREAT;
2513 #endif
2514 #ifdef O_TRUNC
2515     mode |= O_TRUNC;
2516 #endif
2517     textmode = istext(format);
2518     if (!textmode) {
2519 #ifdef O_BINARY
2520         mode |= O_BINARY;
2521 #elif defined(_O_BINARY)
2522         mode |= _O_BINARY;
2523 #endif
2524     }
2525
2526 #ifdef OPENSSL_SYS_VMS
2527     /* VMS doesn't have O_BINARY, it just doesn't make sense.  But,
2528      * it still needs to know that we're going binary, or fdopen()
2529      * will fail with "invalid argument"...  so we tell VMS what the
2530      * context is.
2531      */
2532     if (!textmode)
2533         fd = open(filename, mode, 0600, "ctx=bin");
2534     else
2535 #endif
2536         fd = open(filename, mode, 0600);
2537     if (fd < 0)
2538         goto err;
2539     fp = fdopen(fd, modestr('w', format));
2540     if (fp == NULL)
2541         goto err;
2542     bflags = BIO_CLOSE;
2543     if (textmode)
2544         bflags |= BIO_FP_TEXT;
2545     b = BIO_new_fp(fp, bflags);
2546     if (b)
2547         return b;
2548
2549  err:
2550     BIO_printf(bio_err, "%s: Can't open \"%s\" for writing, %s\n",
2551                opt_getprog(), filename, strerror(errno));
2552     ERR_print_errors(bio_err);
2553     /* If we have fp, then fdopen took over fd, so don't close both. */
2554     if (fp)
2555         fclose(fp);
2556     else if (fd >= 0)
2557         close(fd);
2558     return NULL;
2559 }
2560
2561 static BIO *bio_open_default_(const char *filename, char mode, int format,
2562                               int quiet)
2563 {
2564     BIO *ret;
2565
2566     if (filename == NULL || strcmp(filename, "-") == 0) {
2567         ret = mode == 'r' ? dup_bio_in(format) : dup_bio_out(format);
2568         if (quiet) {
2569             ERR_clear_error();
2570             return ret;
2571         }
2572         if (ret != NULL)
2573             return ret;
2574         BIO_printf(bio_err,
2575                    "Can't open %s, %s\n",
2576                    mode == 'r' ? "stdin" : "stdout", strerror(errno));
2577     } else {
2578         ret = BIO_new_file(filename, modestr(mode, format));
2579         if (quiet) {
2580             ERR_clear_error();
2581             return ret;
2582         }
2583         if (ret != NULL)
2584             return ret;
2585         BIO_printf(bio_err,
2586                    "Can't open %s for %s, %s\n",
2587                    filename, modeverb(mode), strerror(errno));
2588     }
2589     ERR_print_errors(bio_err);
2590     return NULL;
2591 }
2592
2593 BIO *bio_open_default(const char *filename, char mode, int format)
2594 {
2595     return bio_open_default_(filename, mode, format, 0);
2596 }
2597
2598 BIO *bio_open_default_quiet(const char *filename, char mode, int format)
2599 {
2600     return bio_open_default_(filename, mode, format, 1);
2601 }
2602
2603 void wait_for_async(SSL *s)
2604 {
2605     /* On Windows select only works for sockets, so we simply don't wait  */
2606 #ifndef OPENSSL_SYS_WINDOWS
2607     int width = 0;
2608     fd_set asyncfds;
2609     OSSL_ASYNC_FD *fds;
2610     size_t numfds;
2611     size_t i;
2612
2613     if (!SSL_get_all_async_fds(s, NULL, &numfds))
2614         return;
2615     if (numfds == 0)
2616         return;
2617     fds = app_malloc(sizeof(OSSL_ASYNC_FD) * numfds, "allocate async fds");
2618     if (!SSL_get_all_async_fds(s, fds, &numfds)) {
2619         OPENSSL_free(fds);
2620         return;
2621     }
2622
2623     FD_ZERO(&asyncfds);
2624     for (i = 0; i < numfds; i++) {
2625         if (width <= (int)fds[i])
2626             width = (int)fds[i] + 1;
2627         openssl_fdset((int)fds[i], &asyncfds);
2628     }
2629     select(width, (void *)&asyncfds, NULL, NULL, NULL);
2630     OPENSSL_free(fds);
2631 #endif
2632 }
2633
2634 /* if OPENSSL_SYS_WINDOWS is defined then so is OPENSSL_SYS_MSDOS */
2635 #if defined(OPENSSL_SYS_MSDOS)
2636 int has_stdin_waiting(void)
2637 {
2638 # if defined(OPENSSL_SYS_WINDOWS)
2639     HANDLE inhand = GetStdHandle(STD_INPUT_HANDLE);
2640     DWORD events = 0;
2641     INPUT_RECORD inputrec;
2642     DWORD insize = 1;
2643     BOOL peeked;
2644
2645     if (inhand == INVALID_HANDLE_VALUE) {
2646         return 0;
2647     }
2648
2649     peeked = PeekConsoleInput(inhand, &inputrec, insize, &events);
2650     if (!peeked) {
2651         /* Probably redirected input? _kbhit() does not work in this case */
2652         if (!feof(stdin)) {
2653             return 1;
2654         }
2655         return 0;
2656     }
2657 # endif
2658     return _kbhit();
2659 }
2660 #endif
2661
2662 /* Corrupt a signature by modifying final byte */
2663 void corrupt_signature(const ASN1_STRING *signature)
2664 {
2665         unsigned char *s = signature->data;
2666         s[signature->length - 1] ^= 0x1;
2667 }
2668
2669 int set_cert_times(X509 *x, const char *startdate, const char *enddate,
2670                    int days)
2671 {
2672     if (startdate == NULL || strcmp(startdate, "today") == 0) {
2673         if (X509_gmtime_adj(X509_getm_notBefore(x), 0) == NULL)
2674             return 0;
2675     } else {
2676         if (!ASN1_TIME_set_string_X509(X509_getm_notBefore(x), startdate))
2677             return 0;
2678     }
2679     if (enddate == NULL) {
2680         if (X509_time_adj_ex(X509_getm_notAfter(x), days, 0, NULL)
2681             == NULL)
2682             return 0;
2683     } else if (!ASN1_TIME_set_string_X509(X509_getm_notAfter(x), enddate)) {
2684         return 0;
2685     }
2686     return 1;
2687 }
2688
2689 void make_uppercase(char *string)
2690 {
2691     int i;
2692
2693     for (i = 0; string[i] != '\0'; i++)
2694         string[i] = toupper((unsigned char)string[i]);
2695 }