openssl.c

   1 /*
   2  * OpenConnect (SSL + DTLS) VPN client
   3  *
   4  * Copyright © 2008-2012 Intel Corporation.
   5  *
   6  * Author: David Woodhouse <dwmw2@infradead.org>
   7  *
   8  * This program is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public License
  10  * version 2.1, as published by the Free Software Foundation.
  11  *
  12  * This program is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to:
  19  *
  20  *   Free Software Foundation, Inc.
  21  *   51 Franklin Street, Fifth Floor,
  22  *   Boston, MA 02110-1301 USA
  23  */
  24
  25 #include <errno.h>
  26 #include <sys/types.h>
  27 #include <netinet/in.h>
  28 #include <arpa/inet.h>
  29 #include <ctype.h>
  30
  31 #include <openssl/ssl.h>
  32 #include <openssl/err.h>
  33 #include <openssl/engine.h>
  34 #include <openssl/evp.h>
  35 #include <openssl/rand.h>
  36 #include <openssl/pkcs12.h>
  37 #include <openssl/x509v3.h>
  38 #include <openssl/x509.h>
  39 #include <openssl/bio.h>
  40
  41 #include "openconnect-internal.h"
  42
  43 int openconnect_sha1(unsigned char *result, void *data, int len)
  44 {
  45         EVP_MD_CTX c;
  46
  47         EVP_MD_CTX_init(&c);
  48         EVP_Digest(data, len, result, NULL, EVP_sha1(), NULL);
  49         EVP_MD_CTX_cleanup(&c);
  50
  51         return 0;
  52 }
  53
  54 int openconnect_get_cert_DER(struct openconnect_info *vpninfo,
  55                              OPENCONNECT_X509 *cert, unsigned char **buf)
  56 {
  57         BIO *bp = BIO_new(BIO_s_mem());
  58         BUF_MEM *certinfo;
  59         size_t l;
  60
  61         if (!i2d_X509_bio(bp, cert)) {
  62                 BIO_free(bp);
  63                 return -EIO;
  64         }
  65
  66         BIO_get_mem_ptr(bp, &certinfo);
  67         l = certinfo->length;
  68         *buf = malloc(l);
  69         if (!*buf) {
  70                 BIO_free(bp);
  71                 return -ENOMEM;
  72         }
  73         memcpy(*buf, certinfo->data, l);
  74         BIO_free(bp);
  75         return l;
  76 }
  77
  78 int openconnect_random(void *bytes, int len)
  79 {
  80         if (RAND_bytes(bytes, len) != 1)
  81                 return -EIO;
  82         return 0;
  83 }
  84
  85 /* Helper functions for reading/writing lines over SSL.
  86    We could use cURL for the HTTP stuff, but it's overkill */
  87
  88 int openconnect_SSL_write(struct openconnect_info *vpninfo, char *buf, size_t len)
  89 {
  90         size_t orig_len = len;
  91
  92         while (len) {
  93                 int done = SSL_write(vpninfo->https_ssl, buf, len);
  94
  95                 if (done > 0)
  96                         len -= done;
  97                 else {
  98                         int err = SSL_get_error(vpninfo->https_ssl, done);
  99                         fd_set wr_set, rd_set;
 100                         int maxfd = vpninfo->ssl_fd;
 101
 102                         FD_ZERO(&wr_set);
 103                         FD_ZERO(&rd_set);
 104
 105                         if (err == SSL_ERROR_WANT_READ)
 106                                 FD_SET(vpninfo->ssl_fd, &rd_set);
 107                         else if (err == SSL_ERROR_WANT_WRITE)
 108                                 FD_SET(vpninfo->ssl_fd, &wr_set);
 109                         else {
 110                                 vpn_progress(vpninfo, PRG_ERR, _("Failed to write to SSL socket"));
 111                                 openconnect_report_ssl_errors(vpninfo);
 112                                 return -EIO;
 113                         }
 114                         if (vpninfo->cancel_fd != -1) {
 115                                 FD_SET(vpninfo->cancel_fd, &rd_set);
 116                                 if (vpninfo->cancel_fd > vpninfo->ssl_fd)
 117                                         maxfd = vpninfo->cancel_fd;
 118                         }
 119                         select(maxfd + 1, &rd_set, &wr_set, NULL, NULL);
 120                         if (vpninfo->cancel_fd != -1 &&
 121                             FD_ISSET(vpninfo->cancel_fd, &rd_set)) {
 122                                 vpn_progress(vpninfo, PRG_ERR, _("SSL write cancelled\n"));
 123                                 return -EINTR;
 124                         }
 125                 }
 126         }
 127         return orig_len;
 128 }
 129
 130 int openconnect_SSL_read(struct openconnect_info *vpninfo, char *buf, size_t len)
 131 {
 132         int done;
 133
 134         while ((done = SSL_read(vpninfo->https_ssl, buf, len)) == -1) {
 135                 int err = SSL_get_error(vpninfo->https_ssl, done);
 136                 fd_set wr_set, rd_set;
 137                 int maxfd = vpninfo->ssl_fd;
 138
 139                 FD_ZERO(&wr_set);
 140                 FD_ZERO(&rd_set);
 141
 142                 if (err == SSL_ERROR_WANT_READ)
 143                         FD_SET(vpninfo->ssl_fd, &rd_set);
 144                 else if (err == SSL_ERROR_WANT_WRITE)
 145                         FD_SET(vpninfo->ssl_fd, &wr_set);
 146                 else {
 147                         vpn_progress(vpninfo, PRG_ERR, _("Failed to read from SSL socket"));
 148                         openconnect_report_ssl_errors(vpninfo);
 149                         return -EIO;
 150                 }
 151                 if (vpninfo->cancel_fd != -1) {
 152                         FD_SET(vpninfo->cancel_fd, &rd_set);
 153                         if (vpninfo->cancel_fd > vpninfo->ssl_fd)
 154                                 maxfd = vpninfo->cancel_fd;
 155                 }
 156                 select(maxfd + 1, &rd_set, &wr_set, NULL, NULL);
 157                 if (vpninfo->cancel_fd != -1 &&
 158                     FD_ISSET(vpninfo->cancel_fd, &rd_set)) {
 159                         vpn_progress(vpninfo, PRG_ERR, _("SSL read cancelled\n"));
 160                         return -EINTR;
 161                 }
 162         }
 163         return done;
 164 }
 165
 166 int openconnect_SSL_gets(struct openconnect_info *vpninfo, char *buf, size_t len)
 167 {
 168         int i = 0;
 169         int ret;
 170
 171         if (len < 2)
 172                 return -EINVAL;
 173
 174         while (1) {
 175                 ret = SSL_read(vpninfo->https_ssl, buf + i, 1);
 176                 if (ret == 1) {
 177                         if (buf[i] == '\n') {
 178                                 buf[i] = 0;
 179                                 if (i && buf[i-1] == '\r') {
 180                                         buf[i-1] = 0;
 181                                         i--;
 182                                 }
 183                                 return i;
 184                         }
 185                         i++;
 186
 187                         if (i >= len - 1) {
 188                                 buf[i] = 0;
 189                                 return i;
 190                         }
 191                 } else {
 192                         fd_set rd_set, wr_set;
 193                         int maxfd = vpninfo->ssl_fd;
 194
 195                         FD_ZERO(&rd_set);
 196                         FD_ZERO(&wr_set);
 197
 198                         ret = SSL_get_error(vpninfo->https_ssl, ret);
 199                         if (ret == SSL_ERROR_WANT_READ)
 200                                 FD_SET(vpninfo->ssl_fd, &rd_set);
 201                         else if (ret == SSL_ERROR_WANT_WRITE)
 202                                 FD_SET(vpninfo->ssl_fd, &wr_set);
 203                         else {
 204                                 vpn_progress(vpninfo, PRG_ERR, _("Failed to read from SSL socket\n"));
 205                                 openconnect_report_ssl_errors(vpninfo);
 206                                 ret = -EIO;
 207                                 break;
 208                         }
 209                         if (vpninfo->cancel_fd != -1) {
 210                                 FD_SET(vpninfo->cancel_fd, &rd_set);
 211                                 if (vpninfo->cancel_fd > vpninfo->ssl_fd)
 212                                         maxfd = vpninfo->cancel_fd;
 213                         }
 214                         select(maxfd + 1, &rd_set, &wr_set, NULL, NULL);
 215                         if (vpninfo->cancel_fd != -1 &&
 216                             FD_ISSET(vpninfo->cancel_fd, &rd_set)) {
 217                                 vpn_progress(vpninfo, PRG_ERR, _("SSL read cancelled\n"));
 218                                 ret = -EINTR;
 219                                 break;
 220                         }
 221                 }
 222         }
 223         buf[i] = 0;
 224         return i ?: ret;
 225 }
 226
 227
 228 /* UI handling. All this just to handle the PIN callback from the TPM ENGINE,
 229    and turn it into a call to our ->process_auth_form function */
 230
 231 struct ui_data {
 232         struct openconnect_info *vpninfo;
 233         struct oc_form_opt **last_opt;
 234         struct oc_auth_form form;
 235 };
 236
 237 struct ui_form_opt {
 238         struct oc_form_opt opt;
 239         UI_STRING *uis;
 240 };
 241
 242  /* Ick. But there is no way to pass this sanely through OpenSSL */
 243 static struct openconnect_info *ui_vpninfo;
 244
 245 static int ui_open(UI *ui)
 246 {
 247         struct openconnect_info *vpninfo = ui_vpninfo; /* Ick */
 248         struct ui_data *ui_data;
 249
 250         if (!vpninfo || !vpninfo->process_auth_form)
 251                 return 0;
 252
 253         ui_data = malloc(sizeof(*ui_data));
 254         if (!ui_data)
 255                 return 0;
 256
 257         memset(ui_data, 0, sizeof(*ui_data));
 258         ui_data->last_opt = &ui_data->form.opts;
 259         ui_data->vpninfo = vpninfo;
 260         UI_add_user_data(ui, ui_data);
 261
 262         return 1;
 263 }
 264
 265 static int ui_write(UI *ui, UI_STRING *uis)
 266 {
 267         struct ui_data *ui_data = UI_get0_user_data(ui);
 268         struct ui_form_opt *opt;
 269
 270         switch(UI_get_string_type(uis)) {
 271         case UIT_ERROR:
 272                 ui_data->form.error = (char *)UI_get0_output_string(uis);
 273                 break;
 274         case UIT_INFO:
 275                 ui_data->form.message = (char *)UI_get0_output_string(uis);
 276                 break;
 277         case UIT_PROMPT:
 278                 opt = malloc(sizeof(*opt));
 279                 if (!opt)
 280                         return 1;
 281                 memset(opt, 0, sizeof(*opt));
 282                 opt->uis = uis;
 283                 opt->opt.label = opt->opt.name = (char *)UI_get0_output_string(uis);
 284                 if (UI_get_input_flags(uis) & UI_INPUT_FLAG_ECHO)
 285                         opt->opt.type = OC_FORM_OPT_TEXT;
 286                 else
 287                         opt->opt.type = OC_FORM_OPT_PASSWORD;
 288                 *(ui_data->last_opt) = &opt->opt;
 289                 ui_data->last_opt = &opt->opt.next;
 290                 break;
 291
 292         default:
 293                 fprintf(stderr, "Unhandled SSL UI request type %d\n",
 294                         UI_get_string_type(uis));
 295                 return 0;
 296         }
 297         return 1;
 298 }
 299
 300 static int ui_flush(UI *ui)
 301 {
 302         struct ui_data *ui_data = UI_get0_user_data(ui);
 303         struct openconnect_info *vpninfo = ui_data->vpninfo;
 304         struct ui_form_opt *opt;
 305         int ret;
 306
 307         ret = vpninfo->process_auth_form(vpninfo->cbdata, &ui_data->form);
 308         if (ret)
 309                 return 0;
 310
 311         for (opt = (struct ui_form_opt *)ui_data->form.opts; opt;
 312              opt = (struct ui_form_opt *)opt->opt.next) {
 313                 if (opt->opt.value && opt->uis)
 314                         UI_set_result(ui, opt->uis, opt->opt.value);
 315         }
 316         return 1;
 317 }
 318
 319 static int ui_close(UI *ui)
 320 {
 321         struct ui_data *ui_data = UI_get0_user_data(ui);
 322         struct ui_form_opt *opt, *next_opt;
 323
 324         opt = (struct ui_form_opt *)ui_data->form.opts;
 325         while (opt) {
 326                 next_opt = (struct ui_form_opt *)opt->opt.next;
 327                 if (opt->opt.value)
 328                         free(opt->opt.value);
 329                 free(opt);
 330                 opt = next_opt;
 331         }
 332         free(ui_data);
 333         UI_add_user_data(ui, NULL);
 334
 335         return 1;
 336 }
 337
 338 static UI_METHOD *create_openssl_ui(struct openconnect_info *vpninfo)
 339 {
 340         UI_METHOD *ui_method = UI_create_method((char *)"AnyConnect VPN UI");
 341
 342         /* There is a race condition here because of the use of the
 343            static ui_vpninfo pointer. This sucks, but it's OpenSSL's
 344            fault and in practice it's *never* going to hurt us.
 345
 346            This UI is only used for loading certificates from a TPM; for
 347            PKCS#12 and PEM files we hook the passphrase request differently.
 348            The ui_vpninfo variable is set here, and is used from ui_open()
 349            when the TPM ENGINE decides it needs to ask the user for a PIN.
 350
 351            The race condition exists because theoretically, there
 352            could be more than one thread using libopenconnect and
 353            trying to authenticate to a VPN server, within the *same*
 354            process. And if *both* are using certificates from the TPM,
 355            and *both* manage to be within that short window of time
 356            between setting ui_vpninfo and invoking ui_open() to fetch
 357            the PIN, then one connection's ->process_auth_form() could
 358            get a PIN request for the *other* connection.
 359
 360            However, the only thing that ever does run libopenconnect more
 361            than once from the same process is KDE's NetworkManager support,
 362            and NetworkManager doesn't *support* having more than one VPN
 363            connected anyway, so first that would have to be fixed and then
 364            you'd have to connect to two VPNs simultaneously by clicking
 365            'connect' on both at *exactly* the same time and then getting
 366            *really* unlucky.
 367
 368            Oh, and the KDE support won't be using OpenSSL anyway because of
 369            licensing conflicts... so although this sucks, I'm not going to
 370            lose sleep over it.
 371         */
 372         ui_vpninfo = vpninfo;
 373
 374         /* Set up a UI method of our own for password/passphrase requests */
 375         UI_method_set_opener(ui_method, ui_open);
 376         UI_method_set_writer(ui_method, ui_write);
 377         UI_method_set_flusher(ui_method, ui_flush);
 378         UI_method_set_closer(ui_method, ui_close);
 379
 380         return ui_method;
 381 }
 382
 383 static int pem_pw_cb(char *buf, int len, int w, void *v)
 384 {
 385         struct openconnect_info *vpninfo = v;
 386         char *pass = NULL;
 387         int plen;
 388
 389         if (vpninfo->cert_password) {
 390                 pass = vpninfo->cert_password;
 391                 vpninfo->cert_password = NULL;
 392         } else if (request_passphrase(vpninfo, &pass,
 393                                       _("Enter PEM pass phrase:")))
 394                 return -1;
 395
 396         plen = strlen(pass);
 397
 398         if (len <= plen) {
 399                 vpn_progress(vpninfo, PRG_ERR,
 400                              _("PEM password too long (%d >= %d)\n"),
 401                              plen, len);
 402                 free(pass);
 403                 return -1;
 404         }
 405
 406         memcpy(buf, pass, plen+1);
 407         free(pass);
 408         return plen;
 409 }
 410
 411 static int load_pkcs12_certificate(struct openconnect_info *vpninfo, PKCS12 *p12)
 412 {
 413         EVP_PKEY *pkey = NULL;
 414         X509 *cert = NULL;
 415         STACK_OF(X509) *ca;
 416         int ret = 0;
 417         char *pass;
 418
 419         pass = vpninfo->cert_password;
 420         vpninfo->cert_password = NULL;
 421  retrypass:
 422         /* We do this every time round the loop, to work around a bug in
 423            OpenSSL < 1.0.0-beta2 -- where the stack at *ca will be freed
 424            when PKCS12_parse() returns an error, but *ca is left pointing
 425            to the freed memory. */
 426         ca = NULL;
 427         if (!pass && request_passphrase(vpninfo, &pass,
 428                                         _("Enter PKCS#12 pass phrase:")) < 0) {
 429                 PKCS12_free(p12);
 430                 return -EINVAL;
 431         }
 432         if (!PKCS12_parse(p12, pass, &pkey, &cert, &ca)) {
 433                 unsigned long err = ERR_peek_error();
 434
 435                 openconnect_report_ssl_errors(vpninfo);
 436
 437                 if (ERR_GET_LIB(err) == ERR_LIB_PKCS12 &&
 438                     ERR_GET_FUNC(err) == PKCS12_F_PKCS12_PARSE &&
 439                     ERR_GET_REASON(err) == PKCS12_R_MAC_VERIFY_FAILURE) {
 440                         vpn_progress(vpninfo, PRG_ERR,
 441                                      _("Parse PKCS#12 failed (wrong passphrase?)\n"));
 442                         free(pass);
 443                         pass = NULL;
 444                         goto retrypass;
 445                 }
 446
 447                 vpn_progress(vpninfo, PRG_ERR,
 448                              _("Parse PKCS#12 failed (see above errors)\n"));
 449                 PKCS12_free(p12);
 450                 free(pass);
 451                 return -EINVAL;
 452         }
 453         free(pass);
 454         if (cert) {
 455                 char buf[200];
 456                 vpninfo->cert_x509 = cert;
 457                 SSL_CTX_use_certificate(vpninfo->https_ctx, cert);
 458                 X509_NAME_oneline(X509_get_subject_name(cert), buf, sizeof(buf));
 459                 vpn_progress(vpninfo, PRG_INFO,
 460                              _("Using client certificate '%s'\n"), buf);
 461         } else {
 462                 vpn_progress(vpninfo, PRG_ERR,
 463                              _("PKCS#12 contained no certificate!"));
 464                 ret = -EINVAL;
 465         }
 466
 467         if (pkey) {
 468                 SSL_CTX_use_PrivateKey(vpninfo->https_ctx, pkey);
 469                 EVP_PKEY_free(pkey);
 470         } else {
 471                 vpn_progress(vpninfo, PRG_ERR,
 472                              _("PKCS#12 contained no private key!"));
 473                 ret = -EINVAL;
 474         }
 475
 476         /* Only include supporting certificates which are actually necessary */
 477         if (ca) {
 478                 int i;
 479         next:
 480                 for (i = 0; i < sk_X509_num(ca); i++) {
 481                         X509 *cert2 = sk_X509_value(ca, i);
 482                         if (X509_check_issued(cert2, cert) == X509_V_OK) {
 483                                 char buf[200];
 484
 485                                 if (cert2 == cert)
 486                                         break;
 487                                 if (X509_check_issued(cert2, cert2) == X509_V_OK)
 488                                         break;
 489
 490                                 X509_NAME_oneline(X509_get_subject_name(cert2),
 491                                                   buf, sizeof(buf));
 492                                 vpn_progress(vpninfo, PRG_DEBUG,
 493                                              _("Extra cert from PKCS#12: '%s'\n"), buf);
 494                                 CRYPTO_add(&cert2->references, 1, CRYPTO_LOCK_X509);
 495                                 SSL_CTX_add_extra_chain_cert(vpninfo->https_ctx, cert2);
 496                                 cert = cert2;
 497                                 goto next;
 498                         }
 499                 }
 500                 sk_X509_pop_free(ca, X509_free);
 501         }
 502
 503         PKCS12_free(p12);
 504         return ret;
 505 }
 506
 507 #ifdef HAVE_ENGINE
 508 static int load_tpm_certificate(struct openconnect_info *vpninfo)
 509 {
 510         ENGINE *e;
 511         EVP_PKEY *key;
 512         UI_METHOD *meth = NULL;
 513         int ret = 0;
 514
 515         ENGINE_load_builtin_engines();
 516
 517         e = ENGINE_by_id("tpm");
 518         if (!e) {
 519                 vpn_progress(vpninfo, PRG_ERR, _("Can't load TPM engine.\n"));
 520                 openconnect_report_ssl_errors(vpninfo);
 521                 return -EINVAL;
 522         }
 523         if (!ENGINE_init(e) || !ENGINE_set_default_RSA(e) ||
 524             !ENGINE_set_default_RAND(e)) {
 525                 vpn_progress(vpninfo, PRG_ERR, _("Failed to init TPM engine\n"));
 526                 openconnect_report_ssl_errors(vpninfo);
 527                 ENGINE_free(e);
 528                 return -EINVAL;
 529         }
 530
 531         if (vpninfo->cert_password) {
 532                 if (!ENGINE_ctrl_cmd(e, "PIN", strlen(vpninfo->cert_password),
 533                                      vpninfo->cert_password, NULL, 0)) {
 534                         vpn_progress(vpninfo, PRG_ERR,
 535                                      _("Failed to set TPM SRK password\n"));
 536                         openconnect_report_ssl_errors(vpninfo);
 537                 }
 538                 vpninfo->cert_password = NULL;
 539                 free(vpninfo->cert_password);
 540         } else {
 541                 /* Provide our own UI method to handle the PIN callback. */
 542                 meth = create_openssl_ui(vpninfo);
 543         }
 544         key = ENGINE_load_private_key(e, vpninfo->sslkey, meth, NULL);
 545         if (meth)
 546                 UI_destroy_method(meth);
 547         if (!key) {
 548                 vpn_progress(vpninfo, PRG_ERR,
 549                              _("Failed to load TPM private key\n"));
 550                 openconnect_report_ssl_errors(vpninfo);
 551                 ret = -EINVAL;
 552                 goto out;
 553         }
 554         if (!SSL_CTX_use_PrivateKey(vpninfo->https_ctx, key)) {
 555                 vpn_progress(vpninfo, PRG_ERR, _("Add key from TPM failed\n"));
 556                 openconnect_report_ssl_errors(vpninfo);
 557                 ret = -EINVAL;
 558         }
 559         EVP_PKEY_free(key);
 560  out:
 561         ENGINE_finish(e);
 562         ENGINE_free(e);
 563         return ret;
 564 }
 565 #else
 566 static int load_tpm_certificate(struct openconnect_info *vpninfo)
 567 {
 568         vpn_progress(vpninfo, PRG_ERR,
 569                      _("This version of OpenConnect was built without TPM support\n"));
 570         return -EINVAL;
 571 }
 572 #endif
 573
 574 static int reload_pem_cert(struct openconnect_info *vpninfo)
 575 {
 576         BIO *b = BIO_new(BIO_s_file_internal());
 577         char buf[200];
 578
 579         if (!b)
 580                 return -ENOMEM;
 581
 582         if (BIO_read_filename(b, vpninfo->cert) <= 0) {
 583         err:
 584                 BIO_free(b);
 585                 vpn_progress(vpninfo, PRG_ERR,
 586                              _("Failed to reload X509 cert for expiry check\n"));
 587                 openconnect_report_ssl_errors(vpninfo);
 588                 return -EIO;
 589         }
 590         vpninfo->cert_x509 = PEM_read_bio_X509_AUX(b, NULL, NULL, NULL);
 591         if (!vpninfo->cert_x509)
 592                 goto err;
 593
 594         X509_NAME_oneline(X509_get_subject_name(vpninfo->cert_x509), buf, sizeof(buf));
 595         vpn_progress(vpninfo, PRG_INFO,
 596                              _("Using client certificate '%s'\n"), buf);
 597
 598         return 0;
 599 }
 600
 601 static int load_certificate(struct openconnect_info *vpninfo)
 602 {
 603         if (!strncmp(vpninfo->sslkey, "pkcs11:", 7) ||
 604             !strncmp(vpninfo->cert, "pkcs11:", 7)) {
 605                 vpn_progress(vpninfo, PRG_ERR,
 606                              _("This binary built without PKCS#11 support\n"));
 607                 return -EINVAL;
 608         }
 609
 610         vpn_progress(vpninfo, PRG_TRACE,
 611                      _("Using certificate file %s\n"), vpninfo->cert);
 612
 613         if (vpninfo->cert_type == CERT_TYPE_PKCS12 ||
 614             vpninfo->cert_type == CERT_TYPE_UNKNOWN) {
 615                 FILE *f;
 616                 PKCS12 *p12;
 617
 618                 f = fopen(vpninfo->cert, "r");
 619                 if (!f) {
 620                         vpn_progress(vpninfo, PRG_ERR,
 621                                      _("Failed to open certificate file %s: %s\n"),
 622                                      vpninfo->cert, strerror(errno));
 623                         return -ENOENT;
 624                 }
 625                 p12 = d2i_PKCS12_fp(f, NULL);
 626                 fclose(f);
 627                 if (p12)
 628                         return load_pkcs12_certificate(vpninfo, p12);
 629
 630                 /* Not PKCS#12 */
 631                 if (vpninfo->cert_type == CERT_TYPE_PKCS12) {
 632                         vpn_progress(vpninfo, PRG_ERR, _("Read PKCS#12 failed\n"));
 633                         openconnect_report_ssl_errors(vpninfo);
 634                         return -EINVAL;
 635                 }
 636                 /* Clear error and fall through to see if it's a PEM file... */
 637                 ERR_clear_error();
 638         }
 639
 640         /* It's PEM or TPM now, and either way we need to load the plain cert: */
 641         if (!SSL_CTX_use_certificate_chain_file(vpninfo->https_ctx,
 642                                                 vpninfo->cert)) {
 643                 vpn_progress(vpninfo, PRG_ERR,
 644                              _("Loading certificate failed\n"));
 645                 openconnect_report_ssl_errors(vpninfo);
 646                 return -EINVAL;
 647         }
 648
 649         /* Ew, we can't get it back from the OpenSSL CTX in any sane fashion */
 650         reload_pem_cert(vpninfo);
 651
 652         if (vpninfo->cert_type == CERT_TYPE_UNKNOWN) {
 653                 FILE *f = fopen(vpninfo->sslkey, "r");
 654                 char buf[256];
 655
 656                 if (!f) {
 657                         vpn_progress(vpninfo, PRG_ERR,
 658                                      _("Failed to open private key file %s: %s\n"),
 659                                      vpninfo->cert, strerror(errno));
 660                         return -ENOENT;
 661                 }
 662
 663                 buf[255] = 0;
 664                 while (fgets(buf, 255, f)) {
 665                         if (!strcmp(buf, "-----BEGIN TSS KEY BLOB-----\n")) {
 666                                 vpninfo->cert_type = CERT_TYPE_TPM;
 667                                 break;
 668                         } else if (!strcmp(buf, "-----BEGIN RSA PRIVATE KEY-----\n") ||
 669                                    !strcmp(buf, "-----BEGIN DSA PRIVATE KEY-----\n") ||
 670                                    !strcmp(buf, "-----BEGIN ENCRYPTED PRIVATE KEY-----\n")) {
 671                                 vpninfo->cert_type = CERT_TYPE_PEM;
 672                                 break;
 673                         }
 674                 }
 675                 fclose(f);
 676                 if (vpninfo->cert_type == CERT_TYPE_UNKNOWN) {
 677                         vpn_progress(vpninfo, PRG_ERR,
 678                                      _("Failed to identify private key type in '%s'\n"),
 679                                      vpninfo->sslkey);
 680                         return -EINVAL;
 681                 }
 682         }
 683
 684         if (vpninfo->cert_type == CERT_TYPE_TPM)
 685                 return load_tpm_certificate(vpninfo);
 686
 687         /* Standard PEM certificate */
 688         SSL_CTX_set_default_passwd_cb(vpninfo->https_ctx, pem_pw_cb);
 689         SSL_CTX_set_default_passwd_cb_userdata(vpninfo->https_ctx, vpninfo);
 690  again:
 691         if (!SSL_CTX_use_RSAPrivateKey_file(vpninfo->https_ctx, vpninfo->sslkey,
 692                                             SSL_FILETYPE_PEM)) {
 693                 unsigned long err = ERR_peek_error();
 694
 695                 openconnect_report_ssl_errors(vpninfo);
 696
 697 #ifndef EVP_F_EVP_DECRYPTFINAL_EX
 698 #define EVP_F_EVP_DECRYPTFINAL_EX EVP_F_EVP_DECRYPTFINAL
 699 #endif
 700                 /* If the user fat-fingered the passphrase, try again */
 701                 if (ERR_GET_LIB(err) == ERR_LIB_EVP &&
 702                     ERR_GET_FUNC(err) == EVP_F_EVP_DECRYPTFINAL_EX &&
 703                     ERR_GET_REASON(err) == EVP_R_BAD_DECRYPT) {
 704                         vpn_progress(vpninfo, PRG_ERR,
 705                                      _("Loading private key failed (wrong passphrase?)\n"));
 706                         goto again;
 707                 }
 708
 709                 vpn_progress(vpninfo, PRG_ERR,
 710                              _("Loading private key failed (see above errors)\n"));
 711                 return -EINVAL;
 712         }
 713         return 0;
 714 }
 715
 716 static int get_cert_fingerprint(struct openconnect_info *vpninfo,
 717                                 OPENCONNECT_X509 *cert, const EVP_MD *type,
 718                                 char *buf)
 719 {
 720         unsigned char md[EVP_MAX_MD_SIZE];
 721         unsigned int i, n;
 722
 723         if (!X509_digest(cert, type, md, &n))
 724                 return -ENOMEM;
 725
 726         for (i=0; i < n; i++)
 727                 sprintf(&buf[i*2], "%02X", md[i]);
 728
 729         return 0;
 730 }
 731
 732 int get_cert_md5_fingerprint(struct openconnect_info *vpninfo,
 733                              OPENCONNECT_X509 *cert, char *buf)
 734 {
 735         return get_cert_fingerprint(vpninfo, cert, EVP_md5(), buf);
 736 }
 737
 738 int openconnect_get_cert_sha1(struct openconnect_info *vpninfo,
 739                               OPENCONNECT_X509 *cert, char *buf)
 740 {
 741         return get_cert_fingerprint(vpninfo, cert, EVP_sha1(), buf);
 742 }
 743
 744 static int check_server_cert(struct openconnect_info *vpninfo, X509 *cert)
 745 {
 746         char fingerprint[EVP_MAX_MD_SIZE * 2 + 1];
 747         int ret;
 748
 749         ret = openconnect_get_cert_sha1(vpninfo, cert, fingerprint);
 750         if (ret)
 751                 return ret;
 752
 753         if (strcasecmp(vpninfo->servercert, fingerprint)) {
 754                 vpn_progress(vpninfo, PRG_ERR,
 755                              _("Server SSL certificate didn't match: %s\n"), fingerprint);
 756                 return -EINVAL;
 757         }
 758         return 0;
 759 }
 760
 761 static int match_hostname_elem(const char *hostname, int helem_len,
 762                                const char *match, int melem_len)
 763 {
 764         if (!helem_len && !melem_len)
 765                 return 0;
 766
 767         if (!helem_len || !melem_len)
 768                 return -1;
 769
 770
 771         if (match[0] == '*') {
 772                 int i;
 773
 774                 for (i = 1 ; i <= helem_len; i++) {
 775                         if (!match_hostname_elem(hostname + i, helem_len - i,
 776                                                  match + 1, melem_len - 1))
 777                                 return 0;
 778                 }
 779                 return -1;
 780         }
 781
 782         /* From the NetBSD (5.1) man page for ctype(3):
 783            Values of type char or signed char must first be cast to unsigned char,
 784            to ensure that the values are within the correct range.  The result
 785            should then be cast to int to avoid warnings from some compilers.
 786            We do indeed get warning "array subscript has type 'char'" without
 787            the casts. Ick. */
 788         if (toupper((int)(unsigned char)hostname[0]) ==
 789             toupper((int)(unsigned char)match[0]))
 790                 return match_hostname_elem(hostname + 1, helem_len - 1,
 791                                            match + 1, melem_len - 1);
 792
 793         return -1;
 794 }
 795
 796 static int match_hostname(const char *hostname, const char *match)
 797 {
 798         while (*match) {
 799                 const char *h_dot, *m_dot;
 800                 int helem_len, melem_len;
 801
 802                 h_dot = strchr(hostname, '.');
 803                 m_dot = strchr(match, '.');
 804
 805                 if (h_dot && m_dot) {
 806                         helem_len = h_dot - hostname + 1;
 807                         melem_len = m_dot - match + 1;
 808                 } else if (!h_dot && !m_dot) {
 809                         helem_len = strlen(hostname);
 810                         melem_len = strlen(match);
 811                 } else
 812                         return -1;
 813
 814
 815                 if (match_hostname_elem(hostname, helem_len,
 816                                         match, melem_len))
 817                         return -1;
 818
 819                 hostname += helem_len;
 820                 match += melem_len;
 821         }
 822         if (*hostname)
 823                 return -1;
 824
 825         return 0;
 826 }
 827
 828 /* cf. RFC2818 and RFC2459 */
 829 static int match_cert_hostname(struct openconnect_info *vpninfo, X509 *peer_cert)
 830 {
 831         STACK_OF(GENERAL_NAME) *altnames;
 832         X509_NAME *subjname;
 833         ASN1_STRING *subjasn1;
 834         char *subjstr = NULL;
 835         int addrlen = 0;
 836         int i, altdns = 0;
 837         char addrbuf[sizeof(struct in6_addr)];
 838         int ret;
 839
 840         /* Allow GEN_IP in the certificate only if we actually connected
 841            by IP address rather than by name. */
 842         if (inet_pton(AF_INET, vpninfo->hostname, addrbuf) > 0)
 843                 addrlen = 4;
 844         else if (inet_pton(AF_INET6, vpninfo->hostname, addrbuf) > 0)
 845                 addrlen = 16;
 846         else if (vpninfo->hostname[0] == '[' &&
 847                  vpninfo->hostname[strlen(vpninfo->hostname)-1] == ']') {
 848                 char *p = &vpninfo->hostname[strlen(vpninfo->hostname)-1];
 849                 *p = 0;
 850                 if (inet_pton(AF_INET6, vpninfo->hostname + 1, addrbuf) > 0)
 851                         addrlen = 16;
 852                 *p = ']';
 853         }
 854
 855         altnames = X509_get_ext_d2i(peer_cert, NID_subject_alt_name,
 856                                     NULL, NULL);
 857         for (i = 0; i < sk_GENERAL_NAME_num(altnames); i++) {
 858                 const GENERAL_NAME *this = sk_GENERAL_NAME_value(altnames, i);
 859
 860                 if (this->type == GEN_DNS) {
 861                         char *str;
 862
 863                         int len = ASN1_STRING_to_UTF8((void *)&str, this->d.ia5);
 864                         if (len < 0)
 865                                 continue;
 866
 867                         altdns = 1;
 868
 869                         /* We don't like names with embedded NUL */
 870                         if (strlen(str) != len)
 871                                 continue;
 872
 873                         if (!match_hostname(vpninfo->hostname, str)) {
 874                                 vpn_progress(vpninfo, PRG_TRACE,
 875                                              _("Matched DNS altname '%s'\n"),
 876                                              str);
 877                                 GENERAL_NAMES_free(altnames);
 878                                 OPENSSL_free(str);
 879                                 return 0;
 880                         } else {
 881                                 vpn_progress(vpninfo, PRG_TRACE,
 882                                              _("No match for altname '%s'\n"),
 883                                              str);
 884                         }
 885                         OPENSSL_free(str);
 886                 } else if (this->type == GEN_IPADD && addrlen) {
 887                         char host[80];
 888                         int family;
 889
 890                         if (this->d.ip->length == 4) {
 891                                 family = AF_INET;
 892                         } else if (this->d.ip->length == 16) {
 893                                 family = AF_INET6;
 894                         } else {
 895                                 vpn_progress(vpninfo, PRG_ERR,
 896                                              _("Certificate has GEN_IPADD altname with bogus length %d\n"),
 897                                              this->d.ip->length);
 898                                 continue;
 899                         }
 900
 901                         /* We only do this for the debug messages */
 902                         inet_ntop(family, this->d.ip->data, host, sizeof(host));
 903
 904                         if (this->d.ip->length == addrlen &&
 905                             !memcmp(addrbuf, this->d.ip->data, addrlen)) {
 906                                 vpn_progress(vpninfo, PRG_TRACE,
 907                                              _("Matched %s address '%s'\n"),
 908                                              (family == AF_INET6)?"IPv6":"IPv4",
 909                                              host);
 910                                 GENERAL_NAMES_free(altnames);
 911                                 return 0;
 912                         } else {
 913                                 vpn_progress(vpninfo, PRG_TRACE,
 914                                              _("No match for %s address '%s'\n"),
 915                                              (family == AF_INET6)?"IPv6":"IPv4",
 916                                              host);
 917                         }
 918                 } else if (this->type == GEN_URI) {
 919                         char *str;
 920                         char *url_proto, *url_host, *url_path, *url_host2;
 921                         int url_port;
 922                         int len = ASN1_STRING_to_UTF8((void *)&str, this->d.ia5);
 923
 924                         if (len < 0)
 925                                 continue;
 926
 927                         /* We don't like names with embedded NUL */
 928                         if (strlen(str) != len)
 929                                 continue;
 930
 931                         if (internal_parse_url(str, &url_proto, &url_host, &url_port, &url_path, 0)) {
 932                                 OPENSSL_free(str);
 933                                 continue;
 934                         }
 935
 936                         if (!url_proto || strcasecmp(url_proto, "https"))
 937                                 goto no_uri_match;
 938
 939                         if (url_port != vpninfo->port)
 940                                 goto no_uri_match;
 941
 942                         /* Leave url_host as it was so that it can be freed */
 943                         url_host2 = url_host;
 944                         if (addrlen == 16 && vpninfo->hostname[0] != '[' &&
 945                             url_host[0] == '[' && url_host[strlen(url_host)-1] == ']') {
 946                                 /* Cope with https://[IPv6]/ when the hostname is bare IPv6 */
 947                                 url_host[strlen(url_host)-1] = 0;
 948                                 url_host2++;
 949                         }
 950
 951                         if (strcasecmp(vpninfo->hostname, url_host2))
 952                                 goto no_uri_match;
 953
 954                         if (url_path) {
 955                                 vpn_progress(vpninfo, PRG_TRACE,
 956                                              _("URI '%s' has non-empty path; ignoring\n"),
 957                                              str);
 958                                 goto no_uri_match_silent;
 959                         }
 960                         vpn_progress(vpninfo, PRG_TRACE,
 961                                      _("Matched URI '%s'\n"),
 962                                      str);
 963                         free(url_proto);
 964                         free(url_host);
 965                         free(url_path);
 966                         OPENSSL_free(str);
 967                         GENERAL_NAMES_free(altnames);
 968                         return 0;
 969
 970                 no_uri_match:
 971                         vpn_progress(vpninfo, PRG_TRACE,
 972                                      _("No match for URI '%s'\n"),
 973                                      str);
 974                 no_uri_match_silent:
 975                         free(url_proto);
 976                         free(url_host);
 977                         free(url_path);
 978                         OPENSSL_free(str);
 979                 }
 980         }
 981         GENERAL_NAMES_free(altnames);
 982
 983         /* According to RFC2818, we don't use the legacy subject name if
 984            there was an altname with DNS type. */
 985         if (altdns) {
 986                 vpn_progress(vpninfo, PRG_ERR,
 987                              _("No altname in peer cert matched '%s'\n"),
 988                              vpninfo->hostname);
 989                 return -EINVAL;
 990         }
 991
 992         subjname = X509_get_subject_name(peer_cert);
 993         if (!subjname) {
 994                 vpn_progress(vpninfo, PRG_ERR,
 995                              _("No subject name in peer cert!\n"));
 996                 return -EINVAL;
 997         }
 998
 999         /* Find the _last_ (most specific) commonName */
1000         i = -1;
1001         while (1) {
1002                 int j = X509_NAME_get_index_by_NID(subjname, NID_commonName, i);
1003                 if (j >= 0)
1004                         i = j;
1005                 else
1006                         break;
1007         }
1008
1009         subjasn1 = X509_NAME_ENTRY_get_data(X509_NAME_get_entry(subjname, i));
1010
1011         i = ASN1_STRING_to_UTF8((void *)&subjstr, subjasn1);
1012
1013         if (!subjstr || strlen(subjstr) != i) {
1014                 vpn_progress(vpninfo, PRG_ERR,
1015                              _("Failed to parse subject name in peer cert\n"));
1016                 return -EINVAL;
1017         }
1018         ret = 0;
1019
1020         if (match_hostname(vpninfo->hostname, subjstr)) {
1021                 vpn_progress(vpninfo, PRG_ERR,
1022                              _("Peer cert subject mismatch ('%s' != '%s')\n"),
1023                              subjstr, vpninfo->hostname);
1024                 ret = -EINVAL;
1025         } else {
1026                 vpn_progress(vpninfo, PRG_TRACE,
1027                              _("Matched peer certificate subject name '%s'\n"),
1028                              subjstr);
1029         }
1030
1031         OPENSSL_free(subjstr);
1032         return ret;
1033 }
1034
1035 static int verify_peer(struct openconnect_info *vpninfo, SSL *https_ssl)
1036 {
1037         X509 *peer_cert;
1038         int ret;
1039
1040         peer_cert = SSL_get_peer_certificate(https_ssl);
1041
1042         if (vpninfo->servercert) {
1043                 /* If given a cert fingerprint on the command line, that's
1044                    all we look for */
1045                 ret = check_server_cert(vpninfo, peer_cert);
1046         } else {
1047                 int vfy = SSL_get_verify_result(https_ssl);
1048                 const char *err_string = NULL;
1049
1050                 if (vfy != X509_V_OK)
1051                         err_string = X509_verify_cert_error_string(vfy);
1052                 else if (match_cert_hostname(vpninfo, peer_cert))
1053                         err_string = _("certificate does not match hostname");
1054
1055                 if (err_string) {
1056                         vpn_progress(vpninfo, PRG_INFO,
1057                                      _("Server certificate verify failed: %s\n"),
1058                                      err_string);
1059
1060                         if (vpninfo->validate_peer_cert)
1061                                 ret = vpninfo->validate_peer_cert(vpninfo->cbdata,
1062                                                                   peer_cert,
1063                                                                   err_string);
1064                         else
1065                                 ret = -EINVAL;
1066                 } else {
1067                         ret = 0;
1068                 }
1069         }
1070         X509_free(peer_cert);
1071
1072         return ret;
1073 }
1074
1075 static void workaround_openssl_certchain_bug(struct openconnect_info *vpninfo,
1076                                              SSL *ssl)
1077 {
1078         /* OpenSSL has problems with certificate chains -- if there are
1079            multiple certs with the same name, it doesn't necessarily
1080            choose the _right_ one. (RT#1942)
1081            Pick the right ones for ourselves and add them manually. */
1082         X509 *cert = SSL_get_certificate(ssl);
1083         X509 *cert2;
1084         X509_STORE *store = SSL_CTX_get_cert_store(vpninfo->https_ctx);
1085         X509_STORE_CTX ctx;
1086
1087         if (!cert || !store)
1088                 return;
1089
1090         /* If we already have 'supporting' certs, don't add them again */
1091         if (vpninfo->https_ctx->extra_certs)
1092                 return;
1093
1094         if (!X509_STORE_CTX_init(&ctx, store, NULL, NULL))
1095                 return;
1096
1097         while (ctx.get_issuer(&cert2, &ctx, cert) == 1) {
1098                 char buf[200];
1099                 if (cert2 == cert)
1100                         break;
1101                 if (X509_check_issued(cert2, cert2) == X509_V_OK)
1102                         break;
1103                 cert = cert2;
1104                 X509_NAME_oneline(X509_get_subject_name(cert),
1105                                   buf, sizeof(buf));
1106                 vpn_progress(vpninfo, PRG_DEBUG,
1107                              _("Extra cert from cafile: '%s'\n"), buf);
1108                 SSL_CTX_add_extra_chain_cert(vpninfo->https_ctx, cert);
1109         }
1110         X509_STORE_CTX_cleanup(&ctx);
1111 }
1112
1113 #if OPENSSL_VERSION_NUMBER >= 0x00908000
1114 static int ssl_app_verify_callback(X509_STORE_CTX *ctx, void *arg)
1115 {
1116         /* We've seen certificates in the wild which don't have the
1117            purpose fields filled in correctly */
1118         X509_VERIFY_PARAM_set_purpose(ctx->param, X509_PURPOSE_ANY);
1119         return X509_verify_cert(ctx);
1120 }
1121 #endif
1122
1123 static int check_certificate_expiry(struct openconnect_info *vpninfo)
1124 {
1125         ASN1_TIME *notAfter;
1126         const char *reason = NULL;
1127         time_t t;
1128         int i;
1129
1130         if (!vpninfo->cert_x509)
1131                 return 0;
1132
1133         t = time(NULL);
1134         notAfter = X509_get_notAfter(vpninfo->cert_x509);
1135         i = X509_cmp_time(notAfter, &t);
1136         if (!i) {
1137                 vpn_progress(vpninfo, PRG_ERR,
1138                              _("Error in client cert notAfter field\n"));
1139                 return -EINVAL;
1140         } else if (i < 0) {
1141                 reason = _("Client certificate has expired at");
1142         } else {
1143                 t += vpninfo->cert_expire_warning;
1144                 i = X509_cmp_time(notAfter, &t);
1145                 if (i < 0) {
1146                         reason = _("Client certificate expires soon at");
1147                 }
1148         }
1149         if (reason) {
1150                 BIO *bp = BIO_new(BIO_s_mem());
1151                 BUF_MEM *bm;
1152                 const char *expiry = _("<error>");
1153                 char zero = 0;
1154
1155                 if (bp) {
1156                         ASN1_TIME_print(bp, notAfter);
1157                         BIO_write(bp, &zero, 1);
1158                         BIO_get_mem_ptr(bp, &bm);
1159                         expiry = bm->data;
1160                 }
1161                 vpn_progress(vpninfo, PRG_ERR, "%s: %s\n", reason, expiry);
1162                 if (bp)
1163                         BIO_free(bp);
1164         }
1165         return 0;
1166 }
1167 int openconnect_open_https(struct openconnect_info *vpninfo)
1168 {
1169         method_const SSL_METHOD *ssl3_method;
1170         SSL *https_ssl;
1171         BIO *https_bio;
1172         int ssl_sock;
1173         int err;
1174
1175         if (vpninfo->https_ssl)
1176                 return 0;
1177
1178         if (vpninfo->peer_cert) {
1179                 X509_free(vpninfo->peer_cert);
1180                 vpninfo->peer_cert = NULL;
1181         }
1182
1183         ssl_sock = connect_https_socket(vpninfo);
1184         if (ssl_sock < 0)
1185                 return ssl_sock;
1186
1187         ssl3_method = TLSv1_client_method();
1188         if (!vpninfo->https_ctx) {
1189                 vpninfo->https_ctx = SSL_CTX_new(ssl3_method);
1190
1191                 /* Some servers (or their firewalls) really don't like seeing
1192                    extensions. */
1193 #ifdef SSL_OP_NO_TICKET
1194                 SSL_CTX_set_options (vpninfo->https_ctx, SSL_OP_NO_TICKET);
1195 #endif
1196
1197                 if (vpninfo->cert) {
1198                         err = load_certificate(vpninfo);
1199                         if (err) {
1200                                 vpn_progress(vpninfo, PRG_ERR,
1201                                              _("Loading certificate failed. Aborting.\n"));
1202                                 return err;
1203                         }
1204                         check_certificate_expiry(vpninfo);
1205                 }
1206
1207                 /* We just want to do:
1208                    SSL_CTX_set_purpose(vpninfo->https_ctx, X509_PURPOSE_ANY);
1209                    ... but it doesn't work with OpenSSL < 0.9.8k because of
1210                    problems with inheritance (fixed in v1.1.4.6 of
1211                    crypto/x509/x509_vpm.c) so we have to play silly buggers
1212                    instead. This trick doesn't work _either_ in < 0.9.7 but
1213                    I don't know of _any_ workaround which will, and can't
1214                    be bothered to find out either. */
1215 #if OPENSSL_VERSION_NUMBER >= 0x00908000
1216                 SSL_CTX_set_cert_verify_callback(vpninfo->https_ctx,
1217                                                  ssl_app_verify_callback, NULL);
1218 #endif
1219                 SSL_CTX_set_default_verify_paths(vpninfo->https_ctx);
1220
1221                 if (vpninfo->cafile) {
1222                         if (!SSL_CTX_load_verify_locations(vpninfo->https_ctx, vpninfo->cafile, NULL)) {
1223                                 vpn_progress(vpninfo, PRG_ERR,
1224                                              _("Failed to open CA file '%s'\n"),
1225                                              vpninfo->cafile);
1226                                 openconnect_report_ssl_errors(vpninfo);
1227                                 close(ssl_sock);
1228                                 return -EINVAL;
1229                         }
1230                 }
1231
1232         }
1233         https_ssl = SSL_new(vpninfo->https_ctx);
1234         workaround_openssl_certchain_bug(vpninfo, https_ssl);
1235
1236         https_bio = BIO_new_socket(ssl_sock, BIO_NOCLOSE);
1237         BIO_set_nbio(https_bio, 1);
1238         SSL_set_bio(https_ssl, https_bio, https_bio);
1239
1240         vpn_progress(vpninfo, PRG_INFO, _("SSL negotiation with %s\n"),
1241                      vpninfo->hostname);
1242
1243         while ((err = SSL_connect(https_ssl)) <= 0) {
1244                 fd_set wr_set, rd_set;
1245                 int maxfd = ssl_sock;
1246
1247                 FD_ZERO(&wr_set);
1248                 FD_ZERO(&rd_set);
1249
1250                 err = SSL_get_error(https_ssl, err);
1251                 if (err == SSL_ERROR_WANT_READ)
1252                         FD_SET(ssl_sock, &rd_set);
1253                 else if (err == SSL_ERROR_WANT_WRITE)
1254                         FD_SET(ssl_sock, &wr_set);
1255                 else {
1256                         vpn_progress(vpninfo, PRG_ERR, _("SSL connection failure\n"));
1257                         openconnect_report_ssl_errors(vpninfo);
1258                         SSL_free(https_ssl);
1259                         close(ssl_sock);
1260                         return -EINVAL;
1261                 }
1262
1263                 if (vpninfo->cancel_fd != -1) {
1264                         FD_SET(vpninfo->cancel_fd, &rd_set);
1265                         if (vpninfo->cancel_fd > ssl_sock)
1266                                 maxfd = vpninfo->cancel_fd;
1267                 }
1268                 select(maxfd + 1, &rd_set, &wr_set, NULL, NULL);
1269                 if (vpninfo->cancel_fd != -1 &&
1270                     FD_ISSET(vpninfo->cancel_fd, &rd_set)) {
1271                         vpn_progress(vpninfo, PRG_ERR, _("SSL connection cancelled\n"));
1272                         SSL_free(https_ssl);
1273                         close(ssl_sock);
1274                         return -EINVAL;
1275                 }
1276         }
1277
1278         if (verify_peer(vpninfo, https_ssl)) {
1279                 SSL_free(https_ssl);
1280                 close(ssl_sock);
1281                 return -EINVAL;
1282         }
1283
1284         vpninfo->ssl_fd = ssl_sock;
1285         vpninfo->https_ssl = https_ssl;
1286
1287         /* Stash this now, because it might not be available later if the
1288            server has disconnected. */
1289         vpninfo->peer_cert = SSL_get_peer_certificate(vpninfo->https_ssl);
1290
1291         vpn_progress(vpninfo, PRG_INFO, _("Connected to HTTPS on %s\n"),
1292                      vpninfo->hostname);
1293
1294         return 0;
1295 }
1296
1297 void openconnect_close_https(struct openconnect_info *vpninfo, int final)
1298 {
1299         if (vpninfo->peer_cert) {
1300                 X509_free(vpninfo->peer_cert);
1301                 vpninfo->peer_cert = NULL;
1302         }
1303         if (vpninfo->https_ssl) {
1304                 SSL_free(vpninfo->https_ssl);
1305                 vpninfo->https_ssl = NULL;
1306         }
1307         if (vpninfo->ssl_fd != -1) {
1308                 close(vpninfo->ssl_fd);
1309                 FD_CLR(vpninfo->ssl_fd, &vpninfo->select_rfds);
1310                 FD_CLR(vpninfo->ssl_fd, &vpninfo->select_wfds);
1311                 FD_CLR(vpninfo->ssl_fd, &vpninfo->select_efds);
1312                 vpninfo->ssl_fd = -1;
1313         }
1314         if (final && vpninfo->https_ctx) {
1315                 SSL_CTX_free(vpninfo->https_ctx);
1316                 vpninfo->https_ctx = NULL;
1317         }
1318 }
1319
1320 void openconnect_init_ssl(void)
1321 {
1322         SSL_library_init ();
1323         ERR_clear_error ();
1324         SSL_load_error_strings ();
1325         OpenSSL_add_all_algorithms ();
1326 }
1327
1328 char *openconnect_get_cert_details(struct openconnect_info *vpninfo,
1329                                    OPENCONNECT_X509 *cert)
1330 {
1331         BIO *bp = BIO_new(BIO_s_mem());
1332         BUF_MEM *certinfo;
1333         char zero = 0;
1334         char *ret;
1335
1336         X509_print_ex(bp, cert, 0, 0);
1337         BIO_write(bp, &zero, 1);
1338         BIO_get_mem_ptr(bp, &certinfo);
1339
1340         ret = strdup(certinfo->data);
1341         BIO_free(bp);
1342         return ret;
1343 }
1344
1345
1346 int openconnect_local_cert_md5(struct openconnect_info *vpninfo,
1347                                char *buf)
1348 {
1349         buf[0] = 0;
1350
1351         if (!vpninfo->cert_x509)
1352                 return -EIO;
1353
1354         if (get_cert_md5_fingerprint(vpninfo, vpninfo->cert_x509, buf))
1355                 return -EIO;
1356
1357         return 0;
1358 }