lib/vtls/openssl.c

   1 /***************************************************************************
   2  *                                  _   _ ____  _
   3  *  Project                     ___| | | |  _ \| |
   4  *                             / __| | | | |_) | |
   5  *                            | (__| |_| |  _ <| |___
   6  *                             \___|\___/|_| \_\_____|
   7  *
   8  * Copyright (C) 1998 - 2014, Daniel Stenberg, <daniel@haxx.se>, et al.
   9  *
  10  * This software is licensed as described in the file COPYING, which
  11  * you should have received as part of this distribution. The terms
  12  * are also available at http://curl.haxx.se/docs/copyright.html.
  13  *
  14  * You may opt to use, copy, modify, merge, publish, distribute and/or sell
  15  * copies of the Software, and permit persons to whom the Software is
  16  * furnished to do so, under the terms of the COPYING file.
  17  *
  18  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  19  * KIND, either express or implied.
  20  *
  21  ***************************************************************************/
  22
  23 /*
  24  * Source file for all OpenSSL-specific code for the TLS/SSL layer. No code
  25  * but vtls.c should ever call or use these functions.
  26  */
  27
  28 /*
  29  * The original SSLeay-using code for curl was written by Linas Vepstas and
  30  * Sampo Kellomaki 1998.
  31  */
  32
  33 #include "curl_setup.h"
  34
  35 #ifdef HAVE_LIMITS_H
  36 #include <limits.h>
  37 #endif
  38
  39 #include "urldata.h"
  40 #include "sendf.h"
  41 #include "formdata.h" /* for the boundary function */
  42 #include "url.h" /* for the ssl config check function */
  43 #include "inet_pton.h"
  44 #include "openssl.h"
  45 #include "connect.h"
  46 #include "slist.h"
  47 #include "strequal.h"
  48 #include "select.h"
  49 #include "vtls.h"
  50 #include "rawstr.h"
  51 #include "hostcheck.h"
  52
  53 #define _MPRINTF_REPLACE /* use the internal *printf() functions */
  54 #include <curl/mprintf.h>
  55
  56 #ifdef USE_SSLEAY
  57
  58 #ifdef USE_OPENSSL
  59 #include <openssl/rand.h>
  60 #include <openssl/x509v3.h>
  61 #include <openssl/dsa.h>
  62 #include <openssl/dh.h>
  63 #include <openssl/err.h>
  64 #include <openssl/md5.h>
  65 #else
  66 #include <rand.h>
  67 #include <x509v3.h>
  68 #include <md5.h>
  69 #endif
  70
  71 #include "warnless.h"
  72 #include "curl_memory.h"
  73 #include "non-ascii.h" /* for Curl_convert_from_utf8 prototype */
  74
  75 /* The last #include file should be: */
  76 #include "memdebug.h"
  77
  78 #ifndef OPENSSL_VERSION_NUMBER
  79 #error "OPENSSL_VERSION_NUMBER not defined"
  80 #endif
  81
  82 #if OPENSSL_VERSION_NUMBER >= 0x0090581fL
  83 #define HAVE_SSL_GET1_SESSION 1
  84 #else
  85 #undef HAVE_SSL_GET1_SESSION
  86 #endif
  87
  88 #if OPENSSL_VERSION_NUMBER >= 0x00904100L
  89 #define HAVE_USERDATA_IN_PWD_CALLBACK 1
  90 #else
  91 #undef HAVE_USERDATA_IN_PWD_CALLBACK
  92 #endif
  93
  94 #if OPENSSL_VERSION_NUMBER >= 0x00907001L
  95 /* ENGINE_load_private_key() takes four arguments */
  96 #define HAVE_ENGINE_LOAD_FOUR_ARGS
  97 #include <openssl/ui.h>
  98 #else
  99 /* ENGINE_load_private_key() takes three arguments */
 100 #undef HAVE_ENGINE_LOAD_FOUR_ARGS
 101 #endif
 102
 103 #if (OPENSSL_VERSION_NUMBER >= 0x00903001L) && defined(HAVE_OPENSSL_PKCS12_H)
 104 /* OpenSSL has PKCS 12 support */
 105 #define HAVE_PKCS12_SUPPORT
 106 #else
 107 /* OpenSSL/SSLEay does not have PKCS12 support */
 108 #undef HAVE_PKCS12_SUPPORT
 109 #endif
 110
 111 #if OPENSSL_VERSION_NUMBER >= 0x00906001L
 112 #define HAVE_ERR_ERROR_STRING_N 1
 113 #endif
 114
 115 #if OPENSSL_VERSION_NUMBER >= 0x00909000L
 116 #define SSL_METHOD_QUAL const
 117 #else
 118 #define SSL_METHOD_QUAL
 119 #endif
 120
 121 #if OPENSSL_VERSION_NUMBER >= 0x00907000L
 122 /* 0.9.6 didn't have X509_STORE_set_flags() */
 123 #define HAVE_X509_STORE_SET_FLAGS 1
 124 #else
 125 #define X509_STORE_set_flags(x,y) Curl_nop_stmt
 126 #endif
 127
 128 #if OPENSSL_VERSION_NUMBER >= 0x10000000L
 129 #define HAVE_ERR_REMOVE_THREAD_STATE 1
 130 #endif
 131
 132 #ifndef HAVE_SSLV2_CLIENT_METHOD
 133 #undef OPENSSL_NO_SSL2 /* undef first to avoid compiler warnings */
 134 #define OPENSSL_NO_SSL2
 135 #endif
 136
 137 /*
 138  * Number of bytes to read from the random number seed file. This must be
 139  * a finite value (because some entropy "files" like /dev/urandom have
 140  * an infinite length), but must be large enough to provide enough
 141  * entopy to properly seed OpenSSL's PRNG.
 142  */
 143 #define RAND_LOAD_LENGTH 1024
 144
 145 #ifndef HAVE_USERDATA_IN_PWD_CALLBACK
 146 static char global_passwd[64];
 147 #endif
 148
 149 static int passwd_callback(char *buf, int num, int encrypting
 150 #ifdef HAVE_USERDATA_IN_PWD_CALLBACK
 151                            /* This was introduced in 0.9.4, we can set this
 152                               using SSL_CTX_set_default_passwd_cb_userdata()
 153                               */
 154                            , void *global_passwd
 155 #endif
 156                            )
 157 {
 158   DEBUGASSERT(0 == encrypting);
 159
 160   if(!encrypting) {
 161     int klen = curlx_uztosi(strlen((char *)global_passwd));
 162     if(num > klen) {
 163       memcpy(buf, global_passwd, klen+1);
 164       return klen;
 165     }
 166   }
 167   return 0;
 168 }
 169
 170 /*
 171  * rand_enough() is a function that returns TRUE if we have seeded the random
 172  * engine properly. We use some preprocessor magic to provide a seed_enough()
 173  * macro to use, just to prevent a compiler warning on this function if we
 174  * pass in an argument that is never used.
 175  */
 176
 177 #ifdef HAVE_RAND_STATUS
 178 #define seed_enough(x) rand_enough()
 179 static bool rand_enough(void)
 180 {
 181   return (0 != RAND_status()) ? TRUE : FALSE;
 182 }
 183 #else
 184 #define seed_enough(x) rand_enough(x)
 185 static bool rand_enough(int nread)
 186 {
 187   /* this is a very silly decision to make */
 188   return (nread > 500) ? TRUE : FALSE;
 189 }
 190 #endif
 191
 192 static int ossl_seed(struct SessionHandle *data)
 193 {
 194   char *buf = data->state.buffer; /* point to the big buffer */
 195   int nread=0;
 196
 197   /* Q: should we add support for a random file name as a libcurl option?
 198      A: Yes, it is here */
 199
 200 #ifndef RANDOM_FILE
 201   /* if RANDOM_FILE isn't defined, we only perform this if an option tells
 202      us to! */
 203   if(data->set.ssl.random_file)
 204 #define RANDOM_FILE "" /* doesn't matter won't be used */
 205 #endif
 206   {
 207     /* let the option override the define */
 208     nread += RAND_load_file((data->set.str[STRING_SSL_RANDOM_FILE]?
 209                              data->set.str[STRING_SSL_RANDOM_FILE]:
 210                              RANDOM_FILE),
 211                             RAND_LOAD_LENGTH);
 212     if(seed_enough(nread))
 213       return nread;
 214   }
 215
 216 #if defined(HAVE_RAND_EGD)
 217   /* only available in OpenSSL 0.9.5 and later */
 218   /* EGD_SOCKET is set at configure time or not at all */
 219 #ifndef EGD_SOCKET
 220   /* If we don't have the define set, we only do this if the egd-option
 221      is set */
 222   if(data->set.str[STRING_SSL_EGDSOCKET])
 223 #define EGD_SOCKET "" /* doesn't matter won't be used */
 224 #endif
 225   {
 226     /* If there's an option and a define, the option overrides the
 227        define */
 228     int ret = RAND_egd(data->set.str[STRING_SSL_EGDSOCKET]?
 229                        data->set.str[STRING_SSL_EGDSOCKET]:EGD_SOCKET);
 230     if(-1 != ret) {
 231       nread += ret;
 232       if(seed_enough(nread))
 233         return nread;
 234     }
 235   }
 236 #endif
 237
 238   /* If we get here, it means we need to seed the PRNG using a "silly"
 239      approach! */
 240   do {
 241     unsigned char randb[64];
 242     int len = sizeof(randb);
 243     RAND_bytes(randb, len);
 244     RAND_add(randb, len, (len >> 1));
 245   } while(!RAND_status());
 246
 247   /* generates a default path for the random seed file */
 248   buf[0]=0; /* blank it first */
 249   RAND_file_name(buf, BUFSIZE);
 250   if(buf[0]) {
 251     /* we got a file name to try */
 252     nread += RAND_load_file(buf, RAND_LOAD_LENGTH);
 253     if(seed_enough(nread))
 254       return nread;
 255   }
 256
 257   infof(data, "libcurl is now using a weak random seed!\n");
 258   return nread;
 259 }
 260
 261 int Curl_ossl_seed(struct SessionHandle *data)
 262 {
 263   /* we have the "SSL is seeded" boolean static to prevent multiple
 264      time-consuming seedings in vain */
 265   static bool ssl_seeded = FALSE;
 266
 267   if(!ssl_seeded || data->set.str[STRING_SSL_RANDOM_FILE] ||
 268      data->set.str[STRING_SSL_EGDSOCKET]) {
 269     ossl_seed(data);
 270     ssl_seeded = TRUE;
 271   }
 272   return 0;
 273 }
 274
 275
 276 #ifndef SSL_FILETYPE_ENGINE
 277 #define SSL_FILETYPE_ENGINE 42
 278 #endif
 279 #ifndef SSL_FILETYPE_PKCS12
 280 #define SSL_FILETYPE_PKCS12 43
 281 #endif
 282 static int do_file_type(const char *type)
 283 {
 284   if(!type || !type[0])
 285     return SSL_FILETYPE_PEM;
 286   if(Curl_raw_equal(type, "PEM"))
 287     return SSL_FILETYPE_PEM;
 288   if(Curl_raw_equal(type, "DER"))
 289     return SSL_FILETYPE_ASN1;
 290   if(Curl_raw_equal(type, "ENG"))
 291     return SSL_FILETYPE_ENGINE;
 292   if(Curl_raw_equal(type, "P12"))
 293     return SSL_FILETYPE_PKCS12;
 294   return -1;
 295 }
 296
 297 #if defined(HAVE_OPENSSL_ENGINE_H) && defined(HAVE_ENGINE_LOAD_FOUR_ARGS)
 298 /*
 299  * Supply default password to the engine user interface conversation.
 300  * The password is passed by OpenSSL engine from ENGINE_load_private_key()
 301  * last argument to the ui and can be obtained by UI_get0_user_data(ui) here.
 302  */
 303 static int ssl_ui_reader(UI *ui, UI_STRING *uis)
 304 {
 305   const char *password;
 306   switch(UI_get_string_type(uis)) {
 307   case UIT_PROMPT:
 308   case UIT_VERIFY:
 309     password = (const char*)UI_get0_user_data(ui);
 310     if(NULL != password &&
 311        UI_get_input_flags(uis) & UI_INPUT_FLAG_DEFAULT_PWD) {
 312       UI_set_result(ui, uis, password);
 313       return 1;
 314     }
 315   default:
 316     break;
 317   }
 318   return (UI_method_get_reader(UI_OpenSSL()))(ui, uis);
 319 }
 320
 321 /*
 322  * Suppress interactive request for a default password if available.
 323  */
 324 static int ssl_ui_writer(UI *ui, UI_STRING *uis)
 325 {
 326   switch(UI_get_string_type(uis)) {
 327   case UIT_PROMPT:
 328   case UIT_VERIFY:
 329     if(NULL != UI_get0_user_data(ui) &&
 330        UI_get_input_flags(uis) & UI_INPUT_FLAG_DEFAULT_PWD) {
 331       return 1;
 332     }
 333   default:
 334     break;
 335   }
 336   return (UI_method_get_writer(UI_OpenSSL()))(ui, uis);
 337 }
 338 #endif
 339
 340 static
 341 int cert_stuff(struct connectdata *conn,
 342                SSL_CTX* ctx,
 343                char *cert_file,
 344                const char *cert_type,
 345                char *key_file,
 346                const char *key_type)
 347 {
 348   struct SessionHandle *data = conn->data;
 349
 350   int file_type = do_file_type(cert_type);
 351
 352   if(cert_file != NULL || file_type == SSL_FILETYPE_ENGINE) {
 353     SSL *ssl;
 354     X509 *x509;
 355     int cert_done = 0;
 356
 357     if(data->set.str[STRING_KEY_PASSWD]) {
 358 #ifndef HAVE_USERDATA_IN_PWD_CALLBACK
 359       /*
 360        * If password has been given, we store that in the global
 361        * area (*shudder*) for a while:
 362        */
 363       size_t len = strlen(data->set.str[STRING_KEY_PASSWD]);
 364       if(len < sizeof(global_passwd))
 365         memcpy(global_passwd, data->set.str[STRING_KEY_PASSWD], len+1);
 366       else
 367         global_passwd[0] = '\0';
 368 #else
 369       /*
 370        * We set the password in the callback userdata
 371        */
 372       SSL_CTX_set_default_passwd_cb_userdata(ctx,
 373                                              data->set.str[STRING_KEY_PASSWD]);
 374 #endif
 375       /* Set passwd callback: */
 376       SSL_CTX_set_default_passwd_cb(ctx, passwd_callback);
 377     }
 378
 379
 380 #define SSL_CLIENT_CERT_ERR \
 381     "unable to use client certificate (no key found or wrong pass phrase?)"
 382
 383     switch(file_type) {
 384     case SSL_FILETYPE_PEM:
 385       /* SSL_CTX_use_certificate_chain_file() only works on PEM files */
 386       if(SSL_CTX_use_certificate_chain_file(ctx,
 387                                             cert_file) != 1) {
 388         failf(data, SSL_CLIENT_CERT_ERR);
 389         return 0;
 390       }
 391       break;
 392
 393     case SSL_FILETYPE_ASN1:
 394       /* SSL_CTX_use_certificate_file() works with either PEM or ASN1, but
 395          we use the case above for PEM so this can only be performed with
 396          ASN1 files. */
 397       if(SSL_CTX_use_certificate_file(ctx,
 398                                       cert_file,
 399                                       file_type) != 1) {
 400         failf(data, SSL_CLIENT_CERT_ERR);
 401         return 0;
 402       }
 403       break;
 404     case SSL_FILETYPE_ENGINE:
 405 #if defined(HAVE_OPENSSL_ENGINE_H) && defined(ENGINE_CTRL_GET_CMD_FROM_NAME)
 406       {
 407         if(data->state.engine) {
 408           const char *cmd_name = "LOAD_CERT_CTRL";
 409           struct {
 410             const char *cert_id;
 411             X509 *cert;
 412           } params;
 413
 414           params.cert_id = cert_file;
 415           params.cert = NULL;
 416
 417           /* Does the engine supports LOAD_CERT_CTRL ? */
 418           if(!ENGINE_ctrl(data->state.engine, ENGINE_CTRL_GET_CMD_FROM_NAME,
 419                           0, (void *)cmd_name, NULL)) {
 420             failf(data, "ssl engine does not support loading certificates");
 421             return 0;
 422           }
 423
 424           /* Load the certificate from the engine */
 425           if(!ENGINE_ctrl_cmd(data->state.engine, cmd_name,
 426                               0, &params, NULL, 1)) {
 427             failf(data, "ssl engine cannot load client cert with id"
 428                   " '%s' [%s]", cert_file,
 429                   ERR_error_string(ERR_get_error(), NULL));
 430             return 0;
 431           }
 432
 433           if(!params.cert) {
 434             failf(data, "ssl engine didn't initialized the certificate "
 435                   "properly.");
 436             return 0;
 437           }
 438
 439           if(SSL_CTX_use_certificate(ctx, params.cert) != 1) {
 440             failf(data, "unable to set client certificate");
 441             X509_free(params.cert);
 442             return 0;
 443           }
 444           X509_free(params.cert); /* we don't need the handle any more... */
 445         }
 446         else {
 447           failf(data, "crypto engine not set, can't load certificate");
 448           return 0;
 449         }
 450       }
 451       break;
 452 #else
 453       failf(data, "file type ENG for certificate not implemented");
 454       return 0;
 455 #endif
 456
 457     case SSL_FILETYPE_PKCS12:
 458     {
 459 #ifdef HAVE_PKCS12_SUPPORT
 460       FILE *f;
 461       PKCS12 *p12;
 462       EVP_PKEY *pri;
 463       STACK_OF(X509) *ca = NULL;
 464       int i;
 465
 466       f = fopen(cert_file,"rb");
 467       if(!f) {
 468         failf(data, "could not open PKCS12 file '%s'", cert_file);
 469         return 0;
 470       }
 471       p12 = d2i_PKCS12_fp(f, NULL);
 472       fclose(f);
 473
 474       if(!p12) {
 475         failf(data, "error reading PKCS12 file '%s'", cert_file );
 476         return 0;
 477       }
 478
 479       PKCS12_PBE_add();
 480
 481       if(!PKCS12_parse(p12, data->set.str[STRING_KEY_PASSWD], &pri, &x509,
 482                        &ca)) {
 483         failf(data,
 484               "could not parse PKCS12 file, check password, OpenSSL error %s",
 485               ERR_error_string(ERR_get_error(), NULL) );
 486         PKCS12_free(p12);
 487         return 0;
 488       }
 489
 490       PKCS12_free(p12);
 491
 492       if(SSL_CTX_use_certificate(ctx, x509) != 1) {
 493         failf(data, SSL_CLIENT_CERT_ERR);
 494         goto fail;
 495       }
 496
 497       if(SSL_CTX_use_PrivateKey(ctx, pri) != 1) {
 498         failf(data, "unable to use private key from PKCS12 file '%s'",
 499               cert_file);
 500         goto fail;
 501       }
 502
 503       if(!SSL_CTX_check_private_key (ctx)) {
 504         failf(data, "private key from PKCS12 file '%s' "
 505               "does not match certificate in same file", cert_file);
 506         goto fail;
 507       }
 508       /* Set Certificate Verification chain */
 509       if(ca && sk_X509_num(ca)) {
 510         for(i = 0; i < sk_X509_num(ca); i++) {
 511           /*
 512            * Note that sk_X509_pop() is used below to make sure the cert is
 513            * removed from the stack properly before getting passed to
 514            * SSL_CTX_add_extra_chain_cert(). Previously we used
 515            * sk_X509_value() instead, but then we'd clean it in the subsequent
 516            * sk_X509_pop_free() call.
 517            */
 518           X509 *x = sk_X509_pop(ca);
 519           if(!SSL_CTX_add_extra_chain_cert(ctx, x)) {
 520             failf(data, "cannot add certificate to certificate chain");
 521             goto fail;
 522           }
 523           /* SSL_CTX_add_client_CA() seems to work with either sk_* function,
 524            * presumably because it duplicates what we pass to it.
 525            */
 526           if(!SSL_CTX_add_client_CA(ctx, x)) {
 527             failf(data, "cannot add certificate to client CA list");
 528             goto fail;
 529           }
 530         }
 531       }
 532
 533       cert_done = 1;
 534   fail:
 535       EVP_PKEY_free(pri);
 536       X509_free(x509);
 537       sk_X509_pop_free(ca, X509_free);
 538
 539       if(!cert_done)
 540         return 0; /* failure! */
 541       break;
 542 #else
 543       failf(data, "file type P12 for certificate not supported");
 544       return 0;
 545 #endif
 546     }
 547     default:
 548       failf(data, "not supported file type '%s' for certificate", cert_type);
 549       return 0;
 550     }
 551
 552     file_type = do_file_type(key_type);
 553
 554     switch(file_type) {
 555     case SSL_FILETYPE_PEM:
 556       if(cert_done)
 557         break;
 558       if(key_file == NULL)
 559         /* cert & key can only be in PEM case in the same file */
 560         key_file=cert_file;
 561     case SSL_FILETYPE_ASN1:
 562       if(SSL_CTX_use_PrivateKey_file(ctx, key_file, file_type) != 1) {
 563         failf(data, "unable to set private key file: '%s' type %s",
 564               key_file, key_type?key_type:"PEM");
 565         return 0;
 566       }
 567       break;
 568     case SSL_FILETYPE_ENGINE:
 569 #ifdef HAVE_OPENSSL_ENGINE_H
 570       {                         /* XXXX still needs some work */
 571         EVP_PKEY *priv_key = NULL;
 572         if(data->state.engine) {
 573 #ifdef HAVE_ENGINE_LOAD_FOUR_ARGS
 574           UI_METHOD *ui_method =
 575             UI_create_method((char *)"cURL user interface");
 576           if(NULL == ui_method) {
 577             failf(data, "unable do create OpenSSL user-interface method");
 578             return 0;
 579           }
 580           UI_method_set_opener(ui_method, UI_method_get_opener(UI_OpenSSL()));
 581           UI_method_set_closer(ui_method, UI_method_get_closer(UI_OpenSSL()));
 582           UI_method_set_reader(ui_method, ssl_ui_reader);
 583           UI_method_set_writer(ui_method, ssl_ui_writer);
 584 #endif
 585           /* the typecast below was added to please mingw32 */
 586           priv_key = (EVP_PKEY *)
 587             ENGINE_load_private_key(data->state.engine,key_file,
 588 #ifdef HAVE_ENGINE_LOAD_FOUR_ARGS
 589                                     ui_method,
 590 #endif
 591                                     data->set.str[STRING_KEY_PASSWD]);
 592 #ifdef HAVE_ENGINE_LOAD_FOUR_ARGS
 593           UI_destroy_method(ui_method);
 594 #endif
 595           if(!priv_key) {
 596             failf(data, "failed to load private key from crypto engine");
 597             return 0;
 598           }
 599           if(SSL_CTX_use_PrivateKey(ctx, priv_key) != 1) {
 600             failf(data, "unable to set private key");
 601             EVP_PKEY_free(priv_key);
 602             return 0;
 603           }
 604           EVP_PKEY_free(priv_key);  /* we don't need the handle any more... */
 605         }
 606         else {
 607           failf(data, "crypto engine not set, can't load private key");
 608           return 0;
 609         }
 610       }
 611       break;
 612 #else
 613       failf(data, "file type ENG for private key not supported");
 614       return 0;
 615 #endif
 616     case SSL_FILETYPE_PKCS12:
 617       if(!cert_done) {
 618         failf(data, "file type P12 for private key not supported");
 619         return 0;
 620       }
 621       break;
 622     default:
 623       failf(data, "not supported file type for private key");
 624       return 0;
 625     }
 626
 627     ssl=SSL_new(ctx);
 628     if(NULL == ssl) {
 629       failf(data,"unable to create an SSL structure");
 630       return 0;
 631     }
 632
 633     x509=SSL_get_certificate(ssl);
 634
 635     /* This version was provided by Evan Jordan and is supposed to not
 636        leak memory as the previous version: */
 637     if(x509 != NULL) {
 638       EVP_PKEY *pktmp = X509_get_pubkey(x509);
 639       EVP_PKEY_copy_parameters(pktmp,SSL_get_privatekey(ssl));
 640       EVP_PKEY_free(pktmp);
 641     }
 642
 643     SSL_free(ssl);
 644
 645     /* If we are using DSA, we can copy the parameters from
 646      * the private key */
 647
 648
 649     /* Now we know that a key and cert have been set against
 650      * the SSL context */
 651     if(!SSL_CTX_check_private_key(ctx)) {
 652       failf(data, "Private key does not match the certificate public key");
 653       return 0;
 654     }
 655 #ifndef HAVE_USERDATA_IN_PWD_CALLBACK
 656     /* erase it now */
 657     memset(global_passwd, 0, sizeof(global_passwd));
 658 #endif
 659   }
 660   return 1;
 661 }
 662
 663 /* returns non-zero on failure */
 664 static int x509_name_oneline(X509_NAME *a, char *buf, size_t size)
 665 {
 666 #if 0
 667   return X509_NAME_oneline(a, buf, size);
 668 #else
 669   BIO *bio_out = BIO_new(BIO_s_mem());
 670   BUF_MEM *biomem;
 671   int rc;
 672
 673   if(!bio_out)
 674     return 1; /* alloc failed! */
 675
 676   rc = X509_NAME_print_ex(bio_out, a, 0, XN_FLAG_SEP_SPLUS_SPC);
 677   BIO_get_mem_ptr(bio_out, &biomem);
 678
 679   if((size_t)biomem->length < size)
 680     size = biomem->length;
 681   else
 682     size--; /* don't overwrite the buffer end */
 683
 684   memcpy(buf, biomem->data, size);
 685   buf[size]=0;
 686
 687   BIO_free(bio_out);
 688
 689   return !rc;
 690 #endif
 691 }
 692
 693 static
 694 int cert_verify_callback(int ok, X509_STORE_CTX *ctx)
 695 {
 696   X509 *err_cert;
 697   char buf[256];
 698
 699   err_cert=X509_STORE_CTX_get_current_cert(ctx);
 700   (void)x509_name_oneline(X509_get_subject_name(err_cert), buf, sizeof(buf));
 701   return ok;
 702 }
 703
 704 /* Return error string for last OpenSSL error
 705  */
 706 static char *SSL_strerror(unsigned long error, char *buf, size_t size)
 707 {
 708 #ifdef HAVE_ERR_ERROR_STRING_N
 709   /* OpenSSL 0.9.6 and later has a function named
 710      ERRO_error_string_n() that takes the size of the buffer as a
 711      third argument */
 712   ERR_error_string_n(error, buf, size);
 713 #else
 714   (void) size;
 715   ERR_error_string(error, buf);
 716 #endif
 717   return buf;
 718 }
 719
 720 #endif /* USE_SSLEAY */
 721
 722 #ifdef USE_SSLEAY
 723 /**
 724  * Global SSL init
 725  *
 726  * @retval 0 error initializing SSL
 727  * @retval 1 SSL initialized successfully
 728  */
 729 int Curl_ossl_init(void)
 730 {
 731 #ifdef HAVE_ENGINE_LOAD_BUILTIN_ENGINES
 732   ENGINE_load_builtin_engines();
 733 #endif
 734
 735   /* Lets get nice error messages */
 736   SSL_load_error_strings();
 737
 738   /* Init the global ciphers and digests */
 739   if(!SSLeay_add_ssl_algorithms())
 740     return 0;
 741
 742   OpenSSL_add_all_algorithms();
 743
 744   return 1;
 745 }
 746
 747 #endif /* USE_SSLEAY */
 748
 749 #ifdef USE_SSLEAY
 750
 751 /* Global cleanup */
 752 void Curl_ossl_cleanup(void)
 753 {
 754   /* Free ciphers and digests lists */
 755   EVP_cleanup();
 756
 757 #ifdef HAVE_ENGINE_CLEANUP
 758   /* Free engine list */
 759   ENGINE_cleanup();
 760 #endif
 761
 762 #ifdef HAVE_CRYPTO_CLEANUP_ALL_EX_DATA
 763   /* Free OpenSSL ex_data table */
 764   CRYPTO_cleanup_all_ex_data();
 765 #endif
 766
 767   /* Free OpenSSL error strings */
 768   ERR_free_strings();
 769
 770   /* Free thread local error state, destroying hash upon zero refcount */
 771 #ifdef HAVE_ERR_REMOVE_THREAD_STATE
 772   ERR_remove_thread_state(NULL);
 773 #else
 774   ERR_remove_state(0);
 775 #endif
 776 }
 777
 778 /*
 779  * This function uses SSL_peek to determine connection status.
 780  *
 781  * Return codes:
 782  *     1 means the connection is still in place
 783  *     0 means the connection has been closed
 784  *    -1 means the connection status is unknown
 785  */
 786 int Curl_ossl_check_cxn(struct connectdata *conn)
 787 {
 788   int rc;
 789   char buf;
 790
 791   rc = SSL_peek(conn->ssl[FIRSTSOCKET].handle, (void*)&buf, 1);
 792   if(rc > 0)
 793     return 1; /* connection still in place */
 794
 795   if(rc == 0)
 796     return 0; /* connection has been closed */
 797
 798   return -1; /* connection status unknown */
 799 }
 800
 801 /* Selects an OpenSSL crypto engine
 802  */
 803 CURLcode Curl_ossl_set_engine(struct SessionHandle *data, const char *engine)
 804 {
 805 #if defined(USE_SSLEAY) && defined(HAVE_OPENSSL_ENGINE_H)
 806   ENGINE *e;
 807
 808 #if OPENSSL_VERSION_NUMBER >= 0x00909000L
 809   e = ENGINE_by_id(engine);
 810 #else
 811   /* avoid memory leak */
 812   for(e = ENGINE_get_first(); e; e = ENGINE_get_next(e)) {
 813     const char *e_id = ENGINE_get_id(e);
 814     if(!strcmp(engine, e_id))
 815       break;
 816   }
 817 #endif
 818
 819   if(!e) {
 820     failf(data, "SSL Engine '%s' not found", engine);
 821     return CURLE_SSL_ENGINE_NOTFOUND;
 822   }
 823
 824   if(data->state.engine) {
 825     ENGINE_finish(data->state.engine);
 826     ENGINE_free(data->state.engine);
 827     data->state.engine = NULL;
 828   }
 829   if(!ENGINE_init(e)) {
 830     char buf[256];
 831
 832     ENGINE_free(e);
 833     failf(data, "Failed to initialise SSL Engine '%s':\n%s",
 834           engine, SSL_strerror(ERR_get_error(), buf, sizeof(buf)));
 835     return CURLE_SSL_ENGINE_INITFAILED;
 836   }
 837   data->state.engine = e;
 838   return CURLE_OK;
 839 #else
 840   (void)engine;
 841   failf(data, "SSL Engine not supported");
 842   return CURLE_SSL_ENGINE_NOTFOUND;
 843 #endif
 844 }
 845
 846 /* Sets engine as default for all SSL operations
 847  */
 848 CURLcode Curl_ossl_set_engine_default(struct SessionHandle *data)
 849 {
 850 #ifdef HAVE_OPENSSL_ENGINE_H
 851   if(data->state.engine) {
 852     if(ENGINE_set_default(data->state.engine, ENGINE_METHOD_ALL) > 0) {
 853       infof(data,"set default crypto engine '%s'\n",
 854             ENGINE_get_id(data->state.engine));
 855     }
 856     else {
 857       failf(data, "set default crypto engine '%s' failed",
 858             ENGINE_get_id(data->state.engine));
 859       return CURLE_SSL_ENGINE_SETFAILED;
 860     }
 861   }
 862 #else
 863   (void) data;
 864 #endif
 865   return CURLE_OK;
 866 }
 867
 868 /* Return list of OpenSSL crypto engine names.
 869  */
 870 struct curl_slist *Curl_ossl_engines_list(struct SessionHandle *data)
 871 {
 872   struct curl_slist *list = NULL;
 873 #if defined(USE_SSLEAY) && defined(HAVE_OPENSSL_ENGINE_H)
 874   struct curl_slist *beg;
 875   ENGINE *e;
 876
 877   for(e = ENGINE_get_first(); e; e = ENGINE_get_next(e)) {
 878     beg = curl_slist_append(list, ENGINE_get_id(e));
 879     if(!beg) {
 880       curl_slist_free_all(list);
 881       return NULL;
 882     }
 883     list = beg;
 884   }
 885 #endif
 886   (void) data;
 887   return list;
 888 }
 889
 890
 891 /*
 892  * This function is called when an SSL connection is closed.
 893  */
 894 void Curl_ossl_close(struct connectdata *conn, int sockindex)
 895 {
 896   struct ssl_connect_data *connssl = &conn->ssl[sockindex];
 897
 898   if(connssl->handle) {
 899     (void)SSL_shutdown(connssl->handle);
 900     SSL_set_connect_state(connssl->handle);
 901
 902     SSL_free (connssl->handle);
 903     connssl->handle = NULL;
 904   }
 905   if(connssl->ctx) {
 906     SSL_CTX_free (connssl->ctx);
 907     connssl->ctx = NULL;
 908   }
 909 }
 910
 911 /*
 912  * This function is called to shut down the SSL layer but keep the
 913  * socket open (CCC - Clear Command Channel)
 914  */
 915 int Curl_ossl_shutdown(struct connectdata *conn, int sockindex)
 916 {
 917   int retval = 0;
 918   struct ssl_connect_data *connssl = &conn->ssl[sockindex];
 919   struct SessionHandle *data = conn->data;
 920   char buf[120]; /* We will use this for the OpenSSL error buffer, so it has
 921                     to be at least 120 bytes long. */
 922   unsigned long sslerror;
 923   ssize_t nread;
 924   int buffsize;
 925   int err;
 926   int done = 0;
 927
 928   /* This has only been tested on the proftpd server, and the mod_tls code
 929      sends a close notify alert without waiting for a close notify alert in
 930      response. Thus we wait for a close notify alert from the server, but
 931      we do not send one. Let's hope other servers do the same... */
 932
 933   if(data->set.ftp_ccc == CURLFTPSSL_CCC_ACTIVE)
 934       (void)SSL_shutdown(connssl->handle);
 935
 936   if(connssl->handle) {
 937     buffsize = (int)sizeof(buf);
 938     while(!done) {
 939       int what = Curl_socket_ready(conn->sock[sockindex],
 940                                    CURL_SOCKET_BAD, SSL_SHUTDOWN_TIMEOUT);
 941       if(what > 0) {
 942         ERR_clear_error();
 943
 944         /* Something to read, let's do it and hope that it is the close
 945            notify alert from the server */
 946         nread = (ssize_t)SSL_read(conn->ssl[sockindex].handle, buf,
 947                                   buffsize);
 948         err = SSL_get_error(conn->ssl[sockindex].handle, (int)nread);
 949
 950         switch(err) {
 951         case SSL_ERROR_NONE: /* this is not an error */
 952         case SSL_ERROR_ZERO_RETURN: /* no more data */
 953           /* This is the expected response. There was no data but only
 954              the close notify alert */
 955           done = 1;
 956           break;
 957         case SSL_ERROR_WANT_READ:
 958           /* there's data pending, re-invoke SSL_read() */
 959           infof(data, "SSL_ERROR_WANT_READ\n");
 960           break;
 961         case SSL_ERROR_WANT_WRITE:
 962           /* SSL wants a write. Really odd. Let's bail out. */
 963           infof(data, "SSL_ERROR_WANT_WRITE\n");
 964           done = 1;
 965           break;
 966         default:
 967           /* openssl/ssl.h says "look at error stack/return value/errno" */
 968           sslerror = ERR_get_error();
 969           failf(conn->data, "SSL read: %s, errno %d",
 970                 ERR_error_string(sslerror, buf),
 971                 SOCKERRNO);
 972           done = 1;
 973           break;
 974         }
 975       }
 976       else if(0 == what) {
 977         /* timeout */
 978         failf(data, "SSL shutdown timeout");
 979         done = 1;
 980       }
 981       else {
 982         /* anything that gets here is fatally bad */
 983         failf(data, "select/poll on SSL socket, errno: %d", SOCKERRNO);
 984         retval = -1;
 985         done = 1;
 986       }
 987     } /* while()-loop for the select() */
 988
 989     if(data->set.verbose) {
 990 #ifdef HAVE_SSL_GET_SHUTDOWN
 991       switch(SSL_get_shutdown(connssl->handle)) {
 992       case SSL_SENT_SHUTDOWN:
 993         infof(data, "SSL_get_shutdown() returned SSL_SENT_SHUTDOWN\n");
 994         break;
 995       case SSL_RECEIVED_SHUTDOWN:
 996         infof(data, "SSL_get_shutdown() returned SSL_RECEIVED_SHUTDOWN\n");
 997         break;
 998       case SSL_SENT_SHUTDOWN|SSL_RECEIVED_SHUTDOWN:
 999         infof(data, "SSL_get_shutdown() returned SSL_SENT_SHUTDOWN|"
1000               "SSL_RECEIVED__SHUTDOWN\n");
1001         break;
1002       }
1003 #endif
1004     }
1005
1006     SSL_free (connssl->handle);
1007     connssl->handle = NULL;
1008   }
1009   return retval;
1010 }
1011
1012 void Curl_ossl_session_free(void *ptr)
1013 {
1014   /* free the ID */
1015   SSL_SESSION_free(ptr);
1016 }
1017
1018 /*
1019  * This function is called when the 'data' struct is going away. Close
1020  * down everything and free all resources!
1021  */
1022 int Curl_ossl_close_all(struct SessionHandle *data)
1023 {
1024 #ifdef HAVE_OPENSSL_ENGINE_H
1025   if(data->state.engine) {
1026     ENGINE_finish(data->state.engine);
1027     ENGINE_free(data->state.engine);
1028     data->state.engine = NULL;
1029   }
1030 #else
1031   (void)data;
1032 #endif
1033   return 0;
1034 }
1035
1036 static int asn1_output(const ASN1_UTCTIME *tm,
1037                        char *buf,
1038                        size_t sizeofbuf)
1039 {
1040   const char *asn1_string;
1041   int gmt=FALSE;
1042   int i;
1043   int year=0,month=0,day=0,hour=0,minute=0,second=0;
1044
1045   i=tm->length;
1046   asn1_string=(const char *)tm->data;
1047
1048   if(i < 10)
1049     return 1;
1050   if(asn1_string[i-1] == 'Z')
1051     gmt=TRUE;
1052   for(i=0; i<10; i++)
1053     if((asn1_string[i] > '9') || (asn1_string[i] < '0'))
1054       return 2;
1055
1056   year= (asn1_string[0]-'0')*10+(asn1_string[1]-'0');
1057   if(year < 50)
1058     year+=100;
1059
1060   month= (asn1_string[2]-'0')*10+(asn1_string[3]-'0');
1061   if((month > 12) || (month < 1))
1062     return 3;
1063
1064   day= (asn1_string[4]-'0')*10+(asn1_string[5]-'0');
1065   hour= (asn1_string[6]-'0')*10+(asn1_string[7]-'0');
1066   minute=  (asn1_string[8]-'0')*10+(asn1_string[9]-'0');
1067
1068   if((asn1_string[10] >= '0') && (asn1_string[10] <= '9') &&
1069      (asn1_string[11] >= '0') && (asn1_string[11] <= '9'))
1070     second= (asn1_string[10]-'0')*10+(asn1_string[11]-'0');
1071
1072   snprintf(buf, sizeofbuf,
1073            "%04d-%02d-%02d %02d:%02d:%02d %s",
1074            year+1900, month, day, hour, minute, second, (gmt?"GMT":""));
1075
1076   return 0;
1077 }
1078
1079 /* ====================================================== */
1080
1081
1082 /* Quote from RFC2818 section 3.1 "Server Identity"
1083
1084    If a subjectAltName extension of type dNSName is present, that MUST
1085    be used as the identity. Otherwise, the (most specific) Common Name
1086    field in the Subject field of the certificate MUST be used. Although
1087    the use of the Common Name is existing practice, it is deprecated and
1088    Certification Authorities are encouraged to use the dNSName instead.
1089
1090    Matching is performed using the matching rules specified by
1091    [RFC2459].  If more than one identity of a given type is present in
1092    the certificate (e.g., more than one dNSName name, a match in any one
1093    of the set is considered acceptable.) Names may contain the wildcard
1094    character * which is considered to match any single domain name
1095    component or component fragment. E.g., *.a.com matches foo.a.com but
1096    not bar.foo.a.com. f*.com matches foo.com but not bar.com.
1097
1098    In some cases, the URI is specified as an IP address rather than a
1099    hostname. In this case, the iPAddress subjectAltName must be present
1100    in the certificate and must exactly match the IP in the URI.
1101
1102 */
1103 static CURLcode verifyhost(struct connectdata *conn,
1104                            X509 *server_cert)
1105 {
1106   int matched = -1; /* -1 is no alternative match yet, 1 means match and 0
1107                        means mismatch */
1108   int target = GEN_DNS; /* target type, GEN_DNS or GEN_IPADD */
1109   size_t addrlen = 0;
1110   struct SessionHandle *data = conn->data;
1111   STACK_OF(GENERAL_NAME) *altnames;
1112 #ifdef ENABLE_IPV6
1113   struct in6_addr addr;
1114 #else
1115   struct in_addr addr;
1116 #endif
1117   CURLcode res = CURLE_OK;
1118
1119 #ifdef ENABLE_IPV6
1120   if(conn->bits.ipv6_ip &&
1121      Curl_inet_pton(AF_INET6, conn->host.name, &addr)) {
1122     target = GEN_IPADD;
1123     addrlen = sizeof(struct in6_addr);
1124   }
1125   else
1126 #endif
1127     if(Curl_inet_pton(AF_INET, conn->host.name, &addr)) {
1128       target = GEN_IPADD;
1129       addrlen = sizeof(struct in_addr);
1130     }
1131
1132   /* get a "list" of alternative names */
1133   altnames = X509_get_ext_d2i(server_cert, NID_subject_alt_name, NULL, NULL);
1134
1135   if(altnames) {
1136     int numalts;
1137     int i;
1138
1139     /* get amount of alternatives, RFC2459 claims there MUST be at least
1140        one, but we don't depend on it... */
1141     numalts = sk_GENERAL_NAME_num(altnames);
1142
1143     /* loop through all alternatives while none has matched */
1144     for(i=0; (i<numalts) && (matched != 1); i++) {
1145       /* get a handle to alternative name number i */
1146       const GENERAL_NAME *check = sk_GENERAL_NAME_value(altnames, i);
1147
1148       /* only check alternatives of the same type the target is */
1149       if(check->type == target) {
1150         /* get data and length */
1151         const char *altptr = (char *)ASN1_STRING_data(check->d.ia5);
1152         size_t altlen = (size_t) ASN1_STRING_length(check->d.ia5);
1153
1154         switch(target) {
1155         case GEN_DNS: /* name/pattern comparison */
1156           /* The OpenSSL man page explicitly says: "In general it cannot be
1157              assumed that the data returned by ASN1_STRING_data() is null
1158              terminated or does not contain embedded nulls." But also that
1159              "The actual format of the data will depend on the actual string
1160              type itself: for example for and IA5String the data will be ASCII"
1161
1162              Gisle researched the OpenSSL sources:
1163              "I checked the 0.9.6 and 0.9.8 sources before my patch and
1164              it always 0-terminates an IA5String."
1165           */
1166           if((altlen == strlen(altptr)) &&
1167              /* if this isn't true, there was an embedded zero in the name
1168                 string and we cannot match it. */
1169              Curl_cert_hostcheck(altptr, conn->host.name))
1170             matched = 1;
1171           else
1172             matched = 0;
1173           break;
1174
1175         case GEN_IPADD: /* IP address comparison */
1176           /* compare alternative IP address if the data chunk is the same size
1177              our server IP address is */
1178           if((altlen == addrlen) && !memcmp(altptr, &addr, altlen))
1179             matched = 1;
1180           else
1181             matched = 0;
1182           break;
1183         }
1184       }
1185     }
1186     GENERAL_NAMES_free(altnames);
1187   }
1188
1189   if(matched == 1)
1190     /* an alternative name matched the server hostname */
1191     infof(data, "\t subjectAltName: %s matched\n", conn->host.dispname);
1192   else if(matched == 0) {
1193     /* an alternative name field existed, but didn't match and then
1194        we MUST fail */
1195     infof(data, "\t subjectAltName does not match %s\n", conn->host.dispname);
1196     failf(data, "SSL: no alternative certificate subject name matches "
1197           "target host name '%s'", conn->host.dispname);
1198     res = CURLE_PEER_FAILED_VERIFICATION;
1199   }
1200   else {
1201     /* we have to look to the last occurrence of a commonName in the
1202        distinguished one to get the most significant one. */
1203     int j,i=-1 ;
1204
1205 /* The following is done because of a bug in 0.9.6b */
1206
1207     unsigned char *nulstr = (unsigned char *)"";
1208     unsigned char *peer_CN = nulstr;
1209
1210     X509_NAME *name = X509_get_subject_name(server_cert) ;
1211     if(name)
1212       while((j = X509_NAME_get_index_by_NID(name, NID_commonName, i))>=0)
1213         i=j;
1214
1215     /* we have the name entry and we will now convert this to a string
1216        that we can use for comparison. Doing this we support BMPstring,
1217        UTF8 etc. */
1218
1219     if(i>=0) {
1220       ASN1_STRING *tmp = X509_NAME_ENTRY_get_data(X509_NAME_get_entry(name,i));
1221
1222       /* In OpenSSL 0.9.7d and earlier, ASN1_STRING_to_UTF8 fails if the input
1223          is already UTF-8 encoded. We check for this case and copy the raw
1224          string manually to avoid the problem. This code can be made
1225          conditional in the future when OpenSSL has been fixed. Work-around
1226          brought by Alexis S. L. Carvalho. */
1227       if(tmp) {
1228         if(ASN1_STRING_type(tmp) == V_ASN1_UTF8STRING) {
1229           j = ASN1_STRING_length(tmp);
1230           if(j >= 0) {
1231             peer_CN = OPENSSL_malloc(j+1);
1232             if(peer_CN) {
1233               memcpy(peer_CN, ASN1_STRING_data(tmp), j);
1234               peer_CN[j] = '\0';
1235             }
1236           }
1237         }
1238         else /* not a UTF8 name */
1239           j = ASN1_STRING_to_UTF8(&peer_CN, tmp);
1240
1241         if(peer_CN && (curlx_uztosi(strlen((char *)peer_CN)) != j)) {
1242           /* there was a terminating zero before the end of string, this
1243              cannot match and we return failure! */
1244           failf(data, "SSL: illegal cert name field");
1245           res = CURLE_PEER_FAILED_VERIFICATION;
1246         }
1247       }
1248     }
1249
1250     if(peer_CN == nulstr)
1251        peer_CN = NULL;
1252     else {
1253       /* convert peer_CN from UTF8 */
1254       CURLcode rc = Curl_convert_from_utf8(data, peer_CN, strlen(peer_CN));
1255       /* Curl_convert_from_utf8 calls failf if unsuccessful */
1256       if(rc) {
1257         OPENSSL_free(peer_CN);
1258         return rc;
1259       }
1260     }
1261
1262     if(res)
1263       /* error already detected, pass through */
1264       ;
1265     else if(!peer_CN) {
1266       failf(data,
1267             "SSL: unable to obtain common name from peer certificate");
1268       res = CURLE_PEER_FAILED_VERIFICATION;
1269     }
1270     else if(!Curl_cert_hostcheck((const char *)peer_CN, conn->host.name)) {
1271       failf(data, "SSL: certificate subject name '%s' does not match "
1272             "target host name '%s'", peer_CN, conn->host.dispname);
1273       res = CURLE_PEER_FAILED_VERIFICATION;
1274     }
1275     else {
1276       infof(data, "\t common name: %s (matched)\n", peer_CN);
1277     }
1278     if(peer_CN)
1279       OPENSSL_free(peer_CN);
1280   }
1281   return res;
1282 }
1283 #endif /* USE_SSLEAY */
1284
1285 /* The SSL_CTRL_SET_MSG_CALLBACK doesn't exist in ancient OpenSSL versions
1286    and thus this cannot be done there. */
1287 #ifdef SSL_CTRL_SET_MSG_CALLBACK
1288
1289 static const char *ssl_msg_type(int ssl_ver, int msg)
1290 {
1291   if(ssl_ver == SSL2_VERSION_MAJOR) {
1292     switch (msg) {
1293       case SSL2_MT_ERROR:
1294         return "Error";
1295       case SSL2_MT_CLIENT_HELLO:
1296         return "Client hello";
1297       case SSL2_MT_CLIENT_MASTER_KEY:
1298         return "Client key";
1299       case SSL2_MT_CLIENT_FINISHED:
1300         return "Client finished";
1301       case SSL2_MT_SERVER_HELLO:
1302         return "Server hello";
1303       case SSL2_MT_SERVER_VERIFY:
1304         return "Server verify";
1305       case SSL2_MT_SERVER_FINISHED:
1306         return "Server finished";
1307       case SSL2_MT_REQUEST_CERTIFICATE:
1308         return "Request CERT";
1309       case SSL2_MT_CLIENT_CERTIFICATE:
1310         return "Client CERT";
1311     }
1312   }
1313   else if(ssl_ver == SSL3_VERSION_MAJOR) {
1314     switch (msg) {
1315       case SSL3_MT_HELLO_REQUEST:
1316         return "Hello request";
1317       case SSL3_MT_CLIENT_HELLO:
1318         return "Client hello";
1319       case SSL3_MT_SERVER_HELLO:
1320         return "Server hello";
1321       case SSL3_MT_CERTIFICATE:
1322         return "CERT";
1323       case SSL3_MT_SERVER_KEY_EXCHANGE:
1324         return "Server key exchange";
1325       case SSL3_MT_CLIENT_KEY_EXCHANGE:
1326         return "Client key exchange";
1327       case SSL3_MT_CERTIFICATE_REQUEST:
1328         return "Request CERT";
1329       case SSL3_MT_SERVER_DONE:
1330         return "Server finished";
1331       case SSL3_MT_CERTIFICATE_VERIFY:
1332         return "CERT verify";
1333       case SSL3_MT_FINISHED:
1334         return "Finished";
1335     }
1336   }
1337   return "Unknown";
1338 }
1339
1340 static const char *tls_rt_type(int type)
1341 {
1342   return (
1343     type == SSL3_RT_CHANGE_CIPHER_SPEC ? "TLS change cipher, " :
1344     type == SSL3_RT_ALERT              ? "TLS alert, "         :
1345     type == SSL3_RT_HANDSHAKE          ? "TLS handshake, "     :
1346     type == SSL3_RT_APPLICATION_DATA   ? "TLS app data, "      :
1347                                          "TLS Unknown, ");
1348 }
1349
1350
1351 /*
1352  * Our callback from the SSL/TLS layers.
1353  */
1354 static void ssl_tls_trace(int direction, int ssl_ver, int content_type,
1355                           const void *buf, size_t len, const SSL *ssl,
1356                           struct connectdata *conn)
1357 {
1358   struct SessionHandle *data;
1359   const char *msg_name, *tls_rt_name;
1360   char ssl_buf[1024];
1361   int  ver, msg_type, txt_len;
1362
1363   if(!conn || !conn->data || !conn->data->set.fdebug ||
1364      (direction != 0 && direction != 1))
1365     return;
1366
1367   data = conn->data;
1368   ssl_ver >>= 8;
1369   ver = (ssl_ver == SSL2_VERSION_MAJOR ? '2' :
1370          ssl_ver == SSL3_VERSION_MAJOR ? '3' : '?');
1371
1372   /* SSLv2 doesn't seem to have TLS record-type headers, so OpenSSL
1373    * always pass-up content-type as 0. But the interesting message-type
1374    * is at 'buf[0]'.
1375    */
1376   if(ssl_ver == SSL3_VERSION_MAJOR && content_type != 0)
1377     tls_rt_name = tls_rt_type(content_type);
1378   else
1379     tls_rt_name = "";
1380
1381   msg_type = *(char*)buf;
1382   msg_name = ssl_msg_type(ssl_ver, msg_type);
1383
1384   txt_len = snprintf(ssl_buf, sizeof(ssl_buf), "SSLv%c, %s%s (%d):\n",
1385                      ver, tls_rt_name, msg_name, msg_type);
1386   Curl_debug(data, CURLINFO_TEXT, ssl_buf, (size_t)txt_len, NULL);
1387
1388   Curl_debug(data, (direction == 1) ? CURLINFO_SSL_DATA_OUT :
1389              CURLINFO_SSL_DATA_IN, (char *)buf, len, NULL);
1390   (void) ssl;
1391 }
1392 #endif
1393
1394 #ifdef USE_SSLEAY
1395 /* ====================================================== */
1396
1397 #ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
1398 #  define use_sni(x)  sni = (x)
1399 #else
1400 #  define use_sni(x)  Curl_nop_stmt
1401 #endif
1402
1403 #ifdef USE_NGHTTP2
1404
1405 #undef HAS_ALPN
1406 #if defined(HAVE_SSL_CTX_SET_ALPN_PROTOS) && \
1407   defined(HAVE_SSL_CTX_SET_ALPN_SELECT_CB)
1408 #  define HAS_ALPN 1
1409 #endif
1410
1411 #if !defined(HAVE_SSL_CTX_SET_NEXT_PROTO_SELECT_CB) || \
1412   defined(OPENSSL_NO_NEXTPROTONEG)
1413 #  if !defined(HAS_ALPN)
1414 #    error http2 builds require OpenSSL with NPN or ALPN support
1415 #  endif
1416 #endif
1417
1418
1419 /*
1420  * in is a list of lenght prefixed strings. this function has to select
1421  * the protocol we want to use from the list and write its string into out.
1422  */
1423 static int
1424 select_next_proto_cb(SSL *ssl,
1425                      unsigned char **out, unsigned char *outlen,
1426                      const unsigned char *in, unsigned int inlen,
1427                      void *arg)
1428 {
1429   struct connectdata *conn = (struct connectdata*) arg;
1430   int retval = nghttp2_select_next_protocol(out, outlen, in, inlen);
1431   (void)ssl;
1432
1433   if(retval == 1) {
1434     infof(conn->data, "NPN, negotiated HTTP2 (%s)\n",
1435           NGHTTP2_PROTO_VERSION_ID);
1436     conn->negnpn = NPN_HTTP2;
1437   }
1438   else if(retval == 0) {
1439     infof(conn->data, "NPN, negotiated HTTP1.1\n");
1440     conn->negnpn = NPN_HTTP1_1;
1441   }
1442   else {
1443     infof(conn->data, "NPN, no overlap, negotiated nothing\n");
1444   }
1445
1446   return SSL_TLSEXT_ERR_OK;
1447 }
1448 #endif
1449
1450 static const char *
1451 get_ssl_version_txt(SSL_SESSION *session)
1452 {
1453   if(NULL == session)
1454     return "";
1455
1456   switch(session->ssl_version) {
1457 #if OPENSSL_VERSION_NUMBER >= 0x1000100FL
1458   case TLS1_2_VERSION:
1459     return "TLSv1.2";
1460   case TLS1_1_VERSION:
1461     return "TLSv1.1";
1462 #endif
1463   case TLS1_VERSION:
1464     return "TLSv1.0";
1465   case SSL3_VERSION:
1466     return "SSLv3";
1467   case SSL2_VERSION:
1468     return "SSLv2";
1469   }
1470   return "unknown";
1471 }
1472
1473
1474 static CURLcode
1475 ossl_connect_step1(struct connectdata *conn,
1476                    int sockindex)
1477 {
1478   CURLcode retcode = CURLE_OK;
1479   char *ciphers;
1480   struct SessionHandle *data = conn->data;
1481   SSL_METHOD_QUAL SSL_METHOD *req_method=NULL;
1482   void *ssl_sessionid=NULL;
1483   X509_LOOKUP *lookup=NULL;
1484   curl_socket_t sockfd = conn->sock[sockindex];
1485   struct ssl_connect_data *connssl = &conn->ssl[sockindex];
1486   long ctx_options;
1487 #ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
1488   bool sni;
1489 #ifdef ENABLE_IPV6
1490   struct in6_addr addr;
1491 #else
1492   struct in_addr addr;
1493 #endif
1494 #endif
1495 #ifdef HAS_ALPN
1496   unsigned char protocols[128];
1497 #endif
1498
1499   DEBUGASSERT(ssl_connect_1 == connssl->connecting_state);
1500
1501   /* Make funny stuff to get random input */
1502   Curl_ossl_seed(data);
1503
1504   data->set.ssl.certverifyresult = !X509_V_OK;
1505
1506   /* check to see if we've been told to use an explicit SSL/TLS version */
1507
1508   switch(data->set.ssl.version) {
1509   default:
1510   case CURL_SSLVERSION_DEFAULT:
1511   case CURL_SSLVERSION_TLSv1:
1512   case CURL_SSLVERSION_TLSv1_0:
1513   case CURL_SSLVERSION_TLSv1_1:
1514   case CURL_SSLVERSION_TLSv1_2:
1515     /* it will be handled later with the context options */
1516     req_method = SSLv23_client_method();
1517     use_sni(TRUE);
1518     break;
1519   case CURL_SSLVERSION_SSLv2:
1520 #ifdef OPENSSL_NO_SSL2
1521     failf(data, "OpenSSL was built without SSLv2 support");
1522     return CURLE_NOT_BUILT_IN;
1523 #else
1524 #ifdef USE_TLS_SRP
1525     if(data->set.ssl.authtype == CURL_TLSAUTH_SRP)
1526       return CURLE_SSL_CONNECT_ERROR;
1527 #endif
1528     req_method = SSLv2_client_method();
1529     use_sni(FALSE);
1530     break;
1531 #endif
1532   case CURL_SSLVERSION_SSLv3:
1533 #ifdef USE_TLS_SRP
1534     if(data->set.ssl.authtype == CURL_TLSAUTH_SRP)
1535       return CURLE_SSL_CONNECT_ERROR;
1536 #endif
1537     req_method = SSLv3_client_method();
1538     use_sni(FALSE);
1539     break;
1540   }
1541
1542   if(connssl->ctx)
1543     SSL_CTX_free(connssl->ctx);
1544   connssl->ctx = SSL_CTX_new(req_method);
1545
1546   if(!connssl->ctx) {
1547     failf(data, "SSL: couldn't create a context: %s",
1548           ERR_error_string(ERR_peek_error(), NULL));
1549     return CURLE_OUT_OF_MEMORY;
1550   }
1551
1552 #ifdef SSL_MODE_RELEASE_BUFFERS
1553   SSL_CTX_set_mode(connssl->ctx, SSL_MODE_RELEASE_BUFFERS);
1554 #endif
1555
1556 #ifdef SSL_CTRL_SET_MSG_CALLBACK
1557   if(data->set.fdebug && data->set.verbose) {
1558     /* the SSL trace callback is only used for verbose logging so we only
1559        inform about failures of setting it */
1560     if(!SSL_CTX_callback_ctrl(connssl->ctx, SSL_CTRL_SET_MSG_CALLBACK,
1561                                (void (*)(void))ssl_tls_trace)) {
1562       infof(data, "SSL: couldn't set callback!\n");
1563     }
1564     else if(!SSL_CTX_ctrl(connssl->ctx, SSL_CTRL_SET_MSG_CALLBACK_ARG, 0,
1565                           conn)) {
1566       infof(data, "SSL: couldn't set callback argument!\n");
1567     }
1568   }
1569 #endif
1570
1571   /* OpenSSL contains code to work-around lots of bugs and flaws in various
1572      SSL-implementations. SSL_CTX_set_options() is used to enabled those
1573      work-arounds. The man page for this option states that SSL_OP_ALL enables
1574      all the work-arounds and that "It is usually safe to use SSL_OP_ALL to
1575      enable the bug workaround options if compatibility with somewhat broken
1576      implementations is desired."
1577
1578      The "-no_ticket" option was introduced in Openssl0.9.8j. It's a flag to
1579      disable "rfc4507bis session ticket support".  rfc4507bis was later turned
1580      into the proper RFC5077 it seems: http://tools.ietf.org/html/rfc5077
1581
1582      The enabled extension concerns the session management. I wonder how often
1583      libcurl stops a connection and then resumes a TLS session. also, sending
1584      the session data is some overhead. .I suggest that you just use your
1585      proposed patch (which explicitly disables TICKET).
1586
1587      If someone writes an application with libcurl and openssl who wants to
1588      enable the feature, one can do this in the SSL callback.
1589
1590      SSL_OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG option enabling allowed proper
1591      interoperability with web server Netscape Enterprise Server 2.0.1 which
1592      was released back in 1996.
1593
1594      Due to CVE-2010-4180, option SSL_OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG has
1595      become ineffective as of OpenSSL 0.9.8q and 1.0.0c. In order to mitigate
1596      CVE-2010-4180 when using previous OpenSSL versions we no longer enable
1597      this option regardless of OpenSSL version and SSL_OP_ALL definition.
1598
1599      OpenSSL added a work-around for a SSL 3.0/TLS 1.0 CBC vulnerability
1600      (http://www.openssl.org/~bodo/tls-cbc.txt). In 0.9.6e they added a bit to
1601      SSL_OP_ALL that _disables_ that work-around despite the fact that
1602      SSL_OP_ALL is documented to do "rather harmless" workarounds. In order to
1603      keep the secure work-around, the SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS bit
1604      must not be set.
1605   */
1606
1607   ctx_options = SSL_OP_ALL;
1608
1609 #ifdef SSL_OP_NO_TICKET
1610   ctx_options |= SSL_OP_NO_TICKET;
1611 #endif
1612
1613 #ifdef SSL_OP_NO_COMPRESSION
1614   ctx_options |= SSL_OP_NO_COMPRESSION;
1615 #endif
1616
1617 #ifdef SSL_OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG
1618   /* mitigate CVE-2010-4180 */
1619   ctx_options &= ~SSL_OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG;
1620 #endif
1621
1622 #ifdef SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS
1623   /* unless the user explicitly ask to allow the protocol vulnerability we
1624      use the work-around */
1625   if(!conn->data->set.ssl_enable_beast)
1626     ctx_options &= ~SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS;
1627 #endif
1628
1629   switch(data->set.ssl.version) {
1630   case CURL_SSLVERSION_DEFAULT:
1631     ctx_options |= SSL_OP_NO_SSLv2;
1632 #ifdef USE_TLS_SRP
1633     if(data->set.ssl.authtype == CURL_TLSAUTH_SRP) {
1634       infof(data, "Set version TLSv1.x for SRP authorisation\n");
1635       ctx_options |= SSL_OP_NO_SSLv3;
1636     }
1637 #endif
1638     break;
1639
1640   case CURL_SSLVERSION_SSLv3:
1641     ctx_options |= SSL_OP_NO_SSLv2;
1642     ctx_options |= SSL_OP_NO_TLSv1;
1643 #if OPENSSL_VERSION_NUMBER >= 0x1000100FL
1644     ctx_options |= SSL_OP_NO_TLSv1_1;
1645     ctx_options |= SSL_OP_NO_TLSv1_2;
1646 #endif
1647     break;
1648
1649   case CURL_SSLVERSION_TLSv1:
1650     ctx_options |= SSL_OP_NO_SSLv2;
1651     ctx_options |= SSL_OP_NO_SSLv3;
1652     break;
1653
1654   case CURL_SSLVERSION_TLSv1_0:
1655     ctx_options |= SSL_OP_NO_SSLv2;
1656     ctx_options |= SSL_OP_NO_SSLv3;
1657 #if OPENSSL_VERSION_NUMBER >= 0x1000100FL
1658     ctx_options |= SSL_OP_NO_TLSv1_1;
1659     ctx_options |= SSL_OP_NO_TLSv1_2;
1660 #endif
1661     break;
1662
1663 #if OPENSSL_VERSION_NUMBER >= 0x1000100FL
1664   case CURL_SSLVERSION_TLSv1_1:
1665     ctx_options |= SSL_OP_NO_SSLv2;
1666     ctx_options |= SSL_OP_NO_SSLv3;
1667     ctx_options |= SSL_OP_NO_TLSv1;
1668     ctx_options |= SSL_OP_NO_TLSv1_2;
1669     break;
1670
1671   case CURL_SSLVERSION_TLSv1_2:
1672     ctx_options |= SSL_OP_NO_SSLv2;
1673     ctx_options |= SSL_OP_NO_SSLv3;
1674     ctx_options |= SSL_OP_NO_TLSv1;
1675     ctx_options |= SSL_OP_NO_TLSv1_1;
1676     break;
1677 #endif
1678
1679 #ifndef OPENSSL_NO_SSL2
1680   case CURL_SSLVERSION_SSLv2:
1681     ctx_options |= SSL_OP_NO_SSLv3;
1682     ctx_options |= SSL_OP_NO_TLSv1;
1683 #if OPENSSL_VERSION_NUMBER >= 0x1000100FL
1684     ctx_options |= SSL_OP_NO_TLSv1_1;
1685     ctx_options |= SSL_OP_NO_TLSv1_2;
1686 #endif
1687     break;
1688 #endif
1689
1690   default:
1691     failf(data, "Unsupported SSL protocol version");
1692     return CURLE_SSL_CONNECT_ERROR;
1693   }
1694
1695   SSL_CTX_set_options(connssl->ctx, ctx_options);
1696
1697 #ifdef USE_NGHTTP2
1698   if(data->set.httpversion == CURL_HTTP_VERSION_2_0) {
1699     if(data->set.ssl_enable_npn) {
1700       SSL_CTX_set_next_proto_select_cb(connssl->ctx, select_next_proto_cb,
1701           conn);
1702     }
1703
1704 #ifdef HAS_ALPN
1705     if(data->set.ssl_enable_alpn) {
1706       protocols[0] = NGHTTP2_PROTO_VERSION_ID_LEN;
1707       memcpy(&protocols[1], NGHTTP2_PROTO_VERSION_ID,
1708           NGHTTP2_PROTO_VERSION_ID_LEN);
1709
1710       protocols[NGHTTP2_PROTO_VERSION_ID_LEN+1] = ALPN_HTTP_1_1_LENGTH;
1711       memcpy(&protocols[NGHTTP2_PROTO_VERSION_ID_LEN+2], ALPN_HTTP_1_1,
1712           ALPN_HTTP_1_1_LENGTH);
1713
1714       /* expects length prefixed preference ordered list of protocols in wire
1715        * format
1716        */
1717       SSL_CTX_set_alpn_protos(connssl->ctx, protocols,
1718           NGHTTP2_PROTO_VERSION_ID_LEN + ALPN_HTTP_1_1_LENGTH + 2);
1719
1720       infof(data, "ALPN, offering %s, %s\n", NGHTTP2_PROTO_VERSION_ID,
1721             ALPN_HTTP_1_1);
1722     }
1723 #endif
1724   }
1725 #endif
1726
1727   if(data->set.str[STRING_CERT] || data->set.str[STRING_CERT_TYPE]) {
1728     if(!cert_stuff(conn,
1729                    connssl->ctx,
1730                    data->set.str[STRING_CERT],
1731                    data->set.str[STRING_CERT_TYPE],
1732                    data->set.str[STRING_KEY],
1733                    data->set.str[STRING_KEY_TYPE])) {
1734       /* failf() is already done in cert_stuff() */
1735       return CURLE_SSL_CERTPROBLEM;
1736     }
1737   }
1738
1739   ciphers = data->set.str[STRING_SSL_CIPHER_LIST];
1740   if(!ciphers)
1741     ciphers = (char *)DEFAULT_CIPHER_SELECTION;
1742   if(!SSL_CTX_set_cipher_list(connssl->ctx, ciphers)) {
1743     failf(data, "failed setting cipher list: %s", ciphers);
1744     return CURLE_SSL_CIPHER;
1745   }
1746
1747 #ifdef USE_TLS_SRP
1748   if(data->set.ssl.authtype == CURL_TLSAUTH_SRP) {
1749     infof(data, "Using TLS-SRP username: %s\n", data->set.ssl.username);
1750
1751     if(!SSL_CTX_set_srp_username(connssl->ctx, data->set.ssl.username)) {
1752       failf(data, "Unable to set SRP user name");
1753       return CURLE_BAD_FUNCTION_ARGUMENT;
1754     }
1755     if(!SSL_CTX_set_srp_password(connssl->ctx,data->set.ssl.password)) {
1756       failf(data, "failed setting SRP password");
1757       return CURLE_BAD_FUNCTION_ARGUMENT;
1758     }
1759     if(!data->set.str[STRING_SSL_CIPHER_LIST]) {
1760       infof(data, "Setting cipher list SRP\n");
1761
1762       if(!SSL_CTX_set_cipher_list(connssl->ctx, "SRP")) {
1763         failf(data, "failed setting SRP cipher list");
1764         return CURLE_SSL_CIPHER;
1765       }
1766     }
1767   }
1768 #endif
1769   if(data->set.str[STRING_SSL_CAFILE] || data->set.str[STRING_SSL_CAPATH]) {
1770     /* tell SSL where to find CA certificates that are used to verify
1771        the servers certificate. */
1772     if(!SSL_CTX_load_verify_locations(connssl->ctx,
1773                                        data->set.str[STRING_SSL_CAFILE],
1774                                        data->set.str[STRING_SSL_CAPATH])) {
1775       if(data->set.ssl.verifypeer) {
1776         /* Fail if we insist on successfully verifying the server. */
1777         failf(data,"error setting certificate verify locations:\n"
1778               "  CAfile: %s\n  CApath: %s",
1779               data->set.str[STRING_SSL_CAFILE]?
1780               data->set.str[STRING_SSL_CAFILE]: "none",
1781               data->set.str[STRING_SSL_CAPATH]?
1782               data->set.str[STRING_SSL_CAPATH] : "none");
1783         return CURLE_SSL_CACERT_BADFILE;
1784       }
1785       else {
1786         /* Just continue with a warning if no strict  certificate verification
1787            is required. */
1788         infof(data, "error setting certificate verify locations,"
1789               " continuing anyway:\n");
1790       }
1791     }
1792     else {
1793       /* Everything is fine. */
1794       infof(data, "successfully set certificate verify locations:\n");
1795     }
1796     infof(data,
1797           "  CAfile: %s\n"
1798           "  CApath: %s\n",
1799           data->set.str[STRING_SSL_CAFILE] ? data->set.str[STRING_SSL_CAFILE]:
1800           "none",
1801           data->set.str[STRING_SSL_CAPATH] ? data->set.str[STRING_SSL_CAPATH]:
1802           "none");
1803   }
1804
1805   if(data->set.str[STRING_SSL_CRLFILE]) {
1806     /* tell SSL where to find CRL file that is used to check certificate
1807      * revocation */
1808     lookup=X509_STORE_add_lookup(SSL_CTX_get_cert_store(connssl->ctx),
1809                                  X509_LOOKUP_file());
1810     if(!lookup ||
1811        (!X509_load_crl_file(lookup,data->set.str[STRING_SSL_CRLFILE],
1812                             X509_FILETYPE_PEM)) ) {
1813       failf(data,"error loading CRL file: %s",
1814             data->set.str[STRING_SSL_CRLFILE]);
1815       return CURLE_SSL_CRL_BADFILE;
1816     }
1817     else {
1818       /* Everything is fine. */
1819       infof(data, "successfully load CRL file:\n");
1820       X509_STORE_set_flags(SSL_CTX_get_cert_store(connssl->ctx),
1821                            X509_V_FLAG_CRL_CHECK|X509_V_FLAG_CRL_CHECK_ALL);
1822     }
1823     infof(data,
1824           "  CRLfile: %s\n", data->set.str[STRING_SSL_CRLFILE] ?
1825           data->set.str[STRING_SSL_CRLFILE]: "none");
1826   }
1827
1828   /* SSL always tries to verify the peer, this only says whether it should
1829    * fail to connect if the verification fails, or if it should continue
1830    * anyway. In the latter case the result of the verification is checked with
1831    * SSL_get_verify_result() below. */
1832   SSL_CTX_set_verify(connssl->ctx,
1833                      data->set.ssl.verifypeer?SSL_VERIFY_PEER:SSL_VERIFY_NONE,
1834                      cert_verify_callback);
1835
1836   /* give application a chance to interfere with SSL set up. */
1837   if(data->set.ssl.fsslctx) {
1838     retcode = (*data->set.ssl.fsslctx)(data, connssl->ctx,
1839                                        data->set.ssl.fsslctxp);
1840     if(retcode) {
1841       failf(data,"error signaled by ssl ctx callback");
1842       return retcode;
1843     }
1844   }
1845
1846   /* Lets make an SSL structure */
1847   if(connssl->handle)
1848     SSL_free(connssl->handle);
1849   connssl->handle = SSL_new(connssl->ctx);
1850   if(!connssl->handle) {
1851     failf(data, "SSL: couldn't create a context (handle)!");
1852     return CURLE_OUT_OF_MEMORY;
1853   }
1854   SSL_set_connect_state(connssl->handle);
1855
1856   connssl->server_cert = 0x0;
1857
1858 #ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
1859   if((0 == Curl_inet_pton(AF_INET, conn->host.name, &addr)) &&
1860 #ifdef ENABLE_IPV6
1861      (0 == Curl_inet_pton(AF_INET6, conn->host.name, &addr)) &&
1862 #endif
1863      sni &&
1864      !SSL_set_tlsext_host_name(connssl->handle, conn->host.name))
1865     infof(data, "WARNING: failed to configure server name indication (SNI) "
1866           "TLS extension\n");
1867 #endif
1868
1869   /* Check if there's a cached ID we can/should use here! */
1870   if(!Curl_ssl_getsessionid(conn, &ssl_sessionid, NULL)) {
1871     /* we got a session id, use it! */
1872     if(!SSL_set_session(connssl->handle, ssl_sessionid)) {
1873       failf(data, "SSL: SSL_set_session failed: %s",
1874             ERR_error_string(ERR_get_error(),NULL));
1875       return CURLE_SSL_CONNECT_ERROR;
1876     }
1877     /* Informational message */
1878     infof (data, "SSL re-using session ID\n");
1879   }
1880
1881   /* pass the raw socket into the SSL layers */
1882   if(!SSL_set_fd(connssl->handle, (int)sockfd)) {
1883     failf(data, "SSL: SSL_set_fd failed: %s",
1884           ERR_error_string(ERR_get_error(),NULL));
1885     return CURLE_SSL_CONNECT_ERROR;
1886   }
1887
1888   connssl->connecting_state = ssl_connect_2;
1889   return CURLE_OK;
1890 }
1891
1892 static CURLcode
1893 ossl_connect_step2(struct connectdata *conn, int sockindex)
1894 {
1895   struct SessionHandle *data = conn->data;
1896   int err;
1897   struct ssl_connect_data *connssl = &conn->ssl[sockindex];
1898   DEBUGASSERT(ssl_connect_2 == connssl->connecting_state
1899              || ssl_connect_2_reading == connssl->connecting_state
1900              || ssl_connect_2_writing == connssl->connecting_state);
1901
1902   ERR_clear_error();
1903
1904   err = SSL_connect(connssl->handle);
1905
1906   /* 1  is fine
1907      0  is "not successful but was shut down controlled"
1908      <0 is "handshake was not successful, because a fatal error occurred" */
1909   if(1 != err) {
1910     int detail = SSL_get_error(connssl->handle, err);
1911
1912     if(SSL_ERROR_WANT_READ == detail) {
1913       connssl->connecting_state = ssl_connect_2_reading;
1914       return CURLE_OK;
1915     }
1916     else if(SSL_ERROR_WANT_WRITE == detail) {
1917       connssl->connecting_state = ssl_connect_2_writing;
1918       return CURLE_OK;
1919     }
1920     else {
1921       /* untreated error */
1922       unsigned long errdetail;
1923       char error_buffer[256]; /* OpenSSL documents that this must be at least
1924                                  256 bytes long. */
1925       CURLcode rc;
1926       const char *cert_problem = NULL;
1927       long lerr;
1928
1929       connssl->connecting_state = ssl_connect_2; /* the connection failed,
1930                                                     we're not waiting for
1931                                                     anything else. */
1932
1933       errdetail = ERR_get_error(); /* Gets the earliest error code from the
1934                                       thread's error queue and removes the
1935                                       entry. */
1936
1937       switch(errdetail) {
1938       case 0x1407E086:
1939         /* 1407E086:
1940            SSL routines:
1941            SSL2_SET_CERTIFICATE:
1942            certificate verify failed */
1943         /* fall-through */
1944       case 0x14090086:
1945         /* 14090086:
1946            SSL routines:
1947            SSL3_GET_SERVER_CERTIFICATE:
1948            certificate verify failed */
1949         rc = CURLE_SSL_CACERT;
1950
1951         lerr = SSL_get_verify_result(connssl->handle);
1952         if(lerr != X509_V_OK) {
1953           snprintf(error_buffer, sizeof(error_buffer),
1954                    "SSL certificate problem: %s",
1955                    X509_verify_cert_error_string(lerr));
1956         }
1957         else
1958           cert_problem = "SSL certificate problem, verify that the CA cert is"
1959             " OK.";
1960
1961         break;
1962       default:
1963         rc = CURLE_SSL_CONNECT_ERROR;
1964         SSL_strerror(errdetail, error_buffer, sizeof(error_buffer));
1965         break;
1966       }
1967
1968       /* detail is already set to the SSL error above */
1969
1970       /* If we e.g. use SSLv2 request-method and the server doesn't like us
1971        * (RST connection etc.), OpenSSL gives no explanation whatsoever and
1972        * the SO_ERROR is also lost.
1973        */
1974       if(CURLE_SSL_CONNECT_ERROR == rc && errdetail == 0) {
1975         failf(data, "Unknown SSL protocol error in connection to %s:%ld ",
1976               conn->host.name, conn->remote_port);
1977         return rc;
1978       }
1979       /* Could be a CERT problem */
1980
1981       failf(data, "%s%s", cert_problem ? cert_problem : "", error_buffer);
1982       return rc;
1983     }
1984   }
1985   else {
1986     /* we have been connected fine, we're not waiting for anything else. */
1987     connssl->connecting_state = ssl_connect_3;
1988
1989     /* Informational message */
1990     infof (data, "SSL connection using %s / %s\n",
1991            get_ssl_version_txt(SSL_get_session(connssl->handle)),
1992            SSL_get_cipher(connssl->handle));
1993
1994 #ifdef HAS_ALPN
1995     /* Sets data and len to negotiated protocol, len is 0 if no protocol was
1996      * negotiated
1997      */
1998     if(data->set.ssl_enable_alpn) {
1999       const unsigned char* neg_protocol;
2000       unsigned int len;
2001       SSL_get0_alpn_selected(connssl->handle, &neg_protocol, &len);
2002       if(len != 0) {
2003         infof(data, "ALPN, server accepted to use %.*s\n", len, neg_protocol);
2004
2005         if(len == NGHTTP2_PROTO_VERSION_ID_LEN &&
2006            memcmp(NGHTTP2_PROTO_VERSION_ID, neg_protocol, len) == 0) {
2007              conn->negnpn = NPN_HTTP2;
2008         }
2009         else if(len == ALPN_HTTP_1_1_LENGTH && memcmp(ALPN_HTTP_1_1,
2010             neg_protocol, ALPN_HTTP_1_1_LENGTH) == 0) {
2011           conn->negnpn = NPN_HTTP1_1;
2012         }
2013       }
2014       else {
2015         infof(data, "ALPN, server did not agree to a protocol\n");
2016       }
2017     }
2018 #endif
2019
2020     return CURLE_OK;
2021   }
2022 }
2023
2024 static int asn1_object_dump(ASN1_OBJECT *a, char *buf, size_t len)
2025 {
2026   int i, ilen;
2027
2028   if((ilen = (int)len) < 0)
2029     return 1; /* buffer too big */
2030
2031   i = i2t_ASN1_OBJECT(buf, ilen, a);
2032
2033   if(i >= ilen)
2034     return 1; /* buffer too small */
2035
2036   return 0;
2037 }
2038
2039 static void pubkey_show(struct SessionHandle *data,
2040                         int num,
2041                         const char *type,
2042                         const char *name,
2043                         unsigned char *raw,
2044                         int len)
2045 {
2046   size_t left;
2047   int i;
2048   char namebuf[32];
2049   char *buffer;
2050
2051   left = len*3 + 1;
2052   buffer = malloc(left);
2053   if(buffer) {
2054     char *ptr=buffer;
2055     snprintf(namebuf, sizeof(namebuf), "%s(%s)", type, name);
2056     for(i=0; i< len; i++) {
2057       snprintf(ptr, left, "%02x:", raw[i]);
2058       ptr += 3;
2059       left -= 3;
2060     }
2061     infof(data, "   %s: %s\n", namebuf, buffer);
2062     Curl_ssl_push_certinfo(data, num, namebuf, buffer);
2063     free(buffer);
2064   }
2065 }
2066
2067 #define print_pubkey_BN(_type, _name, _num)    \
2068 do {                              \
2069   if(pubkey->pkey._type->_name != NULL) { \
2070     int len = BN_num_bytes(pubkey->pkey._type->_name);  \
2071     if(len < CERTBUFFERSIZE) {                                    \
2072       BN_bn2bin(pubkey->pkey._type->_name, (unsigned char*)bufp); \
2073       bufp[len] = 0;                                                    \
2074       pubkey_show(data, _num, #_type, #_name, (unsigned char*)bufp, len); \
2075     } \
2076   } \
2077 } WHILE_FALSE
2078
2079 static int X509V3_ext(struct SessionHandle *data,
2080                       int certnum,
2081                       STACK_OF(X509_EXTENSION) *exts)
2082 {
2083   int i;
2084   size_t j;
2085
2086   if(sk_X509_EXTENSION_num(exts) <= 0)
2087     /* no extensions, bail out */
2088     return 1;
2089
2090   for(i=0; i<sk_X509_EXTENSION_num(exts); i++) {
2091     ASN1_OBJECT *obj;
2092     X509_EXTENSION *ext = sk_X509_EXTENSION_value(exts, i);
2093     BUF_MEM *biomem;
2094     char buf[512];
2095     char *ptr=buf;
2096     char namebuf[128];
2097     BIO *bio_out = BIO_new(BIO_s_mem());
2098
2099     if(!bio_out)
2100       return 1;
2101
2102     obj = X509_EXTENSION_get_object(ext);
2103
2104     asn1_object_dump(obj, namebuf, sizeof(namebuf));
2105
2106     infof(data, "%s: %s\n", namebuf,
2107           X509_EXTENSION_get_critical(ext)?"(critical)":"");
2108
2109     if(!X509V3_EXT_print(bio_out, ext, 0, 0))
2110       M_ASN1_OCTET_STRING_print(bio_out, ext->value);
2111
2112     BIO_get_mem_ptr(bio_out, &biomem);
2113
2114     /* biomem->length bytes at biomem->data, this little loop here is only
2115        done for the infof() call, we send the "raw" data to the certinfo
2116        function */
2117     for(j=0; j<(size_t)biomem->length; j++) {
2118       const char *sep="";
2119       if(biomem->data[j] == '\n') {
2120         sep=", ";
2121         j++; /* skip the newline */
2122       };
2123       while((j<(size_t)biomem->length) && (biomem->data[j] == ' '))
2124         j++;
2125       if(j<(size_t)biomem->length)
2126         ptr+=snprintf(ptr, sizeof(buf)-(ptr-buf), "%s%c", sep,
2127                       biomem->data[j]);
2128     }
2129     infof(data, "  %s\n", buf);
2130
2131     Curl_ssl_push_certinfo(data, certnum, namebuf, buf);
2132
2133     BIO_free(bio_out);
2134
2135   }
2136   return 0; /* all is fine */
2137 }
2138
2139
2140 static void X509_signature(struct SessionHandle *data,
2141                            int numcert,
2142                            ASN1_STRING *sig)
2143 {
2144   char buf[1024];
2145   char *ptr = buf;
2146   int i;
2147   for(i=0; i<sig->length; i++)
2148     ptr+=snprintf(ptr, sizeof(buf)-(ptr-buf), "%02x:", sig->data[i]);
2149
2150   infof(data, " Signature: %s\n", buf);
2151   Curl_ssl_push_certinfo(data, numcert, "Signature", buf);
2152 }
2153
2154 static void dumpcert(struct SessionHandle *data, X509 *x, int numcert)
2155 {
2156   BIO *bio_out = BIO_new(BIO_s_mem());
2157   BUF_MEM *biomem;
2158
2159   /* this outputs the cert in this 64 column wide style with newlines and
2160      -----BEGIN CERTIFICATE----- texts and more */
2161   PEM_write_bio_X509(bio_out, x);
2162
2163   BIO_get_mem_ptr(bio_out, &biomem);
2164
2165   Curl_ssl_push_certinfo_len(data, numcert,
2166                              "Cert", biomem->data, biomem->length);
2167
2168   BIO_free(bio_out);
2169
2170 }
2171
2172 /*
2173  * This size was previously 512 which has been reported "too small" without
2174  * any specifics, so it was enlarged to allow more data to get shown uncut.
2175  * The "perfect" size is yet to figure out.
2176  */
2177 #define CERTBUFFERSIZE 8192
2178
2179 static CURLcode get_cert_chain(struct connectdata *conn,
2180                                struct ssl_connect_data *connssl)
2181
2182 {
2183   STACK_OF(X509) *sk;
2184   int i;
2185   char *bufp;
2186   struct SessionHandle *data = conn->data;
2187   int numcerts;
2188
2189   bufp = malloc(CERTBUFFERSIZE);
2190   if(!bufp)
2191     return CURLE_OUT_OF_MEMORY;
2192
2193   sk = SSL_get_peer_cert_chain(connssl->handle);
2194   if(!sk) {
2195     free(bufp);
2196     return CURLE_OUT_OF_MEMORY;
2197   }
2198
2199   numcerts = sk_X509_num(sk);
2200   if(Curl_ssl_init_certinfo(data, numcerts)) {
2201     free(bufp);
2202     return CURLE_OUT_OF_MEMORY;
2203   }
2204
2205   infof(data, "--- Certificate chain\n");
2206   for(i=0; i<numcerts; i++) {
2207     long value;
2208     ASN1_INTEGER *num;
2209     ASN1_TIME *certdate;
2210
2211     /* get the certs in "importance order" */
2212 #if 0
2213     X509 *x = sk_X509_value(sk, numcerts - i - 1);
2214 #else
2215     X509 *x = sk_X509_value(sk, i);
2216 #endif
2217
2218     X509_CINF *cinf;
2219     EVP_PKEY *pubkey=NULL;
2220     int j;
2221     char *ptr;
2222
2223     (void)x509_name_oneline(X509_get_subject_name(x), bufp, CERTBUFFERSIZE);
2224     infof(data, "%2d Subject: %s\n", i, bufp);
2225     Curl_ssl_push_certinfo(data, i, "Subject", bufp);
2226
2227     (void)x509_name_oneline(X509_get_issuer_name(x), bufp, CERTBUFFERSIZE);
2228     infof(data, "   Issuer: %s\n", bufp);
2229     Curl_ssl_push_certinfo(data, i, "Issuer", bufp);
2230
2231     value = X509_get_version(x);
2232     infof(data, "   Version: %lu (0x%lx)\n", value+1, value);
2233     snprintf(bufp, CERTBUFFERSIZE, "%lx", value);
2234     Curl_ssl_push_certinfo(data, i, "Version", bufp); /* hex */
2235
2236     num=X509_get_serialNumber(x);
2237     if(num->length <= 4) {
2238       value = ASN1_INTEGER_get(num);
2239       infof(data,"   Serial Number: %ld (0x%lx)\n", value, value);
2240       snprintf(bufp, CERTBUFFERSIZE, "%lx", value);
2241     }
2242     else {
2243       int left = CERTBUFFERSIZE;
2244
2245       ptr = bufp;
2246       *ptr++ = 0;
2247       if(num->type == V_ASN1_NEG_INTEGER)
2248         *ptr++='-';
2249
2250       for(j=0; (j<num->length) && (left>=4); j++) {
2251         /* TODO: length restrictions */
2252         snprintf(ptr, 3, "%02x%c",num->data[j],
2253                  ((j+1 == num->length)?'\n':':'));
2254         ptr += 3;
2255         left-=4;
2256       }
2257       if(num->length)
2258         infof(data,"   Serial Number: %s\n", bufp);
2259       else
2260         bufp[0]=0;
2261     }
2262     if(bufp[0])
2263       Curl_ssl_push_certinfo(data, i, "Serial Number", bufp); /* hex */
2264
2265     cinf = x->cert_info;
2266
2267     j = asn1_object_dump(cinf->signature->algorithm, bufp, CERTBUFFERSIZE);
2268     if(!j) {
2269       infof(data, "   Signature Algorithm: %s\n", bufp);
2270       Curl_ssl_push_certinfo(data, i, "Signature Algorithm", bufp);
2271     }
2272
2273     certdate = X509_get_notBefore(x);
2274     asn1_output(certdate, bufp, CERTBUFFERSIZE);
2275     infof(data, "   Start date: %s\n", bufp);
2276     Curl_ssl_push_certinfo(data, i, "Start date", bufp);
2277
2278     certdate = X509_get_notAfter(x);
2279     asn1_output(certdate, bufp, CERTBUFFERSIZE);
2280     infof(data, "   Expire date: %s\n", bufp);
2281     Curl_ssl_push_certinfo(data, i, "Expire date", bufp);
2282
2283     j = asn1_object_dump(cinf->key->algor->algorithm, bufp, CERTBUFFERSIZE);
2284     if(!j) {
2285       infof(data, "   Public Key Algorithm: %s\n", bufp);
2286       Curl_ssl_push_certinfo(data, i, "Public Key Algorithm", bufp);
2287     }
2288
2289     pubkey = X509_get_pubkey(x);
2290     if(!pubkey)
2291       infof(data, "   Unable to load public key\n");
2292     else {
2293       switch(pubkey->type) {
2294       case EVP_PKEY_RSA:
2295         infof(data,  "   RSA Public Key (%d bits)\n",
2296               BN_num_bits(pubkey->pkey.rsa->n));
2297         snprintf(bufp, CERTBUFFERSIZE, "%d", BN_num_bits(pubkey->pkey.rsa->n));
2298         Curl_ssl_push_certinfo(data, i, "RSA Public Key", bufp);
2299
2300         print_pubkey_BN(rsa, n, i);
2301         print_pubkey_BN(rsa, e, i);
2302         print_pubkey_BN(rsa, d, i);
2303         print_pubkey_BN(rsa, p, i);
2304         print_pubkey_BN(rsa, q, i);
2305         print_pubkey_BN(rsa, dmp1, i);
2306         print_pubkey_BN(rsa, dmq1, i);
2307         print_pubkey_BN(rsa, iqmp, i);
2308         break;
2309       case EVP_PKEY_DSA:
2310         print_pubkey_BN(dsa, p, i);
2311         print_pubkey_BN(dsa, q, i);
2312         print_pubkey_BN(dsa, g, i);
2313         print_pubkey_BN(dsa, priv_key, i);
2314         print_pubkey_BN(dsa, pub_key, i);
2315         break;
2316       case EVP_PKEY_DH:
2317         print_pubkey_BN(dh, p, i);
2318         print_pubkey_BN(dh, g, i);
2319         print_pubkey_BN(dh, priv_key, i);
2320         print_pubkey_BN(dh, pub_key, i);
2321         break;
2322 #if 0
2323       case EVP_PKEY_EC: /* symbol not present in OpenSSL 0.9.6 */
2324         /* left TODO */
2325         break;
2326 #endif
2327       }
2328       EVP_PKEY_free(pubkey);
2329     }
2330
2331     X509V3_ext(data, i, cinf->extensions);
2332
2333     X509_signature(data, i, x->signature);
2334
2335     dumpcert(data, x, i);
2336   }
2337
2338   free(bufp);
2339
2340   return CURLE_OK;
2341 }
2342
2343 /*
2344  * Get the server cert, verify it and show it etc, only call failf() if the
2345  * 'strict' argument is TRUE as otherwise all this is for informational
2346  * purposes only!
2347  *
2348  * We check certificates to authenticate the server; otherwise we risk
2349  * man-in-the-middle attack.
2350  */
2351 static CURLcode servercert(struct connectdata *conn,
2352                            struct ssl_connect_data *connssl,
2353                            bool strict)
2354 {
2355   CURLcode retcode = CURLE_OK;
2356   int rc;
2357   long lerr;
2358   ASN1_TIME *certdate;
2359   struct SessionHandle *data = conn->data;
2360   X509 *issuer;
2361   FILE *fp;
2362   char *buffer = data->state.buffer;
2363
2364   if(data->set.ssl.certinfo)
2365     /* we've been asked to gather certificate info! */
2366     (void)get_cert_chain(conn, connssl);
2367
2368   connssl->server_cert = SSL_get_peer_certificate(connssl->handle);
2369   if(!connssl->server_cert) {
2370     if(strict)
2371       failf(data, "SSL: couldn't get peer certificate!");
2372     return CURLE_PEER_FAILED_VERIFICATION;
2373   }
2374   infof (data, "Server certificate:\n");
2375
2376   rc = x509_name_oneline(X509_get_subject_name(connssl->server_cert),
2377                          buffer, BUFSIZE);
2378   infof(data, "\t subject: %s\n", rc?"[NONE]":buffer);
2379
2380   certdate = X509_get_notBefore(connssl->server_cert);
2381   asn1_output(certdate, buffer, BUFSIZE);
2382   infof(data, "\t start date: %s\n", buffer);
2383
2384   certdate = X509_get_notAfter(connssl->server_cert);
2385   asn1_output(certdate, buffer, BUFSIZE);
2386   infof(data, "\t expire date: %s\n", buffer);
2387
2388   if(data->set.ssl.verifyhost) {
2389     retcode = verifyhost(conn, connssl->server_cert);
2390     if(retcode) {
2391       X509_free(connssl->server_cert);
2392       connssl->server_cert = NULL;
2393       return retcode;
2394     }
2395   }
2396
2397   rc = x509_name_oneline(X509_get_issuer_name(connssl->server_cert),
2398                          buffer, BUFSIZE);
2399   if(rc) {
2400     if(strict)
2401       failf(data, "SSL: couldn't get X509-issuer name!");
2402     retcode = CURLE_SSL_CONNECT_ERROR;
2403   }
2404   else {
2405     infof(data, "\t issuer: %s\n", buffer);
2406
2407     /* We could do all sorts of certificate verification stuff here before
2408        deallocating the certificate. */
2409
2410     /* e.g. match issuer name with provided issuer certificate */
2411     if(data->set.str[STRING_SSL_ISSUERCERT]) {
2412       fp=fopen(data->set.str[STRING_SSL_ISSUERCERT],"r");
2413       if(!fp) {
2414         if(strict)
2415           failf(data, "SSL: Unable to open issuer cert (%s)",
2416                 data->set.str[STRING_SSL_ISSUERCERT]);
2417         X509_free(connssl->server_cert);
2418         connssl->server_cert = NULL;
2419         return CURLE_SSL_ISSUER_ERROR;
2420       }
2421       issuer = PEM_read_X509(fp,NULL,ZERO_NULL,NULL);
2422       if(!issuer) {
2423         if(strict)
2424           failf(data, "SSL: Unable to read issuer cert (%s)",
2425                 data->set.str[STRING_SSL_ISSUERCERT]);
2426         X509_free(connssl->server_cert);
2427         X509_free(issuer);
2428         fclose(fp);
2429         return CURLE_SSL_ISSUER_ERROR;
2430       }
2431       fclose(fp);
2432       if(X509_check_issued(issuer,connssl->server_cert) != X509_V_OK) {
2433         if(strict)
2434           failf(data, "SSL: Certificate issuer check failed (%s)",
2435                 data->set.str[STRING_SSL_ISSUERCERT]);
2436         X509_free(connssl->server_cert);
2437         X509_free(issuer);
2438         connssl->server_cert = NULL;
2439         return CURLE_SSL_ISSUER_ERROR;
2440       }
2441       infof(data, "\t SSL certificate issuer check ok (%s)\n",
2442             data->set.str[STRING_SSL_ISSUERCERT]);
2443       X509_free(issuer);
2444     }
2445
2446     lerr = data->set.ssl.certverifyresult=
2447       SSL_get_verify_result(connssl->handle);
2448     if(data->set.ssl.certverifyresult != X509_V_OK) {
2449       if(data->set.ssl.verifypeer) {
2450         /* We probably never reach this, because SSL_connect() will fail
2451            and we return earlier if verifypeer is set? */
2452         if(strict)
2453           failf(data, "SSL certificate verify result: %s (%ld)",
2454                 X509_verify_cert_error_string(lerr), lerr);
2455         retcode = CURLE_PEER_FAILED_VERIFICATION;
2456       }
2457       else
2458         infof(data, "\t SSL certificate verify result: %s (%ld),"
2459               " continuing anyway.\n",
2460               X509_verify_cert_error_string(lerr), lerr);
2461     }
2462     else
2463       infof(data, "\t SSL certificate verify ok.\n");
2464   }
2465
2466   X509_free(connssl->server_cert);
2467   connssl->server_cert = NULL;
2468   connssl->connecting_state = ssl_connect_done;
2469
2470   return retcode;
2471 }
2472
2473
2474 static CURLcode
2475 ossl_connect_step3(struct connectdata *conn,
2476                    int sockindex)
2477 {
2478   CURLcode retcode = CURLE_OK;
2479   void *old_ssl_sessionid=NULL;
2480   struct SessionHandle *data = conn->data;
2481   struct ssl_connect_data *connssl = &conn->ssl[sockindex];
2482   int incache;
2483   SSL_SESSION *our_ssl_sessionid;
2484
2485   DEBUGASSERT(ssl_connect_3 == connssl->connecting_state);
2486
2487 #ifdef HAVE_SSL_GET1_SESSION
2488   our_ssl_sessionid = SSL_get1_session(connssl->handle);
2489
2490   /* SSL_get1_session() will increment the reference
2491      count and the session will stay in memory until explicitly freed with
2492      SSL_SESSION_free(3), regardless of its state.
2493      This function was introduced in openssl 0.9.5a. */
2494 #else
2495   our_ssl_sessionid = SSL_get_session(connssl->handle);
2496
2497   /* if SSL_get1_session() is unavailable, use SSL_get_session().
2498      This is an inferior option because the session can be flushed
2499      at any time by openssl. It is included only so curl compiles
2500      under versions of openssl < 0.9.5a.
2501
2502      WARNING: How curl behaves if it's session is flushed is
2503      untested.
2504   */
2505 #endif
2506
2507   incache = !(Curl_ssl_getsessionid(conn, &old_ssl_sessionid, NULL));
2508   if(incache) {
2509     if(old_ssl_sessionid != our_ssl_sessionid) {
2510       infof(data, "old SSL session ID is stale, removing\n");
2511       Curl_ssl_delsessionid(conn, old_ssl_sessionid);
2512       incache = FALSE;
2513     }
2514   }
2515   if(!incache) {
2516     retcode = Curl_ssl_addsessionid(conn, our_ssl_sessionid,
2517                                     0 /* unknown size */);
2518     if(retcode) {
2519       failf(data, "failed to store ssl session");
2520       return retcode;
2521     }
2522   }
2523 #ifdef HAVE_SSL_GET1_SESSION
2524   else {
2525     /* Session was incache, so refcount already incremented earlier.
2526      * Avoid further increments with each SSL_get1_session() call.
2527      * This does not free the session as refcount remains > 0
2528      */
2529     SSL_SESSION_free(our_ssl_sessionid);
2530   }
2531 #endif
2532
2533   /*
2534    * We check certificates to authenticate the server; otherwise we risk
2535    * man-in-the-middle attack; NEVERTHELESS, if we're told explicitly not to
2536    * verify the peer ignore faults and failures from the server cert
2537    * operations.
2538    */
2539
2540   if(!data->set.ssl.verifypeer && !data->set.ssl.verifyhost)
2541     (void)servercert(conn, connssl, FALSE);
2542   else
2543     retcode = servercert(conn, connssl, TRUE);
2544
2545   if(CURLE_OK == retcode)
2546     connssl->connecting_state = ssl_connect_done;
2547   return retcode;
2548 }
2549
2550 static Curl_recv ossl_recv;
2551 static Curl_send ossl_send;
2552
2553 static CURLcode
2554 ossl_connect_common(struct connectdata *conn,
2555                     int sockindex,
2556                     bool nonblocking,
2557                     bool *done)
2558 {
2559   CURLcode retcode;
2560   struct SessionHandle *data = conn->data;
2561   struct ssl_connect_data *connssl = &conn->ssl[sockindex];
2562   curl_socket_t sockfd = conn->sock[sockindex];
2563   long timeout_ms;
2564   int what;
2565
2566   /* check if the connection has already been established */
2567   if(ssl_connection_complete == connssl->state) {
2568     *done = TRUE;
2569     return CURLE_OK;
2570   }
2571
2572   if(ssl_connect_1==connssl->connecting_state) {
2573     /* Find out how much more time we're allowed */
2574     timeout_ms = Curl_timeleft(data, NULL, TRUE);
2575
2576     if(timeout_ms < 0) {
2577       /* no need to continue if time already is up */
2578       failf(data, "SSL connection timeout");
2579       return CURLE_OPERATION_TIMEDOUT;
2580     }
2581     retcode = ossl_connect_step1(conn, sockindex);
2582     if(retcode)
2583       return retcode;
2584   }
2585
2586   while(ssl_connect_2 == connssl->connecting_state ||
2587         ssl_connect_2_reading == connssl->connecting_state ||
2588         ssl_connect_2_writing == connssl->connecting_state) {
2589
2590     /* check allowed time left */
2591     timeout_ms = Curl_timeleft(data, NULL, TRUE);
2592
2593     if(timeout_ms < 0) {
2594       /* no need to continue if time already is up */
2595       failf(data, "SSL connection timeout");
2596       return CURLE_OPERATION_TIMEDOUT;
2597     }
2598
2599     /* if ssl is expecting something, check if it's available. */
2600     if(connssl->connecting_state == ssl_connect_2_reading
2601         || connssl->connecting_state == ssl_connect_2_writing) {
2602
2603       curl_socket_t writefd = ssl_connect_2_writing==
2604         connssl->connecting_state?sockfd:CURL_SOCKET_BAD;
2605       curl_socket_t readfd = ssl_connect_2_reading==
2606         connssl->connecting_state?sockfd:CURL_SOCKET_BAD;
2607
2608       what = Curl_socket_ready(readfd, writefd, nonblocking?0:timeout_ms);
2609       if(what < 0) {
2610         /* fatal error */
2611         failf(data, "select/poll on SSL socket, errno: %d", SOCKERRNO);
2612         return CURLE_SSL_CONNECT_ERROR;
2613       }
2614       else if(0 == what) {
2615         if(nonblocking) {
2616           *done = FALSE;
2617           return CURLE_OK;
2618         }
2619         else {
2620           /* timeout */
2621           failf(data, "SSL connection timeout");
2622           return CURLE_OPERATION_TIMEDOUT;
2623         }
2624       }
2625       /* socket is readable or writable */
2626     }
2627
2628     /* Run transaction, and return to the caller if it failed or if this
2629      * connection is done nonblocking and this loop would execute again. This
2630      * permits the owner of a multi handle to abort a connection attempt
2631      * before step2 has completed while ensuring that a client using select()
2632      * or epoll() will always have a valid fdset to wait on.
2633      */
2634     retcode = ossl_connect_step2(conn, sockindex);
2635     if(retcode || (nonblocking &&
2636                    (ssl_connect_2 == connssl->connecting_state ||
2637                     ssl_connect_2_reading == connssl->connecting_state ||
2638                     ssl_connect_2_writing == connssl->connecting_state)))
2639       return retcode;
2640
2641   } /* repeat step2 until all transactions are done. */
2642
2643
2644   if(ssl_connect_3==connssl->connecting_state) {
2645     retcode = ossl_connect_step3(conn, sockindex);
2646     if(retcode)
2647       return retcode;
2648   }
2649
2650   if(ssl_connect_done==connssl->connecting_state) {
2651     connssl->state = ssl_connection_complete;
2652     conn->recv[sockindex] = ossl_recv;
2653     conn->send[sockindex] = ossl_send;
2654     *done = TRUE;
2655   }
2656   else
2657     *done = FALSE;
2658
2659   /* Reset our connect state machine */
2660   connssl->connecting_state = ssl_connect_1;
2661
2662   return CURLE_OK;
2663 }
2664
2665 CURLcode
2666 Curl_ossl_connect_nonblocking(struct connectdata *conn,
2667                               int sockindex,
2668                               bool *done)
2669 {
2670   return ossl_connect_common(conn, sockindex, TRUE, done);
2671 }
2672
2673 CURLcode
2674 Curl_ossl_connect(struct connectdata *conn,
2675                   int sockindex)
2676 {
2677   CURLcode retcode;
2678   bool done = FALSE;
2679
2680   retcode = ossl_connect_common(conn, sockindex, FALSE, &done);
2681   if(retcode)
2682     return retcode;
2683
2684   DEBUGASSERT(done);
2685
2686   return CURLE_OK;
2687 }
2688
2689 bool Curl_ossl_data_pending(const struct connectdata *conn,
2690                             int connindex)
2691 {
2692   if(conn->ssl[connindex].handle)
2693     /* SSL is in use */
2694     return (0 != SSL_pending(conn->ssl[connindex].handle)) ? TRUE : FALSE;
2695   else
2696     return FALSE;
2697 }
2698
2699 static ssize_t ossl_send(struct connectdata *conn,
2700                          int sockindex,
2701                          const void *mem,
2702                          size_t len,
2703                          CURLcode *curlcode)
2704 {
2705   /* SSL_write() is said to return 'int' while write() and send() returns
2706      'size_t' */
2707   int err;
2708   char error_buffer[120]; /* OpenSSL documents that this must be at least 120
2709                              bytes long. */
2710   unsigned long sslerror;
2711   int memlen;
2712   int rc;
2713
2714   ERR_clear_error();
2715
2716   memlen = (len > (size_t)INT_MAX) ? INT_MAX : (int)len;
2717   rc = SSL_write(conn->ssl[sockindex].handle, mem, memlen);
2718
2719   if(rc <= 0) {
2720     err = SSL_get_error(conn->ssl[sockindex].handle, rc);
2721
2722     switch(err) {
2723     case SSL_ERROR_WANT_READ:
2724     case SSL_ERROR_WANT_WRITE:
2725       /* The operation did not complete; the same TLS/SSL I/O function
2726          should be called again later. This is basically an EWOULDBLOCK
2727          equivalent. */
2728       *curlcode = CURLE_AGAIN;
2729       return -1;
2730     case SSL_ERROR_SYSCALL:
2731       failf(conn->data, "SSL_write() returned SYSCALL, errno = %d",
2732             SOCKERRNO);
2733       *curlcode = CURLE_SEND_ERROR;
2734       return -1;
2735     case SSL_ERROR_SSL:
2736       /*  A failure in the SSL library occurred, usually a protocol error.
2737           The OpenSSL error queue contains more information on the error. */
2738       sslerror = ERR_get_error();
2739       failf(conn->data, "SSL_write() error: %s",
2740             ERR_error_string(sslerror, error_buffer));
2741       *curlcode = CURLE_SEND_ERROR;
2742       return -1;
2743     }
2744     /* a true error */
2745     failf(conn->data, "SSL_write() return error %d", err);
2746     *curlcode = CURLE_SEND_ERROR;
2747     return -1;
2748   }
2749   return (ssize_t)rc; /* number of bytes */
2750 }
2751
2752 static ssize_t ossl_recv(struct connectdata *conn, /* connection data */
2753                          int num,                  /* socketindex */
2754                          char *buf,                /* store read data here */
2755                          size_t buffersize,        /* max amount to read */
2756                          CURLcode *curlcode)
2757 {
2758   char error_buffer[120]; /* OpenSSL documents that this must be at
2759                              least 120 bytes long. */
2760   unsigned long sslerror;
2761   ssize_t nread;
2762   int buffsize;
2763
2764   ERR_clear_error();
2765
2766   buffsize = (buffersize > (size_t)INT_MAX) ? INT_MAX : (int)buffersize;
2767   nread = (ssize_t)SSL_read(conn->ssl[num].handle, buf, buffsize);
2768   if(nread <= 0) {
2769     /* failed SSL_read */
2770     int err = SSL_get_error(conn->ssl[num].handle, (int)nread);
2771
2772     switch(err) {
2773     case SSL_ERROR_NONE: /* this is not an error */
2774     case SSL_ERROR_ZERO_RETURN: /* no more data */
2775       break;
2776     case SSL_ERROR_WANT_READ:
2777     case SSL_ERROR_WANT_WRITE:
2778       /* there's data pending, re-invoke SSL_read() */
2779       *curlcode = CURLE_AGAIN;
2780       return -1;
2781     default:
2782       /* openssl/ssl.h for SSL_ERROR_SYSCALL says "look at error stack/return
2783          value/errno" */
2784       /* http://www.openssl.org/docs/crypto/ERR_get_error.html */
2785       sslerror = ERR_get_error();
2786       if((nread < 0) || sslerror) {
2787         /* If the return code was negative or there actually is an error in the
2788            queue */
2789         failf(conn->data, "SSL read: %s, errno %d",
2790               ERR_error_string(sslerror, error_buffer),
2791               SOCKERRNO);
2792         *curlcode = CURLE_RECV_ERROR;
2793         return -1;
2794       }
2795     }
2796   }
2797   return nread;
2798 }
2799
2800 size_t Curl_ossl_version(char *buffer, size_t size)
2801 {
2802 #ifdef YASSL_VERSION
2803   /* yassl provides an OpenSSL API compatibility layer so it looks identical
2804      to OpenSSL in all other aspects */
2805   return snprintf(buffer, size, "yassl/%s", YASSL_VERSION);
2806 #else /* YASSL_VERSION */
2807
2808 #if(SSLEAY_VERSION_NUMBER >= 0x905000)
2809   {
2810     char sub[2];
2811     unsigned long ssleay_value;
2812     sub[1]='\0';
2813     ssleay_value=SSLeay();
2814     if(ssleay_value < 0x906000) {
2815       ssleay_value=SSLEAY_VERSION_NUMBER;
2816       sub[0]='\0';
2817     }
2818     else {
2819       if(ssleay_value&0xff0) {
2820         sub[0]=(char)(((ssleay_value>>4)&0xff) + 'a' -1);
2821       }
2822       else
2823         sub[0]='\0';
2824     }
2825
2826     return snprintf(buffer, size, "OpenSSL/%lx.%lx.%lx%s",
2827                     (ssleay_value>>28)&0xf,
2828                     (ssleay_value>>20)&0xff,
2829                     (ssleay_value>>12)&0xff,
2830                     sub);
2831   }
2832
2833 #else /* SSLEAY_VERSION_NUMBER is less than 0.9.5 */
2834
2835 #if(SSLEAY_VERSION_NUMBER >= 0x900000)
2836   return snprintf(buffer, size, "OpenSSL/%lx.%lx.%lx",
2837                   (SSLEAY_VERSION_NUMBER>>28)&0xff,
2838                   (SSLEAY_VERSION_NUMBER>>20)&0xff,
2839                   (SSLEAY_VERSION_NUMBER>>12)&0xf);
2840
2841 #else /* (SSLEAY_VERSION_NUMBER >= 0x900000) */
2842   {
2843     char sub[2];
2844     sub[1]='\0';
2845     if(SSLEAY_VERSION_NUMBER&0x0f) {
2846       sub[0]=(SSLEAY_VERSION_NUMBER&0x0f) + 'a' -1;
2847     }
2848     else
2849       sub[0]='\0';
2850
2851     return snprintf(buffer, size, "SSL/%x.%x.%x%s",
2852                     (SSLEAY_VERSION_NUMBER>>12)&0xff,
2853                     (SSLEAY_VERSION_NUMBER>>8)&0xf,
2854                     (SSLEAY_VERSION_NUMBER>>4)&0xf, sub);
2855   }
2856 #endif /* (SSLEAY_VERSION_NUMBER >= 0x900000) */
2857 #endif /* SSLEAY_VERSION_NUMBER is less than 0.9.5 */
2858
2859 #endif /* YASSL_VERSION */
2860 }
2861
2862 void Curl_ossl_random(struct SessionHandle *data, unsigned char *entropy,
2863                       size_t length)
2864 {
2865   Curl_ossl_seed(data); /* Initiate the seed if not already done */
2866   RAND_bytes(entropy, curlx_uztosi(length));
2867 }
2868
2869 void Curl_ossl_md5sum(unsigned char *tmp, /* input */
2870                       size_t tmplen,
2871                       unsigned char *md5sum /* output */,
2872                       size_t unused)
2873 {
2874   MD5_CTX MD5pw;
2875   (void)unused;
2876   MD5_Init(&MD5pw);
2877   MD5_Update(&MD5pw, tmp, tmplen);
2878   MD5_Final(md5sum, &MD5pw);
2879 }
2880 #endif /* USE_SSLEAY */