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