crypto/openssl/apps/openssl.c

   1 /* apps/openssl.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-2006 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 #include <stdio.h>
 113 #include <string.h>
 114 #include <stdlib.h>
 115 #define OPENSSL_C               /* tells apps.h to use complete
 116                                  * apps_startup() */
 117 #include "apps.h"
 118 #include <openssl/bio.h>
 119 #include <openssl/crypto.h>
 120 #include <openssl/lhash.h>
 121 #include <openssl/conf.h>
 122 #include <openssl/x509.h>
 123 #include <openssl/pem.h>
 124 #include <openssl/ssl.h>
 125 #ifndef OPENSSL_NO_ENGINE
 126 # include <openssl/engine.h>
 127 #endif
 128 #define USE_SOCKETS             /* needed for the _O_BINARY defs in the MS
 129                                  * world */
 130 #include "progs.h"
 131 #include "s_apps.h"
 132 #include <openssl/err.h>
 133
 134 /*
 135  * The LHASH callbacks ("hash" & "cmp") have been replaced by functions with
 136  * the base prototypes (we cast each variable inside the function to the
 137  * required type of "FUNCTION*"). This removes the necessity for
 138  * macro-generated wrapper functions.
 139  */
 140
 141 /* static unsigned long MS_CALLBACK hash(FUNCTION *a); */
 142 static unsigned long MS_CALLBACK hash(const void *a_void);
 143 /* static int MS_CALLBACK cmp(FUNCTION *a,FUNCTION *b); */
 144 static int MS_CALLBACK cmp(const void *a_void, const void *b_void);
 145 static LHASH *prog_init(void);
 146 static int do_cmd(LHASH *prog, int argc, char *argv[]);
 147 char *default_config_file = NULL;
 148
 149 /* Make sure there is only one when MONOLITH is defined */
 150 #ifdef MONOLITH
 151 CONF *config = NULL;
 152 BIO *bio_err = NULL;
 153 int in_FIPS_mode = 0;
 154 #endif
 155
 156 static void lock_dbg_cb(int mode, int type, const char *file, int line)
 157 {
 158     static int modes[CRYPTO_NUM_LOCKS]; /* = {0, 0, ... } */
 159     const char *errstr = NULL;
 160     int rw;
 161
 162     rw = mode & (CRYPTO_READ | CRYPTO_WRITE);
 163     if (!((rw == CRYPTO_READ) || (rw == CRYPTO_WRITE))) {
 164         errstr = "invalid mode";
 165         goto err;
 166     }
 167
 168     if (type < 0 || type >= CRYPTO_NUM_LOCKS) {
 169         errstr = "type out of bounds";
 170         goto err;
 171     }
 172
 173     if (mode & CRYPTO_LOCK) {
 174         if (modes[type]) {
 175             errstr = "already locked";
 176             /*
 177              * must not happen in a single-threaded program (would deadlock)
 178              */
 179             goto err;
 180         }
 181
 182         modes[type] = rw;
 183     } else if (mode & CRYPTO_UNLOCK) {
 184         if (!modes[type]) {
 185             errstr = "not locked";
 186             goto err;
 187         }
 188
 189         if (modes[type] != rw) {
 190             errstr = (rw == CRYPTO_READ) ?
 191                 "CRYPTO_r_unlock on write lock" :
 192                 "CRYPTO_w_unlock on read lock";
 193         }
 194
 195         modes[type] = 0;
 196     } else {
 197         errstr = "invalid mode";
 198         goto err;
 199     }
 200
 201  err:
 202     if (errstr) {
 203         /* we cannot use bio_err here */
 204         fprintf(stderr,
 205                 "openssl (lock_dbg_cb): %s (mode=%d, type=%d) at %s:%d\n",
 206                 errstr, mode, type, file, line);
 207     }
 208 }
 209
 210 int main(int Argc, char *Argv[])
 211 {
 212     ARGS arg;
 213 #define PROG_NAME_SIZE  39
 214     char pname[PROG_NAME_SIZE + 1];
 215     FUNCTION f, *fp;
 216     MS_STATIC const char *prompt;
 217     MS_STATIC char buf[1024];
 218     char *to_free = NULL;
 219     int n, i, ret = 0;
 220     int argc;
 221     char **argv, *p;
 222     LHASH *prog = NULL;
 223     long errline;
 224
 225     arg.data = NULL;
 226     arg.count = 0;
 227
 228     in_FIPS_mode = 0;
 229
 230     if (getenv("OPENSSL_FIPS")) {
 231 #ifdef OPENSSL_FIPS
 232         if (!FIPS_mode_set(1)) {
 233             ERR_load_crypto_strings();
 234             ERR_print_errors(BIO_new_fp(stderr, BIO_NOCLOSE));
 235             EXIT(1);
 236         }
 237         in_FIPS_mode = 1;
 238 #else
 239         fprintf(stderr, "FIPS mode not supported.\n");
 240         EXIT(1);
 241 #endif
 242     }
 243
 244     if (bio_err == NULL)
 245         if ((bio_err = BIO_new(BIO_s_file())) != NULL)
 246             BIO_set_fp(bio_err, stderr, BIO_NOCLOSE | BIO_FP_TEXT);
 247
 248     if (getenv("OPENSSL_DEBUG_MEMORY") != NULL) { /* if not defined, use
 249                                                    * compiled-in library
 250                                                    * defaults */
 251         if (!(0 == strcmp(getenv("OPENSSL_DEBUG_MEMORY"), "off"))) {
 252             CRYPTO_malloc_debug_init();
 253             CRYPTO_set_mem_debug_options(V_CRYPTO_MDEBUG_ALL);
 254         } else {
 255             /* OPENSSL_DEBUG_MEMORY=off */
 256             CRYPTO_set_mem_debug_functions(0, 0, 0, 0, 0);
 257         }
 258     }
 259     CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON);
 260
 261 #if 0
 262     if (getenv("OPENSSL_DEBUG_LOCKING") != NULL)
 263 #endif
 264     {
 265         CRYPTO_set_locking_callback(lock_dbg_cb);
 266     }
 267
 268     apps_startup();
 269
 270     /* Lets load up our environment a little */
 271     p = getenv("OPENSSL_CONF");
 272     if (p == NULL)
 273         p = getenv("SSLEAY_CONF");
 274     if (p == NULL)
 275         p = to_free = make_config_name();
 276
 277     default_config_file = p;
 278
 279     config = NCONF_new(NULL);
 280     i = NCONF_load(config, p, &errline);
 281     if (i == 0) {
 282         NCONF_free(config);
 283         config = NULL;
 284         ERR_clear_error();
 285     }
 286
 287     prog = prog_init();
 288
 289     /* first check the program name */
 290     program_name(Argv[0], pname, sizeof pname);
 291
 292     f.name = pname;
 293     fp = (FUNCTION *) lh_retrieve(prog, &f);
 294     if (fp != NULL) {
 295         Argv[0] = pname;
 296         ret = fp->func(Argc, Argv);
 297         goto end;
 298     }
 299
 300     /*
 301      * ok, now check that there are not arguments, if there are, run with
 302      * them, shifting the ssleay off the front
 303      */
 304     if (Argc != 1) {
 305         Argc--;
 306         Argv++;
 307         ret = do_cmd(prog, Argc, Argv);
 308         if (ret < 0)
 309             ret = 0;
 310         goto end;
 311     }
 312
 313     /* ok, lets enter the old 'OpenSSL>' mode */
 314
 315     for (;;) {
 316         ret = 0;
 317         p = buf;
 318         n = sizeof buf;
 319         i = 0;
 320         for (;;) {
 321             p[0] = '\0';
 322             if (i++)
 323                 prompt = ">";
 324             else
 325                 prompt = "OpenSSL> ";
 326             fputs(prompt, stdout);
 327             fflush(stdout);
 328             if (!fgets(p, n, stdin))
 329                 goto end;
 330             if (p[0] == '\0')
 331                 goto end;
 332             i = strlen(p);
 333             if (i <= 1)
 334                 break;
 335             if (p[i - 2] != '\\')
 336                 break;
 337             i -= 2;
 338             p += i;
 339             n -= i;
 340         }
 341         if (!chopup_args(&arg, buf, &argc, &argv))
 342             break;
 343
 344         ret = do_cmd(prog, argc, argv);
 345         if (ret < 0) {
 346             ret = 0;
 347             goto end;
 348         }
 349         if (ret != 0)
 350             BIO_printf(bio_err, "error in %s\n", argv[0]);
 351         (void)BIO_flush(bio_err);
 352     }
 353     BIO_printf(bio_err, "bad exit\n");
 354     ret = 1;
 355  end:
 356     if (to_free)
 357         OPENSSL_free(to_free);
 358     if (config != NULL) {
 359         NCONF_free(config);
 360         config = NULL;
 361     }
 362     if (prog != NULL)
 363         lh_free(prog);
 364     if (arg.data != NULL)
 365         OPENSSL_free(arg.data);
 366
 367     apps_shutdown();
 368
 369     CRYPTO_mem_leaks(bio_err);
 370     if (bio_err != NULL) {
 371         BIO_free(bio_err);
 372         bio_err = NULL;
 373     }
 374     OPENSSL_EXIT(ret);
 375 }
 376
 377 #define LIST_STANDARD_COMMANDS "list-standard-commands"
 378 #define LIST_MESSAGE_DIGEST_COMMANDS "list-message-digest-commands"
 379 #define LIST_CIPHER_COMMANDS "list-cipher-commands"
 380
 381 static int do_cmd(LHASH *prog, int argc, char *argv[])
 382 {
 383     FUNCTION f, *fp;
 384     int i, ret = 1, tp, nl;
 385
 386     if ((argc <= 0) || (argv[0] == NULL)) {
 387         ret = 0;
 388         goto end;
 389     }
 390     f.name = argv[0];
 391     fp = (FUNCTION *) lh_retrieve(prog, &f);
 392     if (fp != NULL) {
 393         ret = fp->func(argc, argv);
 394     } else if ((strncmp(argv[0], "no-", 3)) == 0) {
 395         BIO *bio_stdout = BIO_new_fp(stdout, BIO_NOCLOSE);
 396 #ifdef OPENSSL_SYS_VMS
 397         {
 398             BIO *tmpbio = BIO_new(BIO_f_linebuffer());
 399             bio_stdout = BIO_push(tmpbio, bio_stdout);
 400         }
 401 #endif
 402         f.name = argv[0] + 3;
 403         ret = (lh_retrieve(prog, &f) != NULL);
 404         if (!ret)
 405             BIO_printf(bio_stdout, "%s\n", argv[0]);
 406         else
 407             BIO_printf(bio_stdout, "%s\n", argv[0] + 3);
 408         BIO_free_all(bio_stdout);
 409         goto end;
 410     } else if ((strcmp(argv[0], "quit") == 0) ||
 411                (strcmp(argv[0], "q") == 0) ||
 412                (strcmp(argv[0], "exit") == 0) ||
 413                (strcmp(argv[0], "bye") == 0)) {
 414         ret = -1;
 415         goto end;
 416     } else if ((strcmp(argv[0], LIST_STANDARD_COMMANDS) == 0) ||
 417                (strcmp(argv[0], LIST_MESSAGE_DIGEST_COMMANDS) == 0) ||
 418                (strcmp(argv[0], LIST_CIPHER_COMMANDS) == 0)) {
 419         int list_type;
 420         BIO *bio_stdout;
 421
 422         if (strcmp(argv[0], LIST_STANDARD_COMMANDS) == 0)
 423             list_type = FUNC_TYPE_GENERAL;
 424         else if (strcmp(argv[0], LIST_MESSAGE_DIGEST_COMMANDS) == 0)
 425             list_type = FUNC_TYPE_MD;
 426         else                    /* strcmp(argv[0],LIST_CIPHER_COMMANDS) == 0 */
 427             list_type = FUNC_TYPE_CIPHER;
 428         bio_stdout = BIO_new_fp(stdout, BIO_NOCLOSE);
 429 #ifdef OPENSSL_SYS_VMS
 430         {
 431             BIO *tmpbio = BIO_new(BIO_f_linebuffer());
 432             bio_stdout = BIO_push(tmpbio, bio_stdout);
 433         }
 434 #endif
 435
 436         for (fp = functions; fp->name != NULL; fp++)
 437             if (fp->type == list_type)
 438                 BIO_printf(bio_stdout, "%s\n", fp->name);
 439         BIO_free_all(bio_stdout);
 440         ret = 0;
 441         goto end;
 442     } else {
 443         BIO_printf(bio_err, "openssl:Error: '%s' is an invalid command.\n",
 444                    argv[0]);
 445         BIO_printf(bio_err, "\nStandard commands");
 446         i = 0;
 447         tp = 0;
 448         for (fp = functions; fp->name != NULL; fp++) {
 449             nl = 0;
 450 #ifdef OPENSSL_NO_CAMELLIA
 451             if (((i++) % 5) == 0)
 452 #else
 453             if (((i++) % 4) == 0)
 454 #endif
 455             {
 456                 BIO_printf(bio_err, "\n");
 457                 nl = 1;
 458             }
 459             if (fp->type != tp) {
 460                 tp = fp->type;
 461                 if (!nl)
 462                     BIO_printf(bio_err, "\n");
 463                 if (tp == FUNC_TYPE_MD) {
 464                     i = 1;
 465                     BIO_printf(bio_err,
 466                                "\nMessage Digest commands (see the `dgst' command for more details)\n");
 467                 } else if (tp == FUNC_TYPE_CIPHER) {
 468                     i = 1;
 469                     BIO_printf(bio_err,
 470                                "\nCipher commands (see the `enc' command for more details)\n");
 471                 }
 472             }
 473 #ifdef OPENSSL_NO_CAMELLIA
 474             BIO_printf(bio_err, "%-15s", fp->name);
 475 #else
 476             BIO_printf(bio_err, "%-18s", fp->name);
 477 #endif
 478         }
 479         BIO_printf(bio_err, "\n\n");
 480         ret = 0;
 481     }
 482  end:
 483     return (ret);
 484 }
 485
 486 static int SortFnByName(const void *_f1, const void *_f2)
 487 {
 488     const FUNCTION *f1 = _f1;
 489     const FUNCTION *f2 = _f2;
 490
 491     if (f1->type != f2->type)
 492         return f1->type - f2->type;
 493     return strcmp(f1->name, f2->name);
 494 }
 495
 496 static LHASH *prog_init(void)
 497 {
 498     LHASH *ret;
 499     FUNCTION *f;
 500     size_t i;
 501
 502     /* Purely so it looks nice when the user hits ? */
 503     for (i = 0, f = functions; f->name != NULL; ++f, ++i) ;
 504     qsort(functions, i, sizeof *functions, SortFnByName);
 505
 506     if ((ret = lh_new(hash, cmp)) == NULL)
 507         return (NULL);
 508
 509     for (f = functions; f->name != NULL; f++)
 510         lh_insert(ret, f);
 511     return (ret);
 512 }
 513
 514 /* static int MS_CALLBACK cmp(FUNCTION *a, FUNCTION *b) */
 515 static int MS_CALLBACK cmp(const void *a_void, const void *b_void)
 516 {
 517     return (strncmp(((const FUNCTION *)a_void)->name,
 518                     ((const FUNCTION *)b_void)->name, 8));
 519 }
 520
 521 /* static unsigned long MS_CALLBACK hash(FUNCTION *a) */
 522 static unsigned long MS_CALLBACK hash(const void *a_void)
 523 {
 524     return (lh_strhash(((const FUNCTION *)a_void)->name));
 525 }