apps/apps.c

   1 /* apps/apps.c */
   2 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
   3  * All rights reserved.
   4  *
   5  * This package is an SSL implementation written
   6  * by Eric Young (eay@cryptsoft.com).
   7  * The implementation was written so as to conform with Netscapes SSL.
   8  *
   9  * This library is free for commercial and non-commercial use as long as
  10  * the following conditions are aheared to.  The following conditions
  11  * apply to all code found in this distribution, be it the RC4, RSA,
  12  * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
  13  * included with this distribution is covered by the same copyright terms
  14  * except that the holder is Tim Hudson (tjh@cryptsoft.com).
  15  *
  16  * Copyright remains Eric Young's, and as such any Copyright notices in
  17  * the code are not to be removed.
  18  * If this package is used in a product, Eric Young should be given attribution
  19  * as the author of the parts of the library used.
  20  * This can be in the form of a textual message at program startup or
  21  * in documentation (online or textual) provided with the package.
  22  *
  23  * Redistribution and use in source and binary forms, with or without
  24  * modification, are permitted provided that the following conditions
  25  * are met:
  26  * 1. Redistributions of source code must retain the copyright
  27  *    notice, this list of conditions and the following disclaimer.
  28  * 2. Redistributions in binary form must reproduce the above copyright
  29  *    notice, this list of conditions and the following disclaimer in the
  30  *    documentation and/or other materials provided with the distribution.
  31  * 3. All advertising materials mentioning features or use of this software
  32  *    must display the following acknowledgement:
  33  *    "This product includes cryptographic software written by
  34  *     Eric Young (eay@cryptsoft.com)"
  35  *    The word 'cryptographic' can be left out if the rouines from the library
  36  *    being used are not cryptographic related :-).
  37  * 4. If you include any Windows specific code (or a derivative thereof) from
  38  *    the apps directory (application code) you must include an acknowledgement:
  39  *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
  40  *
  41  * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
  42  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  43  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  44  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  45  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  46  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  47  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  48  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  49  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  50  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  51  * SUCH DAMAGE.
  52  *
  53  * The licence and distribution terms for any publically available version or
  54  * derivative of this code cannot be changed.  i.e. this code cannot simply be
  55  * copied and put under another distribution licence
  56  * [including the GNU Public Licence.]
  57  */
  58 /* ====================================================================
  59  * Copyright (c) 1998-2001 The OpenSSL Project.  All rights reserved.
  60  *
  61  * Redistribution and use in source and binary forms, with or without
  62  * modification, are permitted provided that the following conditions
  63  * are met:
  64  *
  65  * 1. Redistributions of source code must retain the above copyright
  66  *    notice, this list of conditions and the following disclaimer.
  67  *
  68  * 2. Redistributions in binary form must reproduce the above copyright
  69  *    notice, this list of conditions and the following disclaimer in
  70  *    the documentation and/or other materials provided with the
  71  *    distribution.
  72  *
  73  * 3. All advertising materials mentioning features or use of this
  74  *    software must display the following acknowledgment:
  75  *    "This product includes software developed by the OpenSSL Project
  76  *    for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
  77  *
  78  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
  79  *    endorse or promote products derived from this software without
  80  *    prior written permission. For written permission, please contact
  81  *    openssl-core@openssl.org.
  82  *
  83  * 5. Products derived from this software may not be called "OpenSSL"
  84  *    nor may "OpenSSL" appear in their names without prior written
  85  *    permission of the OpenSSL Project.
  86  *
  87  * 6. Redistributions of any form whatsoever must retain the following
  88  *    acknowledgment:
  89  *    "This product includes software developed by the OpenSSL Project
  90  *    for use in the OpenSSL Toolkit (http://www.openssl.org/)"
  91  *
  92  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
  93  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  94  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  95  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
  96  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  97  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  98  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  99  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 100  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
 101  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 102  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
 103  * OF THE POSSIBILITY OF SUCH DAMAGE.
 104  * ====================================================================
 105  *
 106  * This product includes cryptographic software written by Eric Young
 107  * (eay@cryptsoft.com).  This product includes software written by Tim
 108  * Hudson (tjh@cryptsoft.com).
 109  *
 110  */
 111
 112 #if !defined(_POSIX_C_SOURCE) && defined(OPENSSL_SYS_VMS)
 113 /*
 114  * On VMS, you need to define this to get the declaration of fileno().  The
 115  * value 2 is to make sure no function defined in POSIX-2 is left undefined.
 116  */
 117 # define _POSIX_C_SOURCE 2
 118 #endif
 119 #include <stdio.h>
 120 #include <stdlib.h>
 121 #include <string.h>
 122 #if !defined(OPENSSL_SYSNAME_WIN32) && !defined(NETWARE_CLIB)
 123 # include <strings.h>
 124 #endif
 125 #include <sys/types.h>
 126 #include <ctype.h>
 127 #include <errno.h>
 128 #include <assert.h>
 129 #include <openssl/err.h>
 130 #include <openssl/x509.h>
 131 #include <openssl/x509v3.h>
 132 #include <openssl/pem.h>
 133 #include <openssl/pkcs12.h>
 134 #include <openssl/ui.h>
 135 #include <openssl/safestack.h>
 136 #ifndef OPENSSL_NO_ENGINE
 137 # include <openssl/engine.h>
 138 #endif
 139 #ifndef OPENSSL_NO_RSA
 140 # include <openssl/rsa.h>
 141 #endif
 142 #include <openssl/bn.h>
 143 #ifndef OPENSSL_NO_JPAKE
 144 # include <openssl/jpake.h>
 145 #endif
 146
 147 #define NON_MAIN
 148 #include "apps.h"
 149 #undef NON_MAIN
 150
 151 #ifdef _WIN32
 152 static int WIN32_rename(const char *from, const char *to);
 153 # define rename(from,to) WIN32_rename((from),(to))
 154 #endif
 155
 156 typedef struct {
 157     const char *name;
 158     unsigned long flag;
 159     unsigned long mask;
 160 } NAME_EX_TBL;
 161
 162 static UI_METHOD *ui_method = NULL;
 163
 164 static int set_table_opts(unsigned long *flags, const char *arg,
 165                           const NAME_EX_TBL * in_tbl);
 166 static int set_multi_opts(unsigned long *flags, const char *arg,
 167                           const NAME_EX_TBL * in_tbl);
 168
 169 #if !defined(OPENSSL_NO_RC4) && !defined(OPENSSL_NO_RSA)
 170 /* Looks like this stuff is worth moving into separate function */
 171 static EVP_PKEY *load_netscape_key(BIO *err, BIO *key, const char *file,
 172                                    const char *key_descrip, int format);
 173 #endif
 174
 175 int app_init(long mesgwin);
 176 #ifdef undef                    /* never finished - probably never will be
 177                                  * :-) */
 178 int args_from_file(char *file, int *argc, char **argv[])
 179 {
 180     FILE *fp;
 181     int num, i;
 182     unsigned int len;
 183     static char *buf = NULL;
 184     static char **arg = NULL;
 185     char *p;
 186
 187     fp = fopen(file, "r");
 188     if (fp == NULL)
 189         return (0);
 190
 191     if (fseek(fp, 0, SEEK_END) == 0)
 192         len = ftell(fp), rewind(fp);
 193     else
 194         len = -1;
 195     if (len <= 0) {
 196         fclose(fp);
 197         return (0);
 198     }
 199
 200     *argc = 0;
 201     *argv = NULL;
 202
 203     if (buf != NULL)
 204         OPENSSL_free(buf);
 205     buf = (char *)OPENSSL_malloc(len + 1);
 206     if (buf == NULL)
 207         return (0);
 208
 209     len = fread(buf, 1, len, fp);
 210     if (len <= 1)
 211         return (0);
 212     buf[len] = '\0';
 213
 214     i = 0;
 215     for (p = buf; *p; p++)
 216         if (*p == '\n')
 217             i++;
 218     if (arg != NULL)
 219         OPENSSL_free(arg);
 220     arg = (char **)OPENSSL_malloc(sizeof(char *) * (i * 2));
 221
 222     *argv = arg;
 223     num = 0;
 224     p = buf;
 225     for (;;) {
 226         if (!*p)
 227             break;
 228         if (*p == '#') {        /* comment line */
 229             while (*p && (*p != '\n'))
 230                 p++;
 231             continue;
 232         }
 233         /* else we have a line */
 234         *(arg++) = p;
 235         num++;
 236         while (*p && ((*p != ' ') && (*p != '\t') && (*p != '\n')))
 237             p++;
 238         if (!*p)
 239             break;
 240         if (*p == '\n') {
 241             *(p++) = '\0';
 242             continue;
 243         }
 244         /* else it is a tab or space */
 245         p++;
 246         while (*p && ((*p == ' ') || (*p == '\t') || (*p == '\n')))
 247             p++;
 248         if (!*p)
 249             break;
 250         if (*p == '\n') {
 251             p++;
 252             continue;
 253         }
 254         *(arg++) = p++;
 255         num++;
 256         while (*p && (*p != '\n'))
 257             p++;
 258         if (!*p)
 259             break;
 260         /* else *p == '\n' */
 261         *(p++) = '\0';
 262     }
 263     *argc = num;
 264     return (1);
 265 }
 266 #endif
 267
 268 int str2fmt(char *s)
 269 {
 270     if (s == NULL)
 271         return FORMAT_UNDEF;
 272     if ((*s == 'D') || (*s == 'd'))
 273         return (FORMAT_ASN1);
 274     else if ((*s == 'T') || (*s == 't'))
 275         return (FORMAT_TEXT);
 276     else if ((*s == 'N') || (*s == 'n'))
 277         return (FORMAT_NETSCAPE);
 278     else if ((*s == 'S') || (*s == 's'))
 279         return (FORMAT_SMIME);
 280     else if ((*s == 'M') || (*s == 'm'))
 281         return (FORMAT_MSBLOB);
 282     else if ((*s == '1')
 283              || (strcmp(s, "PKCS12") == 0) || (strcmp(s, "pkcs12") == 0)
 284              || (strcmp(s, "P12") == 0) || (strcmp(s, "p12") == 0))
 285         return (FORMAT_PKCS12);
 286     else if ((*s == 'E') || (*s == 'e'))
 287         return (FORMAT_ENGINE);
 288     else if ((*s == 'P') || (*s == 'p')) {
 289         if (s[1] == 'V' || s[1] == 'v')
 290             return FORMAT_PVK;
 291         else
 292             return (FORMAT_PEM);
 293     } else
 294         return (FORMAT_UNDEF);
 295 }
 296
 297 #if defined(OPENSSL_SYS_MSDOS) || defined(OPENSSL_SYS_WIN32) || defined(OPENSSL_SYS_WIN16) || defined(OPENSSL_SYS_NETWARE)
 298 void program_name(char *in, char *out, int size)
 299 {
 300     int i, n;
 301     char *p = NULL;
 302
 303     n = strlen(in);
 304     /* find the last '/', '\' or ':' */
 305     for (i = n - 1; i > 0; i--) {
 306         if ((in[i] == '/') || (in[i] == '\\') || (in[i] == ':')) {
 307             p = &(in[i + 1]);
 308             break;
 309         }
 310     }
 311     if (p == NULL)
 312         p = in;
 313     n = strlen(p);
 314
 315 # if defined(OPENSSL_SYS_NETWARE)
 316     /* strip off trailing .nlm if present. */
 317     if ((n > 4) && (p[n - 4] == '.') &&
 318         ((p[n - 3] == 'n') || (p[n - 3] == 'N')) &&
 319         ((p[n - 2] == 'l') || (p[n - 2] == 'L')) &&
 320         ((p[n - 1] == 'm') || (p[n - 1] == 'M')))
 321         n -= 4;
 322 # else
 323     /* strip off trailing .exe if present. */
 324     if ((n > 4) && (p[n - 4] == '.') &&
 325         ((p[n - 3] == 'e') || (p[n - 3] == 'E')) &&
 326         ((p[n - 2] == 'x') || (p[n - 2] == 'X')) &&
 327         ((p[n - 1] == 'e') || (p[n - 1] == 'E')))
 328         n -= 4;
 329 # endif
 330
 331     if (n > size - 1)
 332         n = size - 1;
 333
 334     for (i = 0; i < n; i++) {
 335         if ((p[i] >= 'A') && (p[i] <= 'Z'))
 336             out[i] = p[i] - 'A' + 'a';
 337         else
 338             out[i] = p[i];
 339     }
 340     out[n] = '\0';
 341 }
 342 #else
 343 # ifdef OPENSSL_SYS_VMS
 344 void program_name(char *in, char *out, int size)
 345 {
 346     char *p = in, *q;
 347     char *chars = ":]>";
 348
 349     while (*chars != '\0') {
 350         q = strrchr(p, *chars);
 351         if (q > p)
 352             p = q + 1;
 353         chars++;
 354     }
 355
 356     q = strrchr(p, '.');
 357     if (q == NULL)
 358         q = p + strlen(p);
 359     strncpy(out, p, size - 1);
 360     if (q - p >= size) {
 361         out[size - 1] = '\0';
 362     } else {
 363         out[q - p] = '\0';
 364     }
 365 }
 366 # else
 367 void program_name(char *in, char *out, int size)
 368 {
 369     char *p;
 370
 371     p = strrchr(in, '/');
 372     if (p != NULL)
 373         p++;
 374     else
 375         p = in;
 376     BUF_strlcpy(out, p, size);
 377 }
 378 # endif
 379 #endif
 380
 381 int chopup_args(ARGS *arg, char *buf, int *argc, char **argv[])
 382 {
 383     int num, i;
 384     char *p;
 385
 386     *argc = 0;
 387     *argv = NULL;
 388
 389     i = 0;
 390     if (arg->count == 0) {
 391         arg->count = 20;
 392         arg->data = (char **)OPENSSL_malloc(sizeof(char *) * arg->count);
 393         if (arg->data == NULL)
 394             return 0;
 395     }
 396     for (i = 0; i < arg->count; i++)
 397         arg->data[i] = NULL;
 398
 399     num = 0;
 400     p = buf;
 401     for (;;) {
 402         /* first scan over white space */
 403         if (!*p)
 404             break;
 405         while (*p && ((*p == ' ') || (*p == '\t') || (*p == '\n')))
 406             p++;
 407         if (!*p)
 408             break;
 409
 410         /* The start of something good :-) */
 411         if (num >= arg->count) {
 412             char **tmp_p;
 413             int tlen = arg->count + 20;
 414             tmp_p = (char **)OPENSSL_realloc(arg->data,
 415                                              sizeof(char *) * tlen);
 416             if (tmp_p == NULL)
 417                 return 0;
 418             arg->data = tmp_p;
 419             arg->count = tlen;
 420             /* initialize newly allocated data */
 421             for (i = num; i < arg->count; i++)
 422                 arg->data[i] = NULL;
 423         }
 424         arg->data[num++] = p;
 425
 426         /* now look for the end of this */
 427         if ((*p == '\'') || (*p == '\"')) { /* scan for closing quote */
 428             i = *(p++);
 429             arg->data[num - 1]++; /* jump over quote */
 430             while (*p && (*p != i))
 431                 p++;
 432             *p = '\0';
 433         } else {
 434             while (*p && ((*p != ' ') && (*p != '\t') && (*p != '\n')))
 435                 p++;
 436
 437             if (*p == '\0')
 438                 p--;
 439             else
 440                 *p = '\0';
 441         }
 442         p++;
 443     }
 444     *argc = num;
 445     *argv = arg->data;
 446     return (1);
 447 }
 448
 449 #ifndef APP_INIT
 450 int app_init(long mesgwin)
 451 {
 452     return (1);
 453 }
 454 #endif
 455
 456 int dump_cert_text(BIO *out, X509 *x)
 457 {
 458     char *p;
 459
 460     p = X509_NAME_oneline(X509_get_subject_name(x), NULL, 0);
 461     BIO_puts(out, "subject=");
 462     BIO_puts(out, p);
 463     OPENSSL_free(p);
 464
 465     p = X509_NAME_oneline(X509_get_issuer_name(x), NULL, 0);
 466     BIO_puts(out, "\nissuer=");
 467     BIO_puts(out, p);
 468     BIO_puts(out, "\n");
 469     OPENSSL_free(p);
 470
 471     return 0;
 472 }
 473
 474 static int ui_open(UI *ui)
 475 {
 476     return UI_method_get_opener(UI_OpenSSL())(ui);
 477 }
 478
 479 static int ui_read(UI *ui, UI_STRING *uis)
 480 {
 481     if (UI_get_input_flags(uis) & UI_INPUT_FLAG_DEFAULT_PWD
 482         && UI_get0_user_data(ui)) {
 483         switch (UI_get_string_type(uis)) {
 484         case UIT_PROMPT:
 485         case UIT_VERIFY:
 486             {
 487                 const char *password =
 488                     ((PW_CB_DATA *)UI_get0_user_data(ui))->password;
 489                 if (password && password[0] != '\0') {
 490                     UI_set_result(ui, uis, password);
 491                     return 1;
 492                 }
 493             }
 494         default:
 495             break;
 496         }
 497     }
 498     return UI_method_get_reader(UI_OpenSSL())(ui, uis);
 499 }
 500
 501 static int ui_write(UI *ui, UI_STRING *uis)
 502 {
 503     if (UI_get_input_flags(uis) & UI_INPUT_FLAG_DEFAULT_PWD
 504         && UI_get0_user_data(ui)) {
 505         switch (UI_get_string_type(uis)) {
 506         case UIT_PROMPT:
 507         case UIT_VERIFY:
 508             {
 509                 const char *password =
 510                     ((PW_CB_DATA *)UI_get0_user_data(ui))->password;
 511                 if (password && password[0] != '\0')
 512                     return 1;
 513             }
 514         default:
 515             break;
 516         }
 517     }
 518     return UI_method_get_writer(UI_OpenSSL())(ui, uis);
 519 }
 520
 521 static int ui_close(UI *ui)
 522 {
 523     return UI_method_get_closer(UI_OpenSSL())(ui);
 524 }
 525
 526 int setup_ui_method(void)
 527 {
 528     ui_method = UI_create_method("OpenSSL application user interface");
 529     UI_method_set_opener(ui_method, ui_open);
 530     UI_method_set_reader(ui_method, ui_read);
 531     UI_method_set_writer(ui_method, ui_write);
 532     UI_method_set_closer(ui_method, ui_close);
 533     return 0;
 534 }
 535
 536 void destroy_ui_method(void)
 537 {
 538     if (ui_method) {
 539         UI_destroy_method(ui_method);
 540         ui_method = NULL;
 541     }
 542 }
 543
 544 int password_callback(char *buf, int bufsiz, int verify, PW_CB_DATA *cb_tmp)
 545 {
 546     UI *ui = NULL;
 547     int res = 0;
 548     const char *prompt_info = NULL;
 549     const char *password = NULL;
 550     PW_CB_DATA *cb_data = (PW_CB_DATA *)cb_tmp;
 551
 552     if (cb_data) {
 553         if (cb_data->password)
 554             password = cb_data->password;
 555         if (cb_data->prompt_info)
 556             prompt_info = cb_data->prompt_info;
 557     }
 558
 559     if (password) {
 560         res = strlen(password);
 561         if (res > bufsiz)
 562             res = bufsiz;
 563         memcpy(buf, password, res);
 564         return res;
 565     }
 566
 567     ui = UI_new_method(ui_method);
 568     if (ui) {
 569         int ok = 0;
 570         char *buff = NULL;
 571         int ui_flags = 0;
 572         char *prompt = NULL;
 573
 574         prompt = UI_construct_prompt(ui, "pass phrase", prompt_info);
 575         if (!prompt) {
 576             BIO_printf(bio_err, "Out of memory\n");
 577             UI_free(ui);
 578             return 0;
 579         }
 580
 581         ui_flags |= UI_INPUT_FLAG_DEFAULT_PWD;
 582         UI_ctrl(ui, UI_CTRL_PRINT_ERRORS, 1, 0, 0);
 583
 584         if (ok >= 0)
 585             ok = UI_add_input_string(ui, prompt, ui_flags, buf,
 586                                      PW_MIN_LENGTH, bufsiz - 1);
 587         if (ok >= 0 && verify) {
 588             buff = (char *)OPENSSL_malloc(bufsiz);
 589             if (!buff) {
 590                 BIO_printf(bio_err, "Out of memory\n");
 591                 UI_free(ui);
 592                 OPENSSL_free(prompt);
 593                 return 0;
 594             }
 595             ok = UI_add_verify_string(ui, prompt, ui_flags, buff,
 596                                       PW_MIN_LENGTH, bufsiz - 1, buf);
 597         }
 598         if (ok >= 0)
 599             do {
 600                 ok = UI_process(ui);
 601             }
 602             while (ok < 0 && UI_ctrl(ui, UI_CTRL_IS_REDOABLE, 0, 0, 0));
 603
 604         if (buff) {
 605             OPENSSL_cleanse(buff, (unsigned int)bufsiz);
 606             OPENSSL_free(buff);
 607         }
 608
 609         if (ok >= 0)
 610             res = strlen(buf);
 611         if (ok == -1) {
 612             BIO_printf(bio_err, "User interface error\n");
 613             ERR_print_errors(bio_err);
 614             OPENSSL_cleanse(buf, (unsigned int)bufsiz);
 615             res = 0;
 616         }
 617         if (ok == -2) {
 618             BIO_printf(bio_err, "aborted!\n");
 619             OPENSSL_cleanse(buf, (unsigned int)bufsiz);
 620             res = 0;
 621         }
 622         UI_free(ui);
 623         OPENSSL_free(prompt);
 624     }
 625     return res;
 626 }
 627
 628 static char *app_get_pass(BIO *err, char *arg, int keepbio);
 629
 630 int app_passwd(BIO *err, char *arg1, char *arg2, char **pass1, char **pass2)
 631 {
 632     int same;
 633     if (!arg2 || !arg1 || strcmp(arg1, arg2))
 634         same = 0;
 635     else
 636         same = 1;
 637     if (arg1) {
 638         *pass1 = app_get_pass(err, arg1, same);
 639         if (!*pass1)
 640             return 0;
 641     } else if (pass1)
 642         *pass1 = NULL;
 643     if (arg2) {
 644         *pass2 = app_get_pass(err, arg2, same ? 2 : 0);
 645         if (!*pass2)
 646             return 0;
 647     } else if (pass2)
 648         *pass2 = NULL;
 649     return 1;
 650 }
 651
 652 static char *app_get_pass(BIO *err, char *arg, int keepbio)
 653 {
 654     char *tmp, tpass[APP_PASS_LEN];
 655     static BIO *pwdbio = NULL;
 656     int i;
 657     if (!strncmp(arg, "pass:", 5))
 658         return BUF_strdup(arg + 5);
 659     if (!strncmp(arg, "env:", 4)) {
 660         tmp = getenv(arg + 4);
 661         if (!tmp) {
 662             BIO_printf(err, "Can't read environment variable %s\n", arg + 4);
 663             return NULL;
 664         }
 665         return BUF_strdup(tmp);
 666     }
 667     if (!keepbio || !pwdbio) {
 668         if (!strncmp(arg, "file:", 5)) {
 669             pwdbio = BIO_new_file(arg + 5, "r");
 670             if (!pwdbio) {
 671                 BIO_printf(err, "Can't open file %s\n", arg + 5);
 672                 return NULL;
 673             }
 674 #if !defined(_WIN32)
 675             /*
 676              * Under _WIN32, which covers even Win64 and CE, file
 677              * descriptors referenced by BIO_s_fd are not inherited
 678              * by child process and therefore below is not an option.
 679              * It could have been an option if bss_fd.c was operating
 680              * on real Windows descriptors, such as those obtained
 681              * with CreateFile.
 682              */
 683         } else if (!strncmp(arg, "fd:", 3)) {
 684             BIO *btmp;
 685             i = atoi(arg + 3);
 686             if (i >= 0)
 687                 pwdbio = BIO_new_fd(i, BIO_NOCLOSE);
 688             if ((i < 0) || !pwdbio) {
 689                 BIO_printf(err, "Can't access file descriptor %s\n", arg + 3);
 690                 return NULL;
 691             }
 692             /*
 693              * Can't do BIO_gets on an fd BIO so add a buffering BIO
 694              */
 695             btmp = BIO_new(BIO_f_buffer());
 696             pwdbio = BIO_push(btmp, pwdbio);
 697 #endif
 698         } else if (!strcmp(arg, "stdin")) {
 699             pwdbio = BIO_new_fp(stdin, BIO_NOCLOSE);
 700             if (!pwdbio) {
 701                 BIO_printf(err, "Can't open BIO for stdin\n");
 702                 return NULL;
 703             }
 704         } else {
 705             BIO_printf(err, "Invalid password argument \"%s\"\n", arg);
 706             return NULL;
 707         }
 708     }
 709     i = BIO_gets(pwdbio, tpass, APP_PASS_LEN);
 710     if (keepbio != 1) {
 711         BIO_free_all(pwdbio);
 712         pwdbio = NULL;
 713     }
 714     if (i <= 0) {
 715         BIO_printf(err, "Error reading password from BIO\n");
 716         return NULL;
 717     }
 718     tmp = strchr(tpass, '\n');
 719     if (tmp)
 720         *tmp = 0;
 721     return BUF_strdup(tpass);
 722 }
 723
 724 int add_oid_section(BIO *err, CONF *conf)
 725 {
 726     char *p;
 727     STACK_OF(CONF_VALUE) *sktmp;
 728     CONF_VALUE *cnf;
 729     int i;
 730     if (!(p = NCONF_get_string(conf, NULL, "oid_section"))) {
 731         ERR_clear_error();
 732         return 1;
 733     }
 734     if (!(sktmp = NCONF_get_section(conf, p))) {
 735         BIO_printf(err, "problem loading oid section %s\n", p);
 736         return 0;
 737     }
 738     for (i = 0; i < sk_CONF_VALUE_num(sktmp); i++) {
 739         cnf = sk_CONF_VALUE_value(sktmp, i);
 740         if (OBJ_create(cnf->value, cnf->name, cnf->name) == NID_undef) {
 741             BIO_printf(err, "problem creating object %s=%s\n",
 742                        cnf->name, cnf->value);
 743             return 0;
 744         }
 745     }
 746     return 1;
 747 }
 748
 749 static int load_pkcs12(BIO *err, BIO *in, const char *desc,
 750                        pem_password_cb *pem_cb, void *cb_data,
 751                        EVP_PKEY **pkey, X509 **cert, STACK_OF(X509) **ca)
 752 {
 753     const char *pass;
 754     char tpass[PEM_BUFSIZE];
 755     int len, ret = 0;
 756     PKCS12 *p12;
 757     p12 = d2i_PKCS12_bio(in, NULL);
 758     if (p12 == NULL) {
 759         BIO_printf(err, "Error loading PKCS12 file for %s\n", desc);
 760         goto die;
 761     }
 762     /* See if an empty password will do */
 763     if (PKCS12_verify_mac(p12, "", 0) || PKCS12_verify_mac(p12, NULL, 0))
 764         pass = "";
 765     else {
 766         if (!pem_cb)
 767             pem_cb = (pem_password_cb *)password_callback;
 768         len = pem_cb(tpass, PEM_BUFSIZE, 0, cb_data);
 769         if (len < 0) {
 770             BIO_printf(err, "Passpharse callback error for %s\n", desc);
 771             goto die;
 772         }
 773         if (len < PEM_BUFSIZE)
 774             tpass[len] = 0;
 775         if (!PKCS12_verify_mac(p12, tpass, len)) {
 776             BIO_printf(err,
 777                        "Mac verify error (wrong password?) in PKCS12 file for %s\n",
 778                        desc);
 779             goto die;
 780         }
 781         pass = tpass;
 782     }
 783     ret = PKCS12_parse(p12, pass, pkey, cert, ca);
 784  die:
 785     if (p12)
 786         PKCS12_free(p12);
 787     return ret;
 788 }
 789
 790 X509 *load_cert(BIO *err, const char *file, int format,
 791                 const char *pass, ENGINE *e, const char *cert_descrip)
 792 {
 793     X509 *x = NULL;
 794     BIO *cert;
 795
 796     if ((cert = BIO_new(BIO_s_file())) == NULL) {
 797         ERR_print_errors(err);
 798         goto end;
 799     }
 800
 801     if (file == NULL) {
 802 #ifdef _IONBF
 803 # ifndef OPENSSL_NO_SETVBUF_IONBF
 804         setvbuf(stdin, NULL, _IONBF, 0);
 805 # endif                         /* ndef OPENSSL_NO_SETVBUF_IONBF */
 806 #endif
 807         BIO_set_fp(cert, stdin, BIO_NOCLOSE);
 808     } else {
 809         if (BIO_read_filename(cert, file) <= 0) {
 810             BIO_printf(err, "Error opening %s %s\n", cert_descrip, file);
 811             ERR_print_errors(err);
 812             goto end;
 813         }
 814     }
 815
 816     if (format == FORMAT_ASN1)
 817         x = d2i_X509_bio(cert, NULL);
 818     else if (format == FORMAT_NETSCAPE) {
 819         NETSCAPE_X509 *nx;
 820         nx = ASN1_item_d2i_bio(ASN1_ITEM_rptr(NETSCAPE_X509), cert, NULL);
 821         if (nx == NULL)
 822             goto end;
 823
 824         if ((strncmp(NETSCAPE_CERT_HDR, (char *)nx->header->data,
 825                      nx->header->length) != 0)) {
 826             NETSCAPE_X509_free(nx);
 827             BIO_printf(err, "Error reading header on certificate\n");
 828             goto end;
 829         }
 830         x = nx->cert;
 831         nx->cert = NULL;
 832         NETSCAPE_X509_free(nx);
 833     } else if (format == FORMAT_PEM)
 834         x = PEM_read_bio_X509_AUX(cert, NULL,
 835                                   (pem_password_cb *)password_callback, NULL);
 836     else if (format == FORMAT_PKCS12) {
 837         if (!load_pkcs12(err, cert, cert_descrip, NULL, NULL, NULL, &x, NULL))
 838             goto end;
 839     } else {
 840         BIO_printf(err, "bad input format specified for %s\n", cert_descrip);
 841         goto end;
 842     }
 843  end:
 844     if (x == NULL) {
 845         BIO_printf(err, "unable to load certificate\n");
 846         ERR_print_errors(err);
 847     }
 848     if (cert != NULL)
 849         BIO_free(cert);
 850     return (x);
 851 }
 852
 853 EVP_PKEY *load_key(BIO *err, const char *file, int format, int maybe_stdin,
 854                    const char *pass, ENGINE *e, const char *key_descrip)
 855 {
 856     BIO *key = NULL;
 857     EVP_PKEY *pkey = NULL;
 858     PW_CB_DATA cb_data;
 859
 860     cb_data.password = pass;
 861     cb_data.prompt_info = file;
 862
 863     if (file == NULL && (!maybe_stdin || format == FORMAT_ENGINE)) {
 864         BIO_printf(err, "no keyfile specified\n");
 865         goto end;
 866     }
 867 #ifndef OPENSSL_NO_ENGINE
 868     if (format == FORMAT_ENGINE) {
 869         if (!e)
 870             BIO_printf(err, "no engine specified\n");
 871         else {
 872             pkey = ENGINE_load_private_key(e, file, ui_method, &cb_data);
 873             if (!pkey) {
 874                 BIO_printf(err, "cannot load %s from engine\n", key_descrip);
 875                 ERR_print_errors(err);
 876             }
 877         }
 878         goto end;
 879     }
 880 #endif
 881     key = BIO_new(BIO_s_file());
 882     if (key == NULL) {
 883         ERR_print_errors(err);
 884         goto end;
 885     }
 886     if (file == NULL && maybe_stdin) {
 887 #ifdef _IONBF
 888 # ifndef OPENSSL_NO_SETVBUF_IONBF
 889         setvbuf(stdin, NULL, _IONBF, 0);
 890 # endif                         /* ndef OPENSSL_NO_SETVBUF_IONBF */
 891 #endif
 892         BIO_set_fp(key, stdin, BIO_NOCLOSE);
 893     } else if (BIO_read_filename(key, file) <= 0) {
 894         BIO_printf(err, "Error opening %s %s\n", key_descrip, file);
 895         ERR_print_errors(err);
 896         goto end;
 897     }
 898     if (format == FORMAT_ASN1) {
 899         pkey = d2i_PrivateKey_bio(key, NULL);
 900     } else if (format == FORMAT_PEM) {
 901         pkey = PEM_read_bio_PrivateKey(key, NULL,
 902                                        (pem_password_cb *)password_callback,
 903                                        &cb_data);
 904     }
 905 #if !defined(OPENSSL_NO_RC4) && !defined(OPENSSL_NO_RSA)
 906     else if (format == FORMAT_NETSCAPE || format == FORMAT_IISSGC)
 907         pkey = load_netscape_key(err, key, file, key_descrip, format);
 908 #endif
 909     else if (format == FORMAT_PKCS12) {
 910         if (!load_pkcs12(err, key, key_descrip,
 911                          (pem_password_cb *)password_callback, &cb_data,
 912                          &pkey, NULL, NULL))
 913             goto end;
 914     }
 915 #if !defined(OPENSSL_NO_RSA) && !defined(OPENSSL_NO_DSA) && !defined (OPENSSL_NO_RC4)
 916     else if (format == FORMAT_MSBLOB)
 917         pkey = b2i_PrivateKey_bio(key);
 918     else if (format == FORMAT_PVK)
 919         pkey = b2i_PVK_bio(key, (pem_password_cb *)password_callback,
 920                            &cb_data);
 921 #endif
 922     else {
 923         BIO_printf(err, "bad input format specified for key file\n");
 924         goto end;
 925     }
 926  end:
 927     if (key != NULL)
 928         BIO_free(key);
 929     if (pkey == NULL) {
 930         BIO_printf(err, "unable to load %s\n", key_descrip);
 931         ERR_print_errors(err);
 932     }
 933     return (pkey);
 934 }
 935
 936 EVP_PKEY *load_pubkey(BIO *err, const char *file, int format, int maybe_stdin,
 937                       const char *pass, ENGINE *e, const char *key_descrip)
 938 {
 939     BIO *key = NULL;
 940     EVP_PKEY *pkey = NULL;
 941     PW_CB_DATA cb_data;
 942
 943     cb_data.password = pass;
 944     cb_data.prompt_info = file;
 945
 946     if (file == NULL && (!maybe_stdin || format == FORMAT_ENGINE)) {
 947         BIO_printf(err, "no keyfile specified\n");
 948         goto end;
 949     }
 950 #ifndef OPENSSL_NO_ENGINE
 951     if (format == FORMAT_ENGINE) {
 952         if (!e)
 953             BIO_printf(bio_err, "no engine specified\n");
 954         else
 955             pkey = ENGINE_load_public_key(e, file, ui_method, &cb_data);
 956         goto end;
 957     }
 958 #endif
 959     key = BIO_new(BIO_s_file());
 960     if (key == NULL) {
 961         ERR_print_errors(err);
 962         goto end;
 963     }
 964     if (file == NULL && maybe_stdin) {
 965 #ifdef _IONBF
 966 # ifndef OPENSSL_NO_SETVBUF_IONBF
 967         setvbuf(stdin, NULL, _IONBF, 0);
 968 # endif                         /* ndef OPENSSL_NO_SETVBUF_IONBF */
 969 #endif
 970         BIO_set_fp(key, stdin, BIO_NOCLOSE);
 971     } else if (BIO_read_filename(key, file) <= 0) {
 972         BIO_printf(err, "Error opening %s %s\n", key_descrip, file);
 973         ERR_print_errors(err);
 974         goto end;
 975     }
 976     if (format == FORMAT_ASN1) {
 977         pkey = d2i_PUBKEY_bio(key, NULL);
 978     }
 979 #ifndef OPENSSL_NO_RSA
 980     else if (format == FORMAT_ASN1RSA) {
 981         RSA *rsa;
 982         rsa = d2i_RSAPublicKey_bio(key, NULL);
 983         if (rsa) {
 984             pkey = EVP_PKEY_new();
 985             if (pkey)
 986                 EVP_PKEY_set1_RSA(pkey, rsa);
 987             RSA_free(rsa);
 988         } else
 989             pkey = NULL;
 990     } else if (format == FORMAT_PEMRSA) {
 991         RSA *rsa;
 992         rsa = PEM_read_bio_RSAPublicKey(key, NULL,
 993                                         (pem_password_cb *)password_callback,
 994                                         &cb_data);
 995         if (rsa) {
 996             pkey = EVP_PKEY_new();
 997             if (pkey)
 998                 EVP_PKEY_set1_RSA(pkey, rsa);
 999             RSA_free(rsa);
1000         } else
1001             pkey = NULL;
1002     }
1003 #endif
1004     else if (format == FORMAT_PEM) {
1005         pkey = PEM_read_bio_PUBKEY(key, NULL,
1006                                    (pem_password_cb *)password_callback,
1007                                    &cb_data);
1008     }
1009 #if !defined(OPENSSL_NO_RC4) && !defined(OPENSSL_NO_RSA)
1010     else if (format == FORMAT_NETSCAPE || format == FORMAT_IISSGC)
1011         pkey = load_netscape_key(err, key, file, key_descrip, format);
1012 #endif
1013 #if !defined(OPENSSL_NO_RSA) && !defined(OPENSSL_NO_DSA)
1014     else if (format == FORMAT_MSBLOB)
1015         pkey = b2i_PublicKey_bio(key);
1016 #endif
1017     else {
1018         BIO_printf(err, "bad input format specified for key file\n");
1019         goto end;
1020     }
1021  end:
1022     if (key != NULL)
1023         BIO_free(key);
1024     if (pkey == NULL)
1025         BIO_printf(err, "unable to load %s\n", key_descrip);
1026     return (pkey);
1027 }
1028
1029 #if !defined(OPENSSL_NO_RC4) && !defined(OPENSSL_NO_RSA)
1030 static EVP_PKEY *load_netscape_key(BIO *err, BIO *key, const char *file,
1031                                    const char *key_descrip, int format)
1032 {
1033     EVP_PKEY *pkey;
1034     BUF_MEM *buf;
1035     RSA *rsa;
1036     const unsigned char *p;
1037     int size, i;
1038
1039     buf = BUF_MEM_new();
1040     pkey = EVP_PKEY_new();
1041     size = 0;
1042     if (buf == NULL || pkey == NULL)
1043         goto error;
1044     for (;;) {
1045         if (!BUF_MEM_grow_clean(buf, size + 1024 * 10))
1046             goto error;
1047         i = BIO_read(key, &(buf->data[size]), 1024 * 10);
1048         size += i;
1049         if (i == 0)
1050             break;
1051         if (i < 0) {
1052             BIO_printf(err, "Error reading %s %s", key_descrip, file);
1053             goto error;
1054         }
1055     }
1056     p = (unsigned char *)buf->data;
1057     rsa = d2i_RSA_NET(NULL, &p, (long)size, NULL,
1058                       (format == FORMAT_IISSGC ? 1 : 0));
1059     if (rsa == NULL)
1060         goto error;
1061     BUF_MEM_free(buf);
1062     EVP_PKEY_set1_RSA(pkey, rsa);
1063     return pkey;
1064  error:
1065     BUF_MEM_free(buf);
1066     EVP_PKEY_free(pkey);
1067     return NULL;
1068 }
1069 #endif                          /* ndef OPENSSL_NO_RC4 */
1070
1071 static int load_certs_crls(BIO *err, const char *file, int format,
1072                            const char *pass, ENGINE *e, const char *desc,
1073                            STACK_OF(X509) **pcerts,
1074                            STACK_OF(X509_CRL) **pcrls)
1075 {
1076     int i;
1077     BIO *bio;
1078     STACK_OF(X509_INFO) *xis = NULL;
1079     X509_INFO *xi;
1080     PW_CB_DATA cb_data;
1081     int rv = 0;
1082
1083     cb_data.password = pass;
1084     cb_data.prompt_info = file;
1085
1086     if (format != FORMAT_PEM) {
1087         BIO_printf(err, "bad input format specified for %s\n", desc);
1088         return 0;
1089     }
1090
1091     if (file == NULL)
1092         bio = BIO_new_fp(stdin, BIO_NOCLOSE);
1093     else
1094         bio = BIO_new_file(file, "r");
1095
1096     if (bio == NULL) {
1097         BIO_printf(err, "Error opening %s %s\n", desc, file ? file : "stdin");
1098         ERR_print_errors(err);
1099         return 0;
1100     }
1101
1102     xis = PEM_X509_INFO_read_bio(bio, NULL,
1103                                  (pem_password_cb *)password_callback,
1104                                  &cb_data);
1105
1106     BIO_free(bio);
1107
1108     if (pcerts) {
1109         *pcerts = sk_X509_new_null();
1110         if (!*pcerts)
1111             goto end;
1112     }
1113
1114     if (pcrls) {
1115         *pcrls = sk_X509_CRL_new_null();
1116         if (!*pcrls)
1117             goto end;
1118     }
1119
1120     for (i = 0; i < sk_X509_INFO_num(xis); i++) {
1121         xi = sk_X509_INFO_value(xis, i);
1122         if (xi->x509 && pcerts) {
1123             if (!sk_X509_push(*pcerts, xi->x509))
1124                 goto end;
1125             xi->x509 = NULL;
1126         }
1127         if (xi->crl && pcrls) {
1128             if (!sk_X509_CRL_push(*pcrls, xi->crl))
1129                 goto end;
1130             xi->crl = NULL;
1131         }
1132     }
1133
1134     if (pcerts && sk_X509_num(*pcerts) > 0)
1135         rv = 1;
1136
1137     if (pcrls && sk_X509_CRL_num(*pcrls) > 0)
1138         rv = 1;
1139
1140  end:
1141
1142     if (xis)
1143         sk_X509_INFO_pop_free(xis, X509_INFO_free);
1144
1145     if (rv == 0) {
1146         if (pcerts) {
1147             sk_X509_pop_free(*pcerts, X509_free);
1148             *pcerts = NULL;
1149         }
1150         if (pcrls) {
1151             sk_X509_CRL_pop_free(*pcrls, X509_CRL_free);
1152             *pcrls = NULL;
1153         }
1154         BIO_printf(err, "unable to load %s\n",
1155                    pcerts ? "certificates" : "CRLs");
1156         ERR_print_errors(err);
1157     }
1158     return rv;
1159 }
1160
1161 STACK_OF(X509) *load_certs(BIO *err, const char *file, int format,
1162                            const char *pass, ENGINE *e, const char *desc)
1163 {
1164     STACK_OF(X509) *certs;
1165     if (!load_certs_crls(err, file, format, pass, e, desc, &certs, NULL))
1166         return NULL;
1167     return certs;
1168 }
1169
1170 STACK_OF(X509_CRL) *load_crls(BIO *err, const char *file, int format,
1171                               const char *pass, ENGINE *e, const char *desc)
1172 {
1173     STACK_OF(X509_CRL) *crls;
1174     if (!load_certs_crls(err, file, format, pass, e, desc, NULL, &crls))
1175         return NULL;
1176     return crls;
1177 }
1178
1179 #define X509V3_EXT_UNKNOWN_MASK         (0xfL << 16)
1180 /* Return error for unknown extensions */
1181 #define X509V3_EXT_DEFAULT              0
1182 /* Print error for unknown extensions */
1183 #define X509V3_EXT_ERROR_UNKNOWN        (1L << 16)
1184 /* ASN1 parse unknown extensions */
1185 #define X509V3_EXT_PARSE_UNKNOWN        (2L << 16)
1186 /* BIO_dump unknown extensions */
1187 #define X509V3_EXT_DUMP_UNKNOWN         (3L << 16)
1188
1189 #define X509_FLAG_CA (X509_FLAG_NO_ISSUER | X509_FLAG_NO_PUBKEY | \
1190                          X509_FLAG_NO_HEADER | X509_FLAG_NO_VERSION)
1191
1192 int set_cert_ex(unsigned long *flags, const char *arg)
1193 {
1194     static const NAME_EX_TBL cert_tbl[] = {
1195         {"compatible", X509_FLAG_COMPAT, 0xffffffffl},
1196         {"ca_default", X509_FLAG_CA, 0xffffffffl},
1197         {"no_header", X509_FLAG_NO_HEADER, 0},
1198         {"no_version", X509_FLAG_NO_VERSION, 0},
1199         {"no_serial", X509_FLAG_NO_SERIAL, 0},
1200         {"no_signame", X509_FLAG_NO_SIGNAME, 0},
1201         {"no_validity", X509_FLAG_NO_VALIDITY, 0},
1202         {"no_subject", X509_FLAG_NO_SUBJECT, 0},
1203         {"no_issuer", X509_FLAG_NO_ISSUER, 0},
1204         {"no_pubkey", X509_FLAG_NO_PUBKEY, 0},
1205         {"no_extensions", X509_FLAG_NO_EXTENSIONS, 0},
1206         {"no_sigdump", X509_FLAG_NO_SIGDUMP, 0},
1207         {"no_aux", X509_FLAG_NO_AUX, 0},
1208         {"no_attributes", X509_FLAG_NO_ATTRIBUTES, 0},
1209         {"ext_default", X509V3_EXT_DEFAULT, X509V3_EXT_UNKNOWN_MASK},
1210         {"ext_error", X509V3_EXT_ERROR_UNKNOWN, X509V3_EXT_UNKNOWN_MASK},
1211         {"ext_parse", X509V3_EXT_PARSE_UNKNOWN, X509V3_EXT_UNKNOWN_MASK},
1212         {"ext_dump", X509V3_EXT_DUMP_UNKNOWN, X509V3_EXT_UNKNOWN_MASK},
1213         {NULL, 0, 0}
1214     };
1215     return set_multi_opts(flags, arg, cert_tbl);
1216 }
1217
1218 int set_name_ex(unsigned long *flags, const char *arg)
1219 {
1220     static const NAME_EX_TBL ex_tbl[] = {
1221         {"esc_2253", ASN1_STRFLGS_ESC_2253, 0},
1222         {"esc_ctrl", ASN1_STRFLGS_ESC_CTRL, 0},
1223         {"esc_msb", ASN1_STRFLGS_ESC_MSB, 0},
1224         {"use_quote", ASN1_STRFLGS_ESC_QUOTE, 0},
1225         {"utf8", ASN1_STRFLGS_UTF8_CONVERT, 0},
1226         {"ignore_type", ASN1_STRFLGS_IGNORE_TYPE, 0},
1227         {"show_type", ASN1_STRFLGS_SHOW_TYPE, 0},
1228         {"dump_all", ASN1_STRFLGS_DUMP_ALL, 0},
1229         {"dump_nostr", ASN1_STRFLGS_DUMP_UNKNOWN, 0},
1230         {"dump_der", ASN1_STRFLGS_DUMP_DER, 0},
1231         {"compat", XN_FLAG_COMPAT, 0xffffffffL},
1232         {"sep_comma_plus", XN_FLAG_SEP_COMMA_PLUS, XN_FLAG_SEP_MASK},
1233         {"sep_comma_plus_space", XN_FLAG_SEP_CPLUS_SPC, XN_FLAG_SEP_MASK},
1234         {"sep_semi_plus_space", XN_FLAG_SEP_SPLUS_SPC, XN_FLAG_SEP_MASK},
1235         {"sep_multiline", XN_FLAG_SEP_MULTILINE, XN_FLAG_SEP_MASK},
1236         {"dn_rev", XN_FLAG_DN_REV, 0},
1237         {"nofname", XN_FLAG_FN_NONE, XN_FLAG_FN_MASK},
1238         {"sname", XN_FLAG_FN_SN, XN_FLAG_FN_MASK},
1239         {"lname", XN_FLAG_FN_LN, XN_FLAG_FN_MASK},
1240         {"align", XN_FLAG_FN_ALIGN, 0},
1241         {"oid", XN_FLAG_FN_OID, XN_FLAG_FN_MASK},
1242         {"space_eq", XN_FLAG_SPC_EQ, 0},
1243         {"dump_unknown", XN_FLAG_DUMP_UNKNOWN_FIELDS, 0},
1244         {"RFC2253", XN_FLAG_RFC2253, 0xffffffffL},
1245         {"oneline", XN_FLAG_ONELINE, 0xffffffffL},
1246         {"multiline", XN_FLAG_MULTILINE, 0xffffffffL},
1247         {"ca_default", XN_FLAG_MULTILINE, 0xffffffffL},
1248         {NULL, 0, 0}
1249     };
1250     if (set_multi_opts(flags, arg, ex_tbl) == 0)
1251         return 0;
1252     if ((*flags & XN_FLAG_SEP_MASK) == 0)
1253         *flags |= XN_FLAG_SEP_CPLUS_SPC;
1254     return 1;
1255 }
1256
1257 int set_ext_copy(int *copy_type, const char *arg)
1258 {
1259     if (!strcasecmp(arg, "none"))
1260         *copy_type = EXT_COPY_NONE;
1261     else if (!strcasecmp(arg, "copy"))
1262         *copy_type = EXT_COPY_ADD;
1263     else if (!strcasecmp(arg, "copyall"))
1264         *copy_type = EXT_COPY_ALL;
1265     else
1266         return 0;
1267     return 1;
1268 }
1269
1270 int copy_extensions(X509 *x, X509_REQ *req, int copy_type)
1271 {
1272     STACK_OF(X509_EXTENSION) *exts = NULL;
1273     X509_EXTENSION *ext, *tmpext;
1274     ASN1_OBJECT *obj;
1275     int i, idx, ret = 0;
1276     if (!x || !req || (copy_type == EXT_COPY_NONE))
1277         return 1;
1278     exts = X509_REQ_get_extensions(req);
1279
1280     for (i = 0; i < sk_X509_EXTENSION_num(exts); i++) {
1281         ext = sk_X509_EXTENSION_value(exts, i);
1282         obj = X509_EXTENSION_get_object(ext);
1283         idx = X509_get_ext_by_OBJ(x, obj, -1);
1284         /* Does extension exist? */
1285         if (idx != -1) {
1286             /* If normal copy don't override existing extension */
1287             if (copy_type == EXT_COPY_ADD)
1288                 continue;
1289             /* Delete all extensions of same type */
1290             do {
1291                 tmpext = X509_get_ext(x, idx);
1292                 X509_delete_ext(x, idx);
1293                 X509_EXTENSION_free(tmpext);
1294                 idx = X509_get_ext_by_OBJ(x, obj, -1);
1295             } while (idx != -1);
1296         }
1297         if (!X509_add_ext(x, ext, -1))
1298             goto end;
1299     }
1300
1301     ret = 1;
1302
1303  end:
1304
1305     sk_X509_EXTENSION_pop_free(exts, X509_EXTENSION_free);
1306
1307     return ret;
1308 }
1309
1310 static int set_multi_opts(unsigned long *flags, const char *arg,
1311                           const NAME_EX_TBL * in_tbl)
1312 {
1313     STACK_OF(CONF_VALUE) *vals;
1314     CONF_VALUE *val;
1315     int i, ret = 1;
1316     if (!arg)
1317         return 0;
1318     vals = X509V3_parse_list(arg);
1319     for (i = 0; i < sk_CONF_VALUE_num(vals); i++) {
1320         val = sk_CONF_VALUE_value(vals, i);
1321         if (!set_table_opts(flags, val->name, in_tbl))
1322             ret = 0;
1323     }
1324     sk_CONF_VALUE_pop_free(vals, X509V3_conf_free);
1325     return ret;
1326 }
1327
1328 static int set_table_opts(unsigned long *flags, const char *arg,
1329                           const NAME_EX_TBL * in_tbl)
1330 {
1331     char c;
1332     const NAME_EX_TBL *ptbl;
1333     c = arg[0];
1334
1335     if (c == '-') {
1336         c = 0;
1337         arg++;
1338     } else if (c == '+') {
1339         c = 1;
1340         arg++;
1341     } else
1342         c = 1;
1343
1344     for (ptbl = in_tbl; ptbl->name; ptbl++) {
1345         if (!strcasecmp(arg, ptbl->name)) {
1346             *flags &= ~ptbl->mask;
1347             if (c)
1348                 *flags |= ptbl->flag;
1349             else
1350                 *flags &= ~ptbl->flag;
1351             return 1;
1352         }
1353     }
1354     return 0;
1355 }
1356
1357 void print_name(BIO *out, const char *title, X509_NAME *nm,
1358                 unsigned long lflags)
1359 {
1360     char *buf;
1361     char mline = 0;
1362     int indent = 0;
1363
1364     if (title)
1365         BIO_puts(out, title);
1366     if ((lflags & XN_FLAG_SEP_MASK) == XN_FLAG_SEP_MULTILINE) {
1367         mline = 1;
1368         indent = 4;
1369     }
1370     if (lflags == XN_FLAG_COMPAT) {
1371         buf = X509_NAME_oneline(nm, 0, 0);
1372         BIO_puts(out, buf);
1373         BIO_puts(out, "\n");
1374         OPENSSL_free(buf);
1375     } else {
1376         if (mline)
1377             BIO_puts(out, "\n");
1378         X509_NAME_print_ex(out, nm, indent, lflags);
1379         BIO_puts(out, "\n");
1380     }
1381 }
1382
1383 X509_STORE *setup_verify(BIO *bp, char *CAfile, char *CApath)
1384 {
1385     X509_STORE *store;
1386     X509_LOOKUP *lookup;
1387     if (!(store = X509_STORE_new()))
1388         goto end;
1389     lookup = X509_STORE_add_lookup(store, X509_LOOKUP_file());
1390     if (lookup == NULL)
1391         goto end;
1392     if (CAfile) {
1393         if (!X509_LOOKUP_load_file(lookup, CAfile, X509_FILETYPE_PEM)) {
1394             BIO_printf(bp, "Error loading file %s\n", CAfile);
1395             goto end;
1396         }
1397     } else
1398         X509_LOOKUP_load_file(lookup, NULL, X509_FILETYPE_DEFAULT);
1399
1400     lookup = X509_STORE_add_lookup(store, X509_LOOKUP_hash_dir());
1401     if (lookup == NULL)
1402         goto end;
1403     if (CApath) {
1404         if (!X509_LOOKUP_add_dir(lookup, CApath, X509_FILETYPE_PEM)) {
1405             BIO_printf(bp, "Error loading directory %s\n", CApath);
1406             goto end;
1407         }
1408     } else
1409         X509_LOOKUP_add_dir(lookup, NULL, X509_FILETYPE_DEFAULT);
1410
1411     ERR_clear_error();
1412     return store;
1413  end:
1414     X509_STORE_free(store);
1415     return NULL;
1416 }
1417
1418 #ifndef OPENSSL_NO_ENGINE
1419 /* Try to load an engine in a shareable library */
1420 static ENGINE *try_load_engine(BIO *err, const char *engine, int debug)
1421 {
1422     ENGINE *e = ENGINE_by_id("dynamic");
1423     if (e) {
1424         if (!ENGINE_ctrl_cmd_string(e, "SO_PATH", engine, 0)
1425             || !ENGINE_ctrl_cmd_string(e, "LOAD", NULL, 0)) {
1426             ENGINE_free(e);
1427             e = NULL;
1428         }
1429     }
1430     return e;
1431 }
1432
1433 ENGINE *setup_engine(BIO *err, const char *engine, int debug)
1434 {
1435     ENGINE *e = NULL;
1436
1437     if (engine) {
1438         if (strcmp(engine, "auto") == 0) {
1439             BIO_printf(err, "enabling auto ENGINE support\n");
1440             ENGINE_register_all_complete();
1441             return NULL;
1442         }
1443         if ((e = ENGINE_by_id(engine)) == NULL
1444             && (e = try_load_engine(err, engine, debug)) == NULL) {
1445             BIO_printf(err, "invalid engine \"%s\"\n", engine);
1446             ERR_print_errors(err);
1447             return NULL;
1448         }
1449         if (debug) {
1450             ENGINE_ctrl(e, ENGINE_CTRL_SET_LOGSTREAM, 0, err, 0);
1451         }
1452         ENGINE_ctrl_cmd(e, "SET_USER_INTERFACE", 0, ui_method, 0, 1);
1453         if (!ENGINE_set_default(e, ENGINE_METHOD_ALL)) {
1454             BIO_printf(err, "can't use that engine\n");
1455             ERR_print_errors(err);
1456             ENGINE_free(e);
1457             return NULL;
1458         }
1459
1460         BIO_printf(err, "engine \"%s\" set.\n", ENGINE_get_id(e));
1461
1462         /* Free our "structural" reference. */
1463         ENGINE_free(e);
1464     }
1465     return e;
1466 }
1467 #endif
1468
1469 int load_config(BIO *err, CONF *cnf)
1470 {
1471     static int load_config_called = 0;
1472     if (load_config_called)
1473         return 1;
1474     load_config_called = 1;
1475     if (!cnf)
1476         cnf = config;
1477     if (!cnf)
1478         return 1;
1479
1480     OPENSSL_load_builtin_modules();
1481
1482     if (CONF_modules_load(cnf, NULL, 0) <= 0) {
1483         BIO_printf(err, "Error configuring OpenSSL\n");
1484         ERR_print_errors(err);
1485         return 0;
1486     }
1487     return 1;
1488 }
1489
1490 char *make_config_name()
1491 {
1492     const char *t = X509_get_default_cert_area();
1493     size_t len;
1494     char *p;
1495
1496     len = strlen(t) + strlen(OPENSSL_CONF) + 2;
1497     p = OPENSSL_malloc(len);
1498     if (p == NULL)
1499         return NULL;
1500     BUF_strlcpy(p, t, len);
1501 #ifndef OPENSSL_SYS_VMS
1502     BUF_strlcat(p, "/", len);
1503 #endif
1504     BUF_strlcat(p, OPENSSL_CONF, len);
1505
1506     return p;
1507 }
1508
1509 static unsigned long index_serial_hash(const OPENSSL_CSTRING *a)
1510 {
1511     const char *n;
1512
1513     n = a[DB_serial];
1514     while (*n == '0')
1515         n++;
1516     return (lh_strhash(n));
1517 }
1518
1519 static int index_serial_cmp(const OPENSSL_CSTRING *a,
1520                             const OPENSSL_CSTRING *b)
1521 {
1522     const char *aa, *bb;
1523
1524     for (aa = a[DB_serial]; *aa == '0'; aa++) ;
1525     for (bb = b[DB_serial]; *bb == '0'; bb++) ;
1526     return (strcmp(aa, bb));
1527 }
1528
1529 static int index_name_qual(char **a)
1530 {
1531     return (a[0][0] == 'V');
1532 }
1533
1534 static unsigned long index_name_hash(const OPENSSL_CSTRING *a)
1535 {
1536     return (lh_strhash(a[DB_name]));
1537 }
1538
1539 int index_name_cmp(const OPENSSL_CSTRING *a, const OPENSSL_CSTRING *b)
1540 {
1541     return (strcmp(a[DB_name], b[DB_name]));
1542 }
1543
1544 static IMPLEMENT_LHASH_HASH_FN(index_serial, OPENSSL_CSTRING)
1545 static IMPLEMENT_LHASH_COMP_FN(index_serial, OPENSSL_CSTRING)
1546 static IMPLEMENT_LHASH_HASH_FN(index_name, OPENSSL_CSTRING)
1547 static IMPLEMENT_LHASH_COMP_FN(index_name, OPENSSL_CSTRING)
1548 #undef BSIZE
1549 #define BSIZE 256
1550 BIGNUM *load_serial(char *serialfile, int create, ASN1_INTEGER **retai)
1551 {
1552     BIO *in = NULL;
1553     BIGNUM *ret = NULL;
1554     MS_STATIC char buf[1024];
1555     ASN1_INTEGER *ai = NULL;
1556
1557     ai = ASN1_INTEGER_new();
1558     if (ai == NULL)
1559         goto err;
1560
1561     if ((in = BIO_new(BIO_s_file())) == NULL) {
1562         ERR_print_errors(bio_err);
1563         goto err;
1564     }
1565
1566     if (BIO_read_filename(in, serialfile) <= 0) {
1567         if (!create) {
1568             perror(serialfile);
1569             goto err;
1570         } else {
1571             ret = BN_new();
1572             if (ret == NULL || !rand_serial(ret, ai))
1573                 BIO_printf(bio_err, "Out of memory\n");
1574         }
1575     } else {
1576         if (!a2i_ASN1_INTEGER(in, ai, buf, 1024)) {
1577             BIO_printf(bio_err, "unable to load number from %s\n",
1578                        serialfile);
1579             goto err;
1580         }
1581         ret = ASN1_INTEGER_to_BN(ai, NULL);
1582         if (ret == NULL) {
1583             BIO_printf(bio_err,
1584                        "error converting number from bin to BIGNUM\n");
1585             goto err;
1586         }
1587     }
1588
1589     if (ret && retai) {
1590         *retai = ai;
1591         ai = NULL;
1592     }
1593  err:
1594     if (in != NULL)
1595         BIO_free(in);
1596     if (ai != NULL)
1597         ASN1_INTEGER_free(ai);
1598     return (ret);
1599 }
1600
1601 int save_serial(char *serialfile, char *suffix, BIGNUM *serial,
1602                 ASN1_INTEGER **retai)
1603 {
1604     char buf[1][BSIZE];
1605     BIO *out = NULL;
1606     int ret = 0;
1607     ASN1_INTEGER *ai = NULL;
1608     int j;
1609
1610     if (suffix == NULL)
1611         j = strlen(serialfile);
1612     else
1613         j = strlen(serialfile) + strlen(suffix) + 1;
1614     if (j >= BSIZE) {
1615         BIO_printf(bio_err, "file name too long\n");
1616         goto err;
1617     }
1618
1619     if (suffix == NULL)
1620         BUF_strlcpy(buf[0], serialfile, BSIZE);
1621     else {
1622 #ifndef OPENSSL_SYS_VMS
1623         j = BIO_snprintf(buf[0], sizeof buf[0], "%s.%s", serialfile, suffix);
1624 #else
1625         j = BIO_snprintf(buf[0], sizeof buf[0], "%s-%s", serialfile, suffix);
1626 #endif
1627     }
1628 #ifdef RL_DEBUG
1629     BIO_printf(bio_err, "DEBUG: writing \"%s\"\n", buf[0]);
1630 #endif
1631     out = BIO_new(BIO_s_file());
1632     if (out == NULL) {
1633         ERR_print_errors(bio_err);
1634         goto err;
1635     }
1636     if (BIO_write_filename(out, buf[0]) <= 0) {
1637         perror(serialfile);
1638         goto err;
1639     }
1640
1641     if ((ai = BN_to_ASN1_INTEGER(serial, NULL)) == NULL) {
1642         BIO_printf(bio_err, "error converting serial to ASN.1 format\n");
1643         goto err;
1644     }
1645     i2a_ASN1_INTEGER(out, ai);
1646     BIO_puts(out, "\n");
1647     ret = 1;
1648     if (retai) {
1649         *retai = ai;
1650         ai = NULL;
1651     }
1652  err:
1653     if (out != NULL)
1654         BIO_free_all(out);
1655     if (ai != NULL)
1656         ASN1_INTEGER_free(ai);
1657     return (ret);
1658 }
1659
1660 int rotate_serial(char *serialfile, char *new_suffix, char *old_suffix)
1661 {
1662     char buf[5][BSIZE];
1663     int i, j;
1664
1665     i = strlen(serialfile) + strlen(old_suffix);
1666     j = strlen(serialfile) + strlen(new_suffix);
1667     if (i > j)
1668         j = i;
1669     if (j + 1 >= BSIZE) {
1670         BIO_printf(bio_err, "file name too long\n");
1671         goto err;
1672     }
1673 #ifndef OPENSSL_SYS_VMS
1674     j = BIO_snprintf(buf[0], sizeof buf[0], "%s.%s", serialfile, new_suffix);
1675 #else
1676     j = BIO_snprintf(buf[0], sizeof buf[0], "%s-%s", serialfile, new_suffix);
1677 #endif
1678 #ifndef OPENSSL_SYS_VMS
1679     j = BIO_snprintf(buf[1], sizeof buf[1], "%s.%s", serialfile, old_suffix);
1680 #else
1681     j = BIO_snprintf(buf[1], sizeof buf[1], "%s-%s", serialfile, old_suffix);
1682 #endif
1683 #ifdef RL_DEBUG
1684     BIO_printf(bio_err, "DEBUG: renaming \"%s\" to \"%s\"\n",
1685                serialfile, buf[1]);
1686 #endif
1687     if (rename(serialfile, buf[1]) < 0 && errno != ENOENT
1688 #ifdef ENOTDIR
1689         && errno != ENOTDIR
1690 #endif
1691         ) {
1692         BIO_printf(bio_err,
1693                    "unable to rename %s to %s\n", serialfile, buf[1]);
1694         perror("reason");
1695         goto err;
1696     }
1697 #ifdef RL_DEBUG
1698     BIO_printf(bio_err, "DEBUG: renaming \"%s\" to \"%s\"\n",
1699                buf[0], serialfile);
1700 #endif
1701     if (rename(buf[0], serialfile) < 0) {
1702         BIO_printf(bio_err,
1703                    "unable to rename %s to %s\n", buf[0], serialfile);
1704         perror("reason");
1705         rename(buf[1], serialfile);
1706         goto err;
1707     }
1708     return 1;
1709  err:
1710     return 0;
1711 }
1712
1713 int rand_serial(BIGNUM *b, ASN1_INTEGER *ai)
1714 {
1715     BIGNUM *btmp;
1716     int ret = 0;
1717     if (b)
1718         btmp = b;
1719     else
1720         btmp = BN_new();
1721
1722     if (!btmp)
1723         return 0;
1724
1725     if (!BN_pseudo_rand(btmp, SERIAL_RAND_BITS, 0, 0))
1726         goto error;
1727     if (ai && !BN_to_ASN1_INTEGER(btmp, ai))
1728         goto error;
1729
1730     ret = 1;
1731
1732  error:
1733
1734     if (!b)
1735         BN_free(btmp);
1736
1737     return ret;
1738 }
1739
1740 CA_DB *load_index(char *dbfile, DB_ATTR *db_attr)
1741 {
1742     CA_DB *retdb = NULL;
1743     TXT_DB *tmpdb = NULL;
1744     BIO *in = BIO_new(BIO_s_file());
1745     CONF *dbattr_conf = NULL;
1746     char buf[1][BSIZE];
1747     long errorline = -1;
1748
1749     if (in == NULL) {
1750         ERR_print_errors(bio_err);
1751         goto err;
1752     }
1753     if (BIO_read_filename(in, dbfile) <= 0) {
1754         perror(dbfile);
1755         BIO_printf(bio_err, "unable to open '%s'\n", dbfile);
1756         goto err;
1757     }
1758     if ((tmpdb = TXT_DB_read(in, DB_NUMBER)) == NULL)
1759         goto err;
1760
1761 #ifndef OPENSSL_SYS_VMS
1762     BIO_snprintf(buf[0], sizeof buf[0], "%s.attr", dbfile);
1763 #else
1764     BIO_snprintf(buf[0], sizeof buf[0], "%s-attr", dbfile);
1765 #endif
1766     dbattr_conf = NCONF_new(NULL);
1767     if (NCONF_load(dbattr_conf, buf[0], &errorline) <= 0) {
1768         if (errorline > 0) {
1769             BIO_printf(bio_err,
1770                        "error on line %ld of db attribute file '%s'\n",
1771                        errorline, buf[0]);
1772             goto err;
1773         } else {
1774             NCONF_free(dbattr_conf);
1775             dbattr_conf = NULL;
1776         }
1777     }
1778
1779     if ((retdb = OPENSSL_malloc(sizeof(CA_DB))) == NULL) {
1780         fprintf(stderr, "Out of memory\n");
1781         goto err;
1782     }
1783
1784     retdb->db = tmpdb;
1785     tmpdb = NULL;
1786     if (db_attr)
1787         retdb->attributes = *db_attr;
1788     else {
1789         retdb->attributes.unique_subject = 1;
1790     }
1791
1792     if (dbattr_conf) {
1793         char *p = NCONF_get_string(dbattr_conf, NULL, "unique_subject");
1794         if (p) {
1795 #ifdef RL_DEBUG
1796             BIO_printf(bio_err,
1797                        "DEBUG[load_index]: unique_subject = \"%s\"\n", p);
1798 #endif
1799             retdb->attributes.unique_subject = parse_yesno(p, 1);
1800         }
1801     }
1802
1803  err:
1804     if (dbattr_conf)
1805         NCONF_free(dbattr_conf);
1806     if (tmpdb)
1807         TXT_DB_free(tmpdb);
1808     if (in)
1809         BIO_free_all(in);
1810     return retdb;
1811 }
1812
1813 int index_index(CA_DB *db)
1814 {
1815     if (!TXT_DB_create_index(db->db, DB_serial, NULL,
1816                              LHASH_HASH_FN(index_serial),
1817                              LHASH_COMP_FN(index_serial))) {
1818         BIO_printf(bio_err,
1819                    "error creating serial number index:(%ld,%ld,%ld)\n",
1820                    db->db->error, db->db->arg1, db->db->arg2);
1821         return 0;
1822     }
1823
1824     if (db->attributes.unique_subject
1825         && !TXT_DB_create_index(db->db, DB_name, index_name_qual,
1826                                 LHASH_HASH_FN(index_name),
1827                                 LHASH_COMP_FN(index_name))) {
1828         BIO_printf(bio_err, "error creating name index:(%ld,%ld,%ld)\n",
1829                    db->db->error, db->db->arg1, db->db->arg2);
1830         return 0;
1831     }
1832     return 1;
1833 }
1834
1835 int save_index(const char *dbfile, const char *suffix, CA_DB *db)
1836 {
1837     char buf[3][BSIZE];
1838     BIO *out = BIO_new(BIO_s_file());
1839     int j;
1840
1841     if (out == NULL) {
1842         ERR_print_errors(bio_err);
1843         goto err;
1844     }
1845
1846     j = strlen(dbfile) + strlen(suffix);
1847     if (j + 6 >= BSIZE) {
1848         BIO_printf(bio_err, "file name too long\n");
1849         goto err;
1850     }
1851 #ifndef OPENSSL_SYS_VMS
1852     j = BIO_snprintf(buf[2], sizeof buf[2], "%s.attr", dbfile);
1853 #else
1854     j = BIO_snprintf(buf[2], sizeof buf[2], "%s-attr", dbfile);
1855 #endif
1856 #ifndef OPENSSL_SYS_VMS
1857     j = BIO_snprintf(buf[1], sizeof buf[1], "%s.attr.%s", dbfile, suffix);
1858 #else
1859     j = BIO_snprintf(buf[1], sizeof buf[1], "%s-attr-%s", dbfile, suffix);
1860 #endif
1861 #ifndef OPENSSL_SYS_VMS
1862     j = BIO_snprintf(buf[0], sizeof buf[0], "%s.%s", dbfile, suffix);
1863 #else
1864     j = BIO_snprintf(buf[0], sizeof buf[0], "%s-%s", dbfile, suffix);
1865 #endif
1866 #ifdef RL_DEBUG
1867     BIO_printf(bio_err, "DEBUG: writing \"%s\"\n", buf[0]);
1868 #endif
1869     if (BIO_write_filename(out, buf[0]) <= 0) {
1870         perror(dbfile);
1871         BIO_printf(bio_err, "unable to open '%s'\n", dbfile);
1872         goto err;
1873     }
1874     j = TXT_DB_write(out, db->db);
1875     if (j <= 0)
1876         goto err;
1877
1878     BIO_free(out);
1879
1880     out = BIO_new(BIO_s_file());
1881 #ifdef RL_DEBUG
1882     BIO_printf(bio_err, "DEBUG: writing \"%s\"\n", buf[1]);
1883 #endif
1884     if (BIO_write_filename(out, buf[1]) <= 0) {
1885         perror(buf[2]);
1886         BIO_printf(bio_err, "unable to open '%s'\n", buf[2]);
1887         goto err;
1888     }
1889     BIO_printf(out, "unique_subject = %s\n",
1890                db->attributes.unique_subject ? "yes" : "no");
1891     BIO_free(out);
1892
1893     return 1;
1894  err:
1895     return 0;
1896 }
1897
1898 int rotate_index(const char *dbfile, const char *new_suffix,
1899                  const char *old_suffix)
1900 {
1901     char buf[5][BSIZE];
1902     int i, j;
1903
1904     i = strlen(dbfile) + strlen(old_suffix);
1905     j = strlen(dbfile) + strlen(new_suffix);
1906     if (i > j)
1907         j = i;
1908     if (j + 6 >= BSIZE) {
1909         BIO_printf(bio_err, "file name too long\n");
1910         goto err;
1911     }
1912 #ifndef OPENSSL_SYS_VMS
1913     j = BIO_snprintf(buf[4], sizeof buf[4], "%s.attr", dbfile);
1914 #else
1915     j = BIO_snprintf(buf[4], sizeof buf[4], "%s-attr", dbfile);
1916 #endif
1917 #ifndef OPENSSL_SYS_VMS
1918     j = BIO_snprintf(buf[2], sizeof buf[2], "%s.attr.%s", dbfile, new_suffix);
1919 #else
1920     j = BIO_snprintf(buf[2], sizeof buf[2], "%s-attr-%s", dbfile, new_suffix);
1921 #endif
1922 #ifndef OPENSSL_SYS_VMS
1923     j = BIO_snprintf(buf[0], sizeof buf[0], "%s.%s", dbfile, new_suffix);
1924 #else
1925     j = BIO_snprintf(buf[0], sizeof buf[0], "%s-%s", dbfile, new_suffix);
1926 #endif
1927 #ifndef OPENSSL_SYS_VMS
1928     j = BIO_snprintf(buf[1], sizeof buf[1], "%s.%s", dbfile, old_suffix);
1929 #else
1930     j = BIO_snprintf(buf[1], sizeof buf[1], "%s-%s", dbfile, old_suffix);
1931 #endif
1932 #ifndef OPENSSL_SYS_VMS
1933     j = BIO_snprintf(buf[3], sizeof buf[3], "%s.attr.%s", dbfile, old_suffix);
1934 #else
1935     j = BIO_snprintf(buf[3], sizeof buf[3], "%s-attr-%s", dbfile, old_suffix);
1936 #endif
1937 #ifdef RL_DEBUG
1938     BIO_printf(bio_err, "DEBUG: renaming \"%s\" to \"%s\"\n", dbfile, buf[1]);
1939 #endif
1940     if (rename(dbfile, buf[1]) < 0 && errno != ENOENT
1941 #ifdef ENOTDIR
1942         && errno != ENOTDIR
1943 #endif
1944         ) {
1945         BIO_printf(bio_err, "unable to rename %s to %s\n", dbfile, buf[1]);
1946         perror("reason");
1947         goto err;
1948     }
1949 #ifdef RL_DEBUG
1950     BIO_printf(bio_err, "DEBUG: renaming \"%s\" to \"%s\"\n", buf[0], dbfile);
1951 #endif
1952     if (rename(buf[0], dbfile) < 0) {
1953         BIO_printf(bio_err, "unable to rename %s to %s\n", buf[0], dbfile);
1954         perror("reason");
1955         rename(buf[1], dbfile);
1956         goto err;
1957     }
1958 #ifdef RL_DEBUG
1959     BIO_printf(bio_err, "DEBUG: renaming \"%s\" to \"%s\"\n", buf[4], buf[3]);
1960 #endif
1961     if (rename(buf[4], buf[3]) < 0 && errno != ENOENT
1962 #ifdef ENOTDIR
1963         && errno != ENOTDIR
1964 #endif
1965         ) {
1966         BIO_printf(bio_err, "unable to rename %s to %s\n", buf[4], buf[3]);
1967         perror("reason");
1968         rename(dbfile, buf[0]);
1969         rename(buf[1], dbfile);
1970         goto err;
1971     }
1972 #ifdef RL_DEBUG
1973     BIO_printf(bio_err, "DEBUG: renaming \"%s\" to \"%s\"\n", buf[2], buf[4]);
1974 #endif
1975     if (rename(buf[2], buf[4]) < 0) {
1976         BIO_printf(bio_err, "unable to rename %s to %s\n", buf[2], buf[4]);
1977         perror("reason");
1978         rename(buf[3], buf[4]);
1979         rename(dbfile, buf[0]);
1980         rename(buf[1], dbfile);
1981         goto err;
1982     }
1983     return 1;
1984  err:
1985     return 0;
1986 }
1987
1988 void free_index(CA_DB *db)
1989 {
1990     if (db) {
1991         if (db->db)
1992             TXT_DB_free(db->db);
1993         OPENSSL_free(db);
1994     }
1995 }
1996
1997 int parse_yesno(const char *str, int def)
1998 {
1999     int ret = def;
2000     if (str) {
2001         switch (*str) {
2002         case 'f':              /* false */
2003         case 'F':              /* FALSE */
2004         case 'n':              /* no */
2005         case 'N':              /* NO */
2006         case '0':              /* 0 */
2007             ret = 0;
2008             break;
2009         case 't':              /* true */
2010         case 'T':              /* TRUE */
2011         case 'y':              /* yes */
2012         case 'Y':              /* YES */
2013         case '1':              /* 1 */
2014             ret = 1;
2015             break;
2016         default:
2017             ret = def;
2018             break;
2019         }
2020     }
2021     return ret;
2022 }
2023
2024 /*
2025  * subject is expected to be in the format /type0=value0/type1=value1/type2=...
2026  * where characters may be escaped by \
2027  */
2028 X509_NAME *parse_name(char *subject, long chtype, int multirdn)
2029 {
2030     size_t buflen = strlen(subject) + 1; /* to copy the types and values
2031                                           * into. due to escaping, the copy
2032                                           * can only become shorter */
2033     char *buf = OPENSSL_malloc(buflen);
2034     size_t max_ne = buflen / 2 + 1; /* maximum number of name elements */
2035     char **ne_types = OPENSSL_malloc(max_ne * sizeof(char *));
2036     char **ne_values = OPENSSL_malloc(max_ne * sizeof(char *));
2037     int *mval = OPENSSL_malloc(max_ne * sizeof(int));
2038
2039     char *sp = subject, *bp = buf;
2040     int i, ne_num = 0;
2041
2042     X509_NAME *n = NULL;
2043     int nid;
2044
2045     if (!buf || !ne_types || !ne_values || !mval) {
2046         BIO_printf(bio_err, "malloc error\n");
2047         goto error;
2048     }
2049
2050     if (*subject != '/') {
2051         BIO_printf(bio_err, "Subject does not start with '/'.\n");
2052         goto error;
2053     }
2054     sp++;                       /* skip leading / */
2055
2056     /* no multivalued RDN by default */
2057     mval[ne_num] = 0;
2058
2059     while (*sp) {
2060         /* collect type */
2061         ne_types[ne_num] = bp;
2062         while (*sp) {
2063             if (*sp == '\\') {  /* is there anything to escape in the
2064                                  * type...? */
2065                 if (*++sp)
2066                     *bp++ = *sp++;
2067                 else {
2068                     BIO_printf(bio_err,
2069                                "escape character at end of string\n");
2070                     goto error;
2071                 }
2072             } else if (*sp == '=') {
2073                 sp++;
2074                 *bp++ = '\0';
2075                 break;
2076             } else
2077                 *bp++ = *sp++;
2078         }
2079         if (!*sp) {
2080             BIO_printf(bio_err,
2081                        "end of string encountered while processing type of subject name element #%d\n",
2082                        ne_num);
2083             goto error;
2084         }
2085         ne_values[ne_num] = bp;
2086         while (*sp) {
2087             if (*sp == '\\') {
2088                 if (*++sp)
2089                     *bp++ = *sp++;
2090                 else {
2091                     BIO_printf(bio_err,
2092                                "escape character at end of string\n");
2093                     goto error;
2094                 }
2095             } else if (*sp == '/') {
2096                 sp++;
2097                 /* no multivalued RDN by default */
2098                 mval[ne_num + 1] = 0;
2099                 break;
2100             } else if (*sp == '+' && multirdn) {
2101                 /*
2102                  * a not escaped + signals a mutlivalued RDN
2103                  */
2104                 sp++;
2105                 mval[ne_num + 1] = -1;
2106                 break;
2107             } else
2108                 *bp++ = *sp++;
2109         }
2110         *bp++ = '\0';
2111         ne_num++;
2112     }
2113
2114     if (!(n = X509_NAME_new()))
2115         goto error;
2116
2117     for (i = 0; i < ne_num; i++) {
2118         if ((nid = OBJ_txt2nid(ne_types[i])) == NID_undef) {
2119             BIO_printf(bio_err,
2120                        "Subject Attribute %s has no known NID, skipped\n",
2121                        ne_types[i]);
2122             continue;
2123         }
2124
2125         if (!*ne_values[i]) {
2126             BIO_printf(bio_err,
2127                        "No value provided for Subject Attribute %s, skipped\n",
2128                        ne_types[i]);
2129             continue;
2130         }
2131
2132         if (!X509_NAME_add_entry_by_NID
2133             (n, nid, chtype, (unsigned char *)ne_values[i], -1, -1, mval[i]))
2134             goto error;
2135     }
2136
2137     OPENSSL_free(ne_values);
2138     OPENSSL_free(ne_types);
2139     OPENSSL_free(buf);
2140     OPENSSL_free(mval);
2141     return n;
2142
2143  error:
2144     X509_NAME_free(n);
2145     if (ne_values)
2146         OPENSSL_free(ne_values);
2147     if (ne_types)
2148         OPENSSL_free(ne_types);
2149     if (mval)
2150         OPENSSL_free(mval);
2151     if (buf)
2152         OPENSSL_free(buf);
2153     return NULL;
2154 }
2155
2156 int args_verify(char ***pargs, int *pargc,
2157                 int *badarg, BIO *err, X509_VERIFY_PARAM **pm)
2158 {
2159     ASN1_OBJECT *otmp = NULL;
2160     unsigned long flags = 0;
2161     int i;
2162     int purpose = 0, depth = -1;
2163     char **oldargs = *pargs;
2164     char *arg = **pargs, *argn = (*pargs)[1];
2165     time_t at_time = 0;
2166     if (!strcmp(arg, "-policy")) {
2167         if (!argn)
2168             *badarg = 1;
2169         else {
2170             otmp = OBJ_txt2obj(argn, 0);
2171             if (!otmp) {
2172                 BIO_printf(err, "Invalid Policy \"%s\"\n", argn);
2173                 *badarg = 1;
2174             }
2175         }
2176         (*pargs)++;
2177     } else if (strcmp(arg, "-purpose") == 0) {
2178         X509_PURPOSE *xptmp;
2179         if (!argn)
2180             *badarg = 1;
2181         else {
2182             i = X509_PURPOSE_get_by_sname(argn);
2183             if (i < 0) {
2184                 BIO_printf(err, "unrecognized purpose\n");
2185                 *badarg = 1;
2186             } else {
2187                 xptmp = X509_PURPOSE_get0(i);
2188                 purpose = X509_PURPOSE_get_id(xptmp);
2189             }
2190         }
2191         (*pargs)++;
2192     } else if (strcmp(arg, "-verify_depth") == 0) {
2193         if (!argn)
2194             *badarg = 1;
2195         else {
2196             depth = atoi(argn);
2197             if (depth < 0) {
2198                 BIO_printf(err, "invalid depth\n");
2199                 *badarg = 1;
2200             }
2201         }
2202         (*pargs)++;
2203     } else if (strcmp(arg, "-attime") == 0) {
2204         if (!argn)
2205             *badarg = 1;
2206         else {
2207             long timestamp;
2208             /*
2209              * interpret the -attime argument as seconds since Epoch
2210              */
2211             if (sscanf(argn, "%li", &timestamp) != 1) {
2212                 BIO_printf(bio_err, "Error parsing timestamp %s\n", argn);
2213                 *badarg = 1;
2214             }
2215             /* on some platforms time_t may be a float */
2216             at_time = (time_t)timestamp;
2217         }
2218         (*pargs)++;
2219     } else if (!strcmp(arg, "-ignore_critical"))
2220         flags |= X509_V_FLAG_IGNORE_CRITICAL;
2221     else if (!strcmp(arg, "-issuer_checks"))
2222         flags |= X509_V_FLAG_CB_ISSUER_CHECK;
2223     else if (!strcmp(arg, "-crl_check"))
2224         flags |= X509_V_FLAG_CRL_CHECK;
2225     else if (!strcmp(arg, "-crl_check_all"))
2226         flags |= X509_V_FLAG_CRL_CHECK | X509_V_FLAG_CRL_CHECK_ALL;
2227     else if (!strcmp(arg, "-policy_check"))
2228         flags |= X509_V_FLAG_POLICY_CHECK;
2229     else if (!strcmp(arg, "-explicit_policy"))
2230         flags |= X509_V_FLAG_EXPLICIT_POLICY;
2231     else if (!strcmp(arg, "-inhibit_any"))
2232         flags |= X509_V_FLAG_INHIBIT_ANY;
2233     else if (!strcmp(arg, "-inhibit_map"))
2234         flags |= X509_V_FLAG_INHIBIT_MAP;
2235     else if (!strcmp(arg, "-x509_strict"))
2236         flags |= X509_V_FLAG_X509_STRICT;
2237     else if (!strcmp(arg, "-extended_crl"))
2238         flags |= X509_V_FLAG_EXTENDED_CRL_SUPPORT;
2239     else if (!strcmp(arg, "-use_deltas"))
2240         flags |= X509_V_FLAG_USE_DELTAS;
2241     else if (!strcmp(arg, "-policy_print"))
2242         flags |= X509_V_FLAG_NOTIFY_POLICY;
2243     else if (!strcmp(arg, "-check_ss_sig"))
2244         flags |= X509_V_FLAG_CHECK_SS_SIGNATURE;
2245     else if (!strcmp(arg, "-no_alt_chains"))
2246         flags |= X509_V_FLAG_NO_ALT_CHAINS;
2247     else
2248         return 0;
2249
2250     if (*badarg) {
2251         if (*pm)
2252             X509_VERIFY_PARAM_free(*pm);
2253         *pm = NULL;
2254         goto end;
2255     }
2256
2257     if (!*pm && !(*pm = X509_VERIFY_PARAM_new())) {
2258         *badarg = 1;
2259         goto end;
2260     }
2261
2262     if (otmp)
2263         X509_VERIFY_PARAM_add0_policy(*pm, otmp);
2264     if (flags)
2265         X509_VERIFY_PARAM_set_flags(*pm, flags);
2266
2267     if (purpose)
2268         X509_VERIFY_PARAM_set_purpose(*pm, purpose);
2269
2270     if (depth >= 0)
2271         X509_VERIFY_PARAM_set_depth(*pm, depth);
2272
2273     if (at_time)
2274         X509_VERIFY_PARAM_set_time(*pm, at_time);
2275
2276  end:
2277
2278     (*pargs)++;
2279
2280     if (pargc)
2281         *pargc -= *pargs - oldargs;
2282
2283     return 1;
2284
2285 }
2286
2287 /*
2288  * Read whole contents of a BIO into an allocated memory buffer and return
2289  * it.
2290  */
2291
2292 int bio_to_mem(unsigned char **out, int maxlen, BIO *in)
2293 {
2294     BIO *mem;
2295     int len, ret;
2296     unsigned char tbuf[1024];
2297     mem = BIO_new(BIO_s_mem());
2298     if (!mem)
2299         return -1;
2300     for (;;) {
2301         if ((maxlen != -1) && maxlen < 1024)
2302             len = maxlen;
2303         else
2304             len = 1024;
2305         len = BIO_read(in, tbuf, len);
2306         if (len <= 0)
2307             break;
2308         if (BIO_write(mem, tbuf, len) != len) {
2309             BIO_free(mem);
2310             return -1;
2311         }
2312         maxlen -= len;
2313
2314         if (maxlen == 0)
2315             break;
2316     }
2317     ret = BIO_get_mem_data(mem, (char **)out);
2318     BIO_set_flags(mem, BIO_FLAGS_MEM_RDONLY);
2319     BIO_free(mem);
2320     return ret;
2321 }
2322
2323 int pkey_ctrl_string(EVP_PKEY_CTX *ctx, char *value)
2324 {
2325     int rv;
2326     char *stmp, *vtmp = NULL;
2327     stmp = BUF_strdup(value);
2328     if (!stmp)
2329         return -1;
2330     vtmp = strchr(stmp, ':');
2331     if (vtmp) {
2332         *vtmp = 0;
2333         vtmp++;
2334     }
2335     rv = EVP_PKEY_CTX_ctrl_str(ctx, stmp, vtmp);
2336     OPENSSL_free(stmp);
2337     return rv;
2338 }
2339
2340 static void nodes_print(BIO *out, const char *name,
2341                         STACK_OF(X509_POLICY_NODE) *nodes)
2342 {
2343     X509_POLICY_NODE *node;
2344     int i;
2345     BIO_printf(out, "%s Policies:", name);
2346     if (nodes) {
2347         BIO_puts(out, "\n");
2348         for (i = 0; i < sk_X509_POLICY_NODE_num(nodes); i++) {
2349             node = sk_X509_POLICY_NODE_value(nodes, i);
2350             X509_POLICY_NODE_print(out, node, 2);
2351         }
2352     } else
2353         BIO_puts(out, " <empty>\n");
2354 }
2355
2356 void policies_print(BIO *out, X509_STORE_CTX *ctx)
2357 {
2358     X509_POLICY_TREE *tree;
2359     int explicit_policy;
2360     int free_out = 0;
2361     if (out == NULL) {
2362         out = BIO_new_fp(stderr, BIO_NOCLOSE);
2363         free_out = 1;
2364     }
2365     tree = X509_STORE_CTX_get0_policy_tree(ctx);
2366     explicit_policy = X509_STORE_CTX_get_explicit_policy(ctx);
2367
2368     BIO_printf(out, "Require explicit Policy: %s\n",
2369                explicit_policy ? "True" : "False");
2370
2371     nodes_print(out, "Authority", X509_policy_tree_get0_policies(tree));
2372     nodes_print(out, "User", X509_policy_tree_get0_user_policies(tree));
2373     if (free_out)
2374         BIO_free(out);
2375 }
2376
2377 #if !defined(OPENSSL_NO_JPAKE) && !defined(OPENSSL_NO_PSK)
2378
2379 static JPAKE_CTX *jpake_init(const char *us, const char *them,
2380                              const char *secret)
2381 {
2382     BIGNUM *p = NULL;
2383     BIGNUM *g = NULL;
2384     BIGNUM *q = NULL;
2385     BIGNUM *bnsecret = BN_new();
2386     JPAKE_CTX *ctx;
2387
2388     /* Use a safe prime for p (that we found earlier) */
2389     BN_hex2bn(&p,
2390               "F9E5B365665EA7A05A9C534502780FEE6F1AB5BD4F49947FD036DBD7E905269AF46EF28B0FC07487EE4F5D20FB3C0AF8E700F3A2FA3414970CBED44FEDFF80CE78D800F184BB82435D137AADA2C6C16523247930A63B85661D1FC817A51ACD96168E95898A1F83A79FFB529368AA7833ABD1B0C3AEDDB14D2E1A2F71D99F763F");
2391     g = BN_new();
2392     BN_set_word(g, 2);
2393     q = BN_new();
2394     BN_rshift1(q, p);
2395
2396     BN_bin2bn((const unsigned char *)secret, strlen(secret), bnsecret);
2397
2398     ctx = JPAKE_CTX_new(us, them, p, g, q, bnsecret);
2399     BN_free(bnsecret);
2400     BN_free(q);
2401     BN_free(g);
2402     BN_free(p);
2403
2404     return ctx;
2405 }
2406
2407 static void jpake_send_part(BIO *conn, const JPAKE_STEP_PART *p)
2408 {
2409     BN_print(conn, p->gx);
2410     BIO_puts(conn, "\n");
2411     BN_print(conn, p->zkpx.gr);
2412     BIO_puts(conn, "\n");
2413     BN_print(conn, p->zkpx.b);
2414     BIO_puts(conn, "\n");
2415 }
2416
2417 static void jpake_send_step1(BIO *bconn, JPAKE_CTX *ctx)
2418 {
2419     JPAKE_STEP1 s1;
2420
2421     JPAKE_STEP1_init(&s1);
2422     JPAKE_STEP1_generate(&s1, ctx);
2423     jpake_send_part(bconn, &s1.p1);
2424     jpake_send_part(bconn, &s1.p2);
2425     (void)BIO_flush(bconn);
2426     JPAKE_STEP1_release(&s1);
2427 }
2428
2429 static void jpake_send_step2(BIO *bconn, JPAKE_CTX *ctx)
2430 {
2431     JPAKE_STEP2 s2;
2432
2433     JPAKE_STEP2_init(&s2);
2434     JPAKE_STEP2_generate(&s2, ctx);
2435     jpake_send_part(bconn, &s2);
2436     (void)BIO_flush(bconn);
2437     JPAKE_STEP2_release(&s2);
2438 }
2439
2440 static void jpake_send_step3a(BIO *bconn, JPAKE_CTX *ctx)
2441 {
2442     JPAKE_STEP3A s3a;
2443
2444     JPAKE_STEP3A_init(&s3a);
2445     JPAKE_STEP3A_generate(&s3a, ctx);
2446     BIO_write(bconn, s3a.hhk, sizeof s3a.hhk);
2447     (void)BIO_flush(bconn);
2448     JPAKE_STEP3A_release(&s3a);
2449 }
2450
2451 static void jpake_send_step3b(BIO *bconn, JPAKE_CTX *ctx)
2452 {
2453     JPAKE_STEP3B s3b;
2454
2455     JPAKE_STEP3B_init(&s3b);
2456     JPAKE_STEP3B_generate(&s3b, ctx);
2457     BIO_write(bconn, s3b.hk, sizeof s3b.hk);
2458     (void)BIO_flush(bconn);
2459     JPAKE_STEP3B_release(&s3b);
2460 }
2461
2462 static void readbn(BIGNUM **bn, BIO *bconn)
2463 {
2464     char buf[10240];
2465     int l;
2466
2467     l = BIO_gets(bconn, buf, sizeof buf);
2468     assert(l > 0);
2469     assert(buf[l - 1] == '\n');
2470     buf[l - 1] = '\0';
2471     BN_hex2bn(bn, buf);
2472 }
2473
2474 static void jpake_receive_part(JPAKE_STEP_PART *p, BIO *bconn)
2475 {
2476     readbn(&p->gx, bconn);
2477     readbn(&p->zkpx.gr, bconn);
2478     readbn(&p->zkpx.b, bconn);
2479 }
2480
2481 static void jpake_receive_step1(JPAKE_CTX *ctx, BIO *bconn)
2482 {
2483     JPAKE_STEP1 s1;
2484
2485     JPAKE_STEP1_init(&s1);
2486     jpake_receive_part(&s1.p1, bconn);
2487     jpake_receive_part(&s1.p2, bconn);
2488     if (!JPAKE_STEP1_process(ctx, &s1)) {
2489         ERR_print_errors(bio_err);
2490         exit(1);
2491     }
2492     JPAKE_STEP1_release(&s1);
2493 }
2494
2495 static void jpake_receive_step2(JPAKE_CTX *ctx, BIO *bconn)
2496 {
2497     JPAKE_STEP2 s2;
2498
2499     JPAKE_STEP2_init(&s2);
2500     jpake_receive_part(&s2, bconn);
2501     if (!JPAKE_STEP2_process(ctx, &s2)) {
2502         ERR_print_errors(bio_err);
2503         exit(1);
2504     }
2505     JPAKE_STEP2_release(&s2);
2506 }
2507
2508 static void jpake_receive_step3a(JPAKE_CTX *ctx, BIO *bconn)
2509 {
2510     JPAKE_STEP3A s3a;
2511     int l;
2512
2513     JPAKE_STEP3A_init(&s3a);
2514     l = BIO_read(bconn, s3a.hhk, sizeof s3a.hhk);
2515     assert(l == sizeof s3a.hhk);
2516     if (!JPAKE_STEP3A_process(ctx, &s3a)) {
2517         ERR_print_errors(bio_err);
2518         exit(1);
2519     }
2520     JPAKE_STEP3A_release(&s3a);
2521 }
2522
2523 static void jpake_receive_step3b(JPAKE_CTX *ctx, BIO *bconn)
2524 {
2525     JPAKE_STEP3B s3b;
2526     int l;
2527
2528     JPAKE_STEP3B_init(&s3b);
2529     l = BIO_read(bconn, s3b.hk, sizeof s3b.hk);
2530     assert(l == sizeof s3b.hk);
2531     if (!JPAKE_STEP3B_process(ctx, &s3b)) {
2532         ERR_print_errors(bio_err);
2533         exit(1);
2534     }
2535     JPAKE_STEP3B_release(&s3b);
2536 }
2537
2538 void jpake_client_auth(BIO *out, BIO *conn, const char *secret)
2539 {
2540     JPAKE_CTX *ctx;
2541     BIO *bconn;
2542
2543     BIO_puts(out, "Authenticating with JPAKE\n");
2544
2545     ctx = jpake_init("client", "server", secret);
2546
2547     bconn = BIO_new(BIO_f_buffer());
2548     BIO_push(bconn, conn);
2549
2550     jpake_send_step1(bconn, ctx);
2551     jpake_receive_step1(ctx, bconn);
2552     jpake_send_step2(bconn, ctx);
2553     jpake_receive_step2(ctx, bconn);
2554     jpake_send_step3a(bconn, ctx);
2555     jpake_receive_step3b(ctx, bconn);
2556
2557     BIO_puts(out, "JPAKE authentication succeeded, setting PSK\n");
2558
2559     psk_key = BN_bn2hex(JPAKE_get_shared_key(ctx));
2560
2561     BIO_pop(bconn);
2562     BIO_free(bconn);
2563
2564     JPAKE_CTX_free(ctx);
2565 }
2566
2567 void jpake_server_auth(BIO *out, BIO *conn, const char *secret)
2568 {
2569     JPAKE_CTX *ctx;
2570     BIO *bconn;
2571
2572     BIO_puts(out, "Authenticating with JPAKE\n");
2573
2574     ctx = jpake_init("server", "client", secret);
2575
2576     bconn = BIO_new(BIO_f_buffer());
2577     BIO_push(bconn, conn);
2578
2579     jpake_receive_step1(ctx, bconn);
2580     jpake_send_step1(bconn, ctx);
2581     jpake_receive_step2(ctx, bconn);
2582     jpake_send_step2(bconn, ctx);
2583     jpake_receive_step3a(ctx, bconn);
2584     jpake_send_step3b(bconn, ctx);
2585
2586     BIO_puts(out, "JPAKE authentication succeeded, setting PSK\n");
2587
2588     psk_key = BN_bn2hex(JPAKE_get_shared_key(ctx));
2589
2590     BIO_pop(bconn);
2591     BIO_free(bconn);
2592
2593     JPAKE_CTX_free(ctx);
2594 }
2595
2596 #endif
2597
2598 #if !defined(OPENSSL_NO_TLSEXT) && !defined(OPENSSL_NO_NEXTPROTONEG)
2599 /*-
2600  * next_protos_parse parses a comma separated list of strings into a string
2601  * in a format suitable for passing to SSL_CTX_set_next_protos_advertised.
2602  *   outlen: (output) set to the length of the resulting buffer on success.
2603  *   err: (maybe NULL) on failure, an error message line is written to this BIO.
2604  *   in: a NUL termianted string like "abc,def,ghi"
2605  *
2606  *   returns: a malloced buffer or NULL on failure.
2607  */
2608 unsigned char *next_protos_parse(unsigned short *outlen, const char *in)
2609 {
2610     size_t len;
2611     unsigned char *out;
2612     size_t i, start = 0;
2613
2614     len = strlen(in);
2615     if (len >= 65535)
2616         return NULL;
2617
2618     out = OPENSSL_malloc(strlen(in) + 1);
2619     if (!out)
2620         return NULL;
2621
2622     for (i = 0; i <= len; ++i) {
2623         if (i == len || in[i] == ',') {
2624             if (i - start > 255) {
2625                 OPENSSL_free(out);
2626                 return NULL;
2627             }
2628             out[start] = i - start;
2629             start = i + 1;
2630         } else
2631             out[i + 1] = in[i];
2632     }
2633
2634     *outlen = len + 1;
2635     return out;
2636 }
2637 #endif                          /* !OPENSSL_NO_TLSEXT &&
2638                                  * !OPENSSL_NO_NEXTPROTONEG */
2639
2640 /*
2641  * Platform-specific sections
2642  */
2643 #if defined(_WIN32)
2644 # ifdef fileno
2645 #  undef fileno
2646 #  define fileno(a) (int)_fileno(a)
2647 # endif
2648
2649 # include <windows.h>
2650 # include <tchar.h>
2651
2652 static int WIN32_rename(const char *from, const char *to)
2653 {
2654     TCHAR *tfrom = NULL, *tto;
2655     DWORD err;
2656     int ret = 0;
2657
2658     if (sizeof(TCHAR) == 1) {
2659         tfrom = (TCHAR *)from;
2660         tto = (TCHAR *)to;
2661     } else {                    /* UNICODE path */
2662
2663         size_t i, flen = strlen(from) + 1, tlen = strlen(to) + 1;
2664         tfrom = (TCHAR *)malloc(sizeof(TCHAR) * (flen + tlen));
2665         if (tfrom == NULL)
2666             goto err;
2667         tto = tfrom + flen;
2668 # if !defined(_WIN32_WCE) || _WIN32_WCE>=101
2669         if (!MultiByteToWideChar(CP_ACP, 0, from, flen, (WCHAR *)tfrom, flen))
2670 # endif
2671             for (i = 0; i < flen; i++)
2672                 tfrom[i] = (TCHAR)from[i];
2673 # if !defined(_WIN32_WCE) || _WIN32_WCE>=101
2674         if (!MultiByteToWideChar(CP_ACP, 0, to, tlen, (WCHAR *)tto, tlen))
2675 # endif
2676             for (i = 0; i < tlen; i++)
2677                 tto[i] = (TCHAR)to[i];
2678     }
2679
2680     if (MoveFile(tfrom, tto))
2681         goto ok;
2682     err = GetLastError();
2683     if (err == ERROR_ALREADY_EXISTS || err == ERROR_FILE_EXISTS) {
2684         if (DeleteFile(tto) && MoveFile(tfrom, tto))
2685             goto ok;
2686         err = GetLastError();
2687     }
2688     if (err == ERROR_FILE_NOT_FOUND || err == ERROR_PATH_NOT_FOUND)
2689         errno = ENOENT;
2690     else if (err == ERROR_ACCESS_DENIED)
2691         errno = EACCES;
2692     else
2693         errno = EINVAL;         /* we could map more codes... */
2694  err:
2695     ret = -1;
2696  ok:
2697     if (tfrom != NULL && tfrom != (TCHAR *)from)
2698         free(tfrom);
2699     return ret;
2700 }
2701 #endif
2702
2703 /* app_tminterval section */
2704 #if defined(_WIN32)
2705 double app_tminterval(int stop, int usertime)
2706 {
2707     FILETIME now;
2708     double ret = 0;
2709     static ULARGE_INTEGER tmstart;
2710     static int warning = 1;
2711 # ifdef _WIN32_WINNT
2712     static HANDLE proc = NULL;
2713
2714     if (proc == NULL) {
2715         if (check_winnt())
2716             proc = OpenProcess(PROCESS_QUERY_INFORMATION, FALSE,
2717                                GetCurrentProcessId());
2718         if (proc == NULL)
2719             proc = (HANDLE) - 1;
2720     }
2721
2722     if (usertime && proc != (HANDLE) - 1) {
2723         FILETIME junk;
2724         GetProcessTimes(proc, &junk, &junk, &junk, &now);
2725     } else
2726 # endif
2727     {
2728         SYSTEMTIME systime;
2729
2730         if (usertime && warning) {
2731             BIO_printf(bio_err, "To get meaningful results, run "
2732                        "this program on idle system.\n");
2733             warning = 0;
2734         }
2735         GetSystemTime(&systime);
2736         SystemTimeToFileTime(&systime, &now);
2737     }
2738
2739     if (stop == TM_START) {
2740         tmstart.u.LowPart = now.dwLowDateTime;
2741         tmstart.u.HighPart = now.dwHighDateTime;
2742     } else {
2743         ULARGE_INTEGER tmstop;
2744
2745         tmstop.u.LowPart = now.dwLowDateTime;
2746         tmstop.u.HighPart = now.dwHighDateTime;
2747
2748         ret = (__int64)(tmstop.QuadPart - tmstart.QuadPart) * 1e-7;
2749     }
2750
2751     return (ret);
2752 }
2753
2754 #elif defined(OPENSSL_SYS_NETWARE)
2755 # include <time.h>
2756
2757 double app_tminterval(int stop, int usertime)
2758 {
2759     double ret = 0;
2760     static clock_t tmstart;
2761     static int warning = 1;
2762
2763     if (usertime && warning) {
2764         BIO_printf(bio_err, "To get meaningful results, run "
2765                    "this program on idle system.\n");
2766         warning = 0;
2767     }
2768
2769     if (stop == TM_START)
2770         tmstart = clock();
2771     else
2772         ret = (clock() - tmstart) / (double)CLOCKS_PER_SEC;
2773
2774     return (ret);
2775 }
2776
2777 #elif defined(OPENSSL_SYSTEM_VXWORKS)
2778 # include <time.h>
2779
2780 double app_tminterval(int stop, int usertime)
2781 {
2782     double ret = 0;
2783 # ifdef CLOCK_REALTIME
2784     static struct timespec tmstart;
2785     struct timespec now;
2786 # else
2787     static unsigned long tmstart;
2788     unsigned long now;
2789 # endif
2790     static int warning = 1;
2791
2792     if (usertime && warning) {
2793         BIO_printf(bio_err, "To get meaningful results, run "
2794                    "this program on idle system.\n");
2795         warning = 0;
2796     }
2797 # ifdef CLOCK_REALTIME
2798     clock_gettime(CLOCK_REALTIME, &now);
2799     if (stop == TM_START)
2800         tmstart = now;
2801     else
2802         ret = ((now.tv_sec + now.tv_nsec * 1e-9)
2803                - (tmstart.tv_sec + tmstart.tv_nsec * 1e-9));
2804 # else
2805     now = tickGet();
2806     if (stop == TM_START)
2807         tmstart = now;
2808     else
2809         ret = (now - tmstart) / (double)sysClkRateGet();
2810 # endif
2811     return (ret);
2812 }
2813
2814 #elif defined(OPENSSL_SYSTEM_VMS)
2815 # include <time.h>
2816 # include <times.h>
2817
2818 double app_tminterval(int stop, int usertime)
2819 {
2820     static clock_t tmstart;
2821     double ret = 0;
2822     clock_t now;
2823 # ifdef __TMS
2824     struct tms rus;
2825
2826     now = times(&rus);
2827     if (usertime)
2828         now = rus.tms_utime;
2829 # else
2830     if (usertime)
2831         now = clock();          /* sum of user and kernel times */
2832     else {
2833         struct timeval tv;
2834         gettimeofday(&tv, NULL);
2835         now = (clock_t)((unsigned long long)tv.tv_sec * CLK_TCK +
2836                         (unsigned long long)tv.tv_usec * (1000000 / CLK_TCK)
2837             );
2838     }
2839 # endif
2840     if (stop == TM_START)
2841         tmstart = now;
2842     else
2843         ret = (now - tmstart) / (double)(CLK_TCK);
2844
2845     return (ret);
2846 }
2847
2848 #elif defined(_SC_CLK_TCK)      /* by means of unistd.h */
2849 # include <sys/times.h>
2850
2851 double app_tminterval(int stop, int usertime)
2852 {
2853     double ret = 0;
2854     struct tms rus;
2855     clock_t now = times(&rus);
2856     static clock_t tmstart;
2857
2858     if (usertime)
2859         now = rus.tms_utime;
2860
2861     if (stop == TM_START)
2862         tmstart = now;
2863     else {
2864         long int tck = sysconf(_SC_CLK_TCK);
2865         ret = (now - tmstart) / (double)tck;
2866     }
2867
2868     return (ret);
2869 }
2870
2871 #else
2872 # include <sys/time.h>
2873 # include <sys/resource.h>
2874
2875 double app_tminterval(int stop, int usertime)
2876 {
2877     double ret = 0;
2878     struct rusage rus;
2879     struct timeval now;
2880     static struct timeval tmstart;
2881
2882     if (usertime)
2883         getrusage(RUSAGE_SELF, &rus), now = rus.ru_utime;
2884     else
2885         gettimeofday(&now, NULL);
2886
2887     if (stop == TM_START)
2888         tmstart = now;
2889     else
2890         ret = ((now.tv_sec + now.tv_usec * 1e-6)
2891                - (tmstart.tv_sec + tmstart.tv_usec * 1e-6));
2892
2893     return ret;
2894 }
2895 #endif
2896
2897 /* app_isdir section */
2898 #ifdef _WIN32
2899 int app_isdir(const char *name)
2900 {
2901     HANDLE hList;
2902     WIN32_FIND_DATA FileData;
2903 # if defined(UNICODE) || defined(_UNICODE)
2904     size_t i, len_0 = strlen(name) + 1;
2905
2906     if (len_0 > sizeof(FileData.cFileName) / sizeof(FileData.cFileName[0]))
2907         return -1;
2908
2909 #  if !defined(_WIN32_WCE) || _WIN32_WCE>=101
2910     if (!MultiByteToWideChar
2911         (CP_ACP, 0, name, len_0, FileData.cFileName, len_0))
2912 #  endif
2913         for (i = 0; i < len_0; i++)
2914             FileData.cFileName[i] = (WCHAR)name[i];
2915
2916     hList = FindFirstFile(FileData.cFileName, &FileData);
2917 # else
2918     hList = FindFirstFile(name, &FileData);
2919 # endif
2920     if (hList == INVALID_HANDLE_VALUE)
2921         return -1;
2922     FindClose(hList);
2923     return ((FileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0);
2924 }
2925 #else
2926 # include <sys/stat.h>
2927 # ifndef S_ISDIR
2928 #  if defined(_S_IFMT) && defined(_S_IFDIR)
2929 #   define S_ISDIR(a)   (((a) & _S_IFMT) == _S_IFDIR)
2930 #  else
2931 #   define S_ISDIR(a)   (((a) & S_IFMT) == S_IFDIR)
2932 #  endif
2933 # endif
2934
2935 int app_isdir(const char *name)
2936 {
2937 # if defined(S_ISDIR)
2938     struct stat st;
2939
2940     if (stat(name, &st) == 0)
2941         return S_ISDIR(st.st_mode);
2942     else
2943         return -1;
2944 # else
2945     return -1;
2946 # endif
2947 }
2948 #endif
2949
2950 /* raw_read|write section */
2951 #if defined(_WIN32) && defined(STD_INPUT_HANDLE)
2952 int raw_read_stdin(void *buf, int siz)
2953 {
2954     DWORD n;
2955     if (ReadFile(GetStdHandle(STD_INPUT_HANDLE), buf, siz, &n, NULL))
2956         return (n);
2957     else
2958         return (-1);
2959 }
2960 #else
2961 int raw_read_stdin(void *buf, int siz)
2962 {
2963     return read(fileno(stdin), buf, siz);
2964 }
2965 #endif
2966
2967 #if defined(_WIN32) && defined(STD_OUTPUT_HANDLE)
2968 int raw_write_stdout(const void *buf, int siz)
2969 {
2970     DWORD n;
2971     if (WriteFile(GetStdHandle(STD_OUTPUT_HANDLE), buf, siz, &n, NULL))
2972         return (n);
2973     else
2974         return (-1);
2975 }
2976 #else
2977 int raw_write_stdout(const void *buf, int siz)
2978 {
2979     return write(fileno(stdout), buf, siz);
2980 }
2981 #endif