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_data->form.auth_id = (char *)"openssl_ui";
 261         UI_add_user_data(ui, ui_data);
 262
 263         return 1;
 264 }
 265
 266 static int ui_write(UI *ui, UI_STRING *uis)
 267 {
 268         struct ui_data *ui_data = UI_get0_user_data(ui);
 269         struct ui_form_opt *opt;
 270
 271         switch(UI_get_string_type(uis)) {
 272         case UIT_ERROR:
 273                 ui_data->form.error = (char *)UI_get0_output_string(uis);
 274                 break;
 275         case UIT_INFO:
 276                 ui_data->form.message = (char *)UI_get0_output_string(uis);
 277                 break;
 278         case UIT_PROMPT:
 279                 opt = malloc(sizeof(*opt));
 280                 if (!opt)
 281                         return 1;
 282                 memset(opt, 0, sizeof(*opt));
 283                 opt->uis = uis;
 284                 opt->opt.label = opt->opt.name = (char *)UI_get0_output_string(uis);
 285                 if (UI_get_input_flags(uis) & UI_INPUT_FLAG_ECHO)
 286                         opt->opt.type = OC_FORM_OPT_TEXT;
 287                 else
 288                         opt->opt.type = OC_FORM_OPT_PASSWORD;
 289                 *(ui_data->last_opt) = &opt->opt;
 290                 ui_data->last_opt = &opt->opt.next;
 291                 break;
 292
 293         default:
 294                 fprintf(stderr, "Unhandled SSL UI request type %d\n",
 295                         UI_get_string_type(uis));
 296                 return 0;
 297         }
 298         return 1;
 299 }
 300
 301 static int ui_flush(UI *ui)
 302 {
 303         struct ui_data *ui_data = UI_get0_user_data(ui);
 304         struct openconnect_info *vpninfo = ui_data->vpninfo;
 305         struct ui_form_opt *opt;
 306         int ret;
 307
 308         ret = vpninfo->process_auth_form(vpninfo->cbdata, &ui_data->form);
 309         if (ret)
 310                 return 0;
 311
 312         for (opt = (struct ui_form_opt *)ui_data->form.opts; opt;
 313              opt = (struct ui_form_opt *)opt->opt.next) {
 314                 if (opt->opt.value && opt->uis)
 315                         UI_set_result(ui, opt->uis, opt->opt.value);
 316         }
 317         return 1;
 318 }
 319
 320 static int ui_close(UI *ui)
 321 {
 322         struct ui_data *ui_data = UI_get0_user_data(ui);
 323         struct ui_form_opt *opt, *next_opt;
 324
 325         opt = (struct ui_form_opt *)ui_data->form.opts;
 326         while (opt) {
 327                 next_opt = (struct ui_form_opt *)opt->opt.next;
 328                 if (opt->opt.value)
 329                         free(opt->opt.value);
 330                 free(opt);
 331                 opt = next_opt;
 332         }
 333         free(ui_data);
 334         UI_add_user_data(ui, NULL);
 335
 336         return 1;
 337 }
 338
 339 static UI_METHOD *create_openssl_ui(struct openconnect_info *vpninfo)
 340 {
 341         UI_METHOD *ui_method = UI_create_method((char *)"AnyConnect VPN UI");
 342
 343         /* There is a race condition here because of the use of the
 344            static ui_vpninfo pointer. This sucks, but it's OpenSSL's
 345            fault and in practice it's *never* going to hurt us.
 346
 347            This UI is only used for loading certificates from a TPM; for
 348            PKCS#12 and PEM files we hook the passphrase request differently.
 349            The ui_vpninfo variable is set here, and is used from ui_open()
 350            when the TPM ENGINE decides it needs to ask the user for a PIN.
 351
 352            The race condition exists because theoretically, there
 353            could be more than one thread using libopenconnect and
 354            trying to authenticate to a VPN server, within the *same*
 355            process. And if *both* are using certificates from the TPM,
 356            and *both* manage to be within that short window of time
 357            between setting ui_vpninfo and invoking ui_open() to fetch
 358            the PIN, then one connection's ->process_auth_form() could
 359            get a PIN request for the *other* connection.
 360
 361            However, the only thing that ever does run libopenconnect more
 362            than once from the same process is KDE's NetworkManager support,
 363            and NetworkManager doesn't *support* having more than one VPN
 364            connected anyway, so first that would have to be fixed and then
 365            you'd have to connect to two VPNs simultaneously by clicking
 366            'connect' on both at *exactly* the same time and then getting
 367            *really* unlucky.
 368
 369            Oh, and the KDE support won't be using OpenSSL anyway because of
 370            licensing conflicts... so although this sucks, I'm not going to
 371            lose sleep over it.
 372         */
 373         ui_vpninfo = vpninfo;
 374
 375         /* Set up a UI method of our own for password/passphrase requests */
 376         UI_method_set_opener(ui_method, ui_open);
 377         UI_method_set_writer(ui_method, ui_write);
 378         UI_method_set_flusher(ui_method, ui_flush);
 379         UI_method_set_closer(ui_method, ui_close);
 380
 381         return ui_method;
 382 }
 383
 384 static int pem_pw_cb(char *buf, int len, int w, void *v)
 385 {
 386         struct openconnect_info *vpninfo = v;
 387         char *pass = NULL;
 388         int plen;
 389
 390         if (vpninfo->cert_password) {
 391                 pass = vpninfo->cert_password;
 392                 vpninfo->cert_password = NULL;
 393         } else if (request_passphrase(vpninfo, "openconnect_pem",
 394                                       &pass, _("Enter PEM pass phrase:")))
 395                 return -1;
 396
 397         plen = strlen(pass);
 398
 399         if (len <= plen) {
 400                 vpn_progress(vpninfo, PRG_ERR,
 401                              _("PEM password too long (%d >= %d)\n"),
 402                              plen, len);
 403                 free(pass);
 404                 return -1;
 405         }
 406
 407         memcpy(buf, pass, plen+1);
 408         free(pass);
 409         return plen;
 410 }
 411
 412 static int load_pkcs12_certificate(struct openconnect_info *vpninfo, PKCS12 *p12)
 413 {
 414         EVP_PKEY *pkey = NULL;
 415         X509 *cert = NULL;
 416         STACK_OF(X509) *ca;
 417         int ret = 0;
 418         char *pass;
 419
 420         pass = vpninfo->cert_password;
 421         vpninfo->cert_password = NULL;
 422  retrypass:
 423         /* We do this every time round the loop, to work around a bug in
 424            OpenSSL < 1.0.0-beta2 -- where the stack at *ca will be freed
 425            when PKCS12_parse() returns an error, but *ca is left pointing
 426            to the freed memory. */
 427         ca = NULL;
 428         if (!pass && request_passphrase(vpninfo, "openconnect_pkcs12", &pass,
 429                                         _("Enter PKCS#12 pass phrase:")) < 0) {
 430                 PKCS12_free(p12);
 431                 return -EINVAL;
 432         }
 433         if (!PKCS12_parse(p12, pass, &pkey, &cert, &ca)) {
 434                 unsigned long err = ERR_peek_error();
 435
 436                 openconnect_report_ssl_errors(vpninfo);
 437
 438                 if (ERR_GET_LIB(err) == ERR_LIB_PKCS12 &&
 439                     ERR_GET_FUNC(err) == PKCS12_F_PKCS12_PARSE &&
 440                     ERR_GET_REASON(err) == PKCS12_R_MAC_VERIFY_FAILURE) {
 441                         vpn_progress(vpninfo, PRG_ERR,
 442                                      _("Parse PKCS#12 failed (wrong passphrase?)\n"));
 443                         free(pass);
 444                         pass = NULL;
 445                         goto retrypass;
 446                 }
 447
 448                 vpn_progress(vpninfo, PRG_ERR,
 449                              _("Parse PKCS#12 failed (see above errors)\n"));
 450                 PKCS12_free(p12);
 451                 free(pass);
 452                 return -EINVAL;
 453         }
 454         free(pass);
 455         if (cert) {
 456                 char buf[200];
 457                 vpninfo->cert_x509 = cert;
 458                 SSL_CTX_use_certificate(vpninfo->https_ctx, cert);
 459                 X509_NAME_oneline(X509_get_subject_name(cert), buf, sizeof(buf));
 460                 vpn_progress(vpninfo, PRG_INFO,
 461                              _("Using client certificate '%s'\n"), buf);
 462         } else {
 463                 vpn_progress(vpninfo, PRG_ERR,
 464                              _("PKCS#12 contained no certificate!"));
 465                 ret = -EINVAL;
 466         }
 467
 468         if (pkey) {
 469                 SSL_CTX_use_PrivateKey(vpninfo->https_ctx, pkey);
 470                 EVP_PKEY_free(pkey);
 471         } else {
 472                 vpn_progress(vpninfo, PRG_ERR,
 473                              _("PKCS#12 contained no private key!"));
 474                 ret = -EINVAL;
 475         }
 476
 477         /* Only include supporting certificates which are actually necessary */
 478         if (ca) {
 479                 int i;
 480         next:
 481                 for (i = 0; i < sk_X509_num(ca); i++) {
 482                         X509 *cert2 = sk_X509_value(ca, i);
 483                         if (X509_check_issued(cert2, cert) == X509_V_OK) {
 484                                 char buf[200];
 485
 486                                 if (cert2 == cert)
 487                                         break;
 488                                 if (X509_check_issued(cert2, cert2) == X509_V_OK)
 489                                         break;
 490
 491                                 X509_NAME_oneline(X509_get_subject_name(cert2),
 492                                                   buf, sizeof(buf));
 493                                 vpn_progress(vpninfo, PRG_DEBUG,
 494                                              _("Extra cert from PKCS#12: '%s'\n"), buf);
 495                                 CRYPTO_add(&cert2->references, 1, CRYPTO_LOCK_X509);
 496                                 SSL_CTX_add_extra_chain_cert(vpninfo->https_ctx, cert2);
 497                                 cert = cert2;
 498                                 goto next;
 499                         }
 500                 }
 501                 sk_X509_pop_free(ca, X509_free);
 502         }
 503
 504         PKCS12_free(p12);
 505         return ret;
 506 }
 507
 508 #ifdef HAVE_ENGINE
 509 static int load_tpm_certificate(struct openconnect_info *vpninfo)
 510 {
 511         ENGINE *e;
 512         EVP_PKEY *key;
 513         UI_METHOD *meth = NULL;
 514         int ret = 0;
 515
 516         ENGINE_load_builtin_engines();
 517
 518         e = ENGINE_by_id("tpm");
 519         if (!e) {
 520                 vpn_progress(vpninfo, PRG_ERR, _("Can't load TPM engine.\n"));
 521                 openconnect_report_ssl_errors(vpninfo);
 522                 return -EINVAL;
 523         }
 524         if (!ENGINE_init(e) || !ENGINE_set_default_RSA(e) ||
 525             !ENGINE_set_default_RAND(e)) {
 526                 vpn_progress(vpninfo, PRG_ERR, _("Failed to init TPM engine\n"));
 527                 openconnect_report_ssl_errors(vpninfo);
 528                 ENGINE_free(e);
 529                 return -EINVAL;
 530         }
 531
 532         if (vpninfo->cert_password) {
 533                 if (!ENGINE_ctrl_cmd(e, "PIN", strlen(vpninfo->cert_password),
 534                                      vpninfo->cert_password, NULL, 0)) {
 535                         vpn_progress(vpninfo, PRG_ERR,
 536                                      _("Failed to set TPM SRK password\n"));
 537                         openconnect_report_ssl_errors(vpninfo);
 538                 }
 539                 vpninfo->cert_password = NULL;
 540                 free(vpninfo->cert_password);
 541         } else {
 542                 /* Provide our own UI method to handle the PIN callback. */
 543                 meth = create_openssl_ui(vpninfo);
 544         }
 545         key = ENGINE_load_private_key(e, vpninfo->sslkey, meth, NULL);
 546         if (meth)
 547                 UI_destroy_method(meth);
 548         if (!key) {
 549                 vpn_progress(vpninfo, PRG_ERR,
 550                              _("Failed to load TPM private key\n"));
 551                 openconnect_report_ssl_errors(vpninfo);
 552                 ret = -EINVAL;
 553                 goto out;
 554         }
 555         if (!SSL_CTX_use_PrivateKey(vpninfo->https_ctx, key)) {
 556                 vpn_progress(vpninfo, PRG_ERR, _("Add key from TPM failed\n"));
 557                 openconnect_report_ssl_errors(vpninfo);
 558                 ret = -EINVAL;
 559         }
 560         EVP_PKEY_free(key);
 561  out:
 562         ENGINE_finish(e);
 563         ENGINE_free(e);
 564         return ret;
 565 }
 566 #else
 567 static int load_tpm_certificate(struct openconnect_info *vpninfo)
 568 {
 569         vpn_progress(vpninfo, PRG_ERR,
 570                      _("This version of OpenConnect was built without TPM support\n"));
 571         return -EINVAL;
 572 }
 573 #endif
 574
 575 static int reload_pem_cert(struct openconnect_info *vpninfo)
 576 {
 577         BIO *b = BIO_new(BIO_s_file_internal());
 578         char buf[200];
 579
 580         if (!b)
 581                 return -ENOMEM;
 582
 583         if (BIO_read_filename(b, vpninfo->cert) <= 0) {
 584         err:
 585                 BIO_free(b);
 586                 vpn_progress(vpninfo, PRG_ERR,
 587                              _("Failed to reload X509 cert for expiry check\n"));
 588                 openconnect_report_ssl_errors(vpninfo);
 589                 return -EIO;
 590         }
 591         vpninfo->cert_x509 = PEM_read_bio_X509_AUX(b, NULL, NULL, NULL);
 592         BIO_free(b);
 593         if (!vpninfo->cert_x509)
 594                 goto err;
 595
 596         X509_NAME_oneline(X509_get_subject_name(vpninfo->cert_x509), buf, sizeof(buf));
 597         vpn_progress(vpninfo, PRG_INFO,
 598                              _("Using client certificate '%s'\n"), buf);
 599
 600         return 0;
 601 }
 602
 603 #ifdef ANDROID_KEYSTORE
 604 static BIO *BIO_from_keystore(struct openconnect_info *vpninfo, const char *item)
 605 {
 606         char content[KEYSTORE_MESSAGE_SIZE];
 607         BIO *b;
 608         int len;
 609         const char *p = item + 9;
 610
 611         /* Skip first two slashes if the user has given it as
 612            keystore://foo ... */
 613         if (*p == '/')
 614                 p++;
 615         if (*p == '/')
 616                 p++;
 617         len = keystore_get(p, strlen(p), content);
 618         if (len < 0) {
 619                 vpn_progress(vpninfo, PRG_ERR,
 620                              _("Failed to lead item '%s' from keystore\n"),
 621                              p);
 622                 return NULL;
 623         }
 624         if (!(b = BIO_new(BIO_s_mem())) || BIO_write(b, content, len) != len) {
 625                 vpn_progress(vpninfo, PRG_ERR,
 626                              _("Failed to create BIO for keystore item '%s'\n"),
 627                                p);
 628                 BIO_free(b);
 629                 return NULL;
 630         }
 631         return b;
 632 }
 633 #endif
 634
 635 static int is_pem_password_error(struct openconnect_info *vpninfo)
 636 {
 637         unsigned long err = ERR_peek_error();
 638
 639         openconnect_report_ssl_errors(vpninfo);
 640
 641 #ifndef EVP_F_EVP_DECRYPTFINAL_EX
 642 #define EVP_F_EVP_DECRYPTFINAL_EX EVP_F_EVP_DECRYPTFINAL
 643 #endif
 644         /* If the user fat-fingered the passphrase, try again */
 645         if (ERR_GET_LIB(err) == ERR_LIB_EVP &&
 646             ERR_GET_FUNC(err) == EVP_F_EVP_DECRYPTFINAL_EX &&
 647             ERR_GET_REASON(err) == EVP_R_BAD_DECRYPT) {
 648                 vpn_progress(vpninfo, PRG_ERR,
 649                              _("Loading private key failed (wrong passphrase?)\n"));
 650                 ERR_clear_error();
 651                 return 1;
 652         }
 653
 654         vpn_progress(vpninfo, PRG_ERR,
 655                      _("Loading private key failed (see above errors)\n"));
 656         return 0;
 657 }
 658
 659 static int load_certificate(struct openconnect_info *vpninfo)
 660 {
 661         if (!strncmp(vpninfo->sslkey, "pkcs11:", 7) ||
 662             !strncmp(vpninfo->cert, "pkcs11:", 7)) {
 663                 vpn_progress(vpninfo, PRG_ERR,
 664                              _("This binary built without PKCS#11 support\n"));
 665                 return -EINVAL;
 666         }
 667
 668         vpn_progress(vpninfo, PRG_TRACE,
 669                      _("Using certificate file %s\n"), vpninfo->cert);
 670
 671         if (strncmp(vpninfo->cert, "keystore:", 9) &&
 672             (vpninfo->cert_type == CERT_TYPE_PKCS12 ||
 673              vpninfo->cert_type == CERT_TYPE_UNKNOWN)) {
 674                 FILE *f;
 675                 PKCS12 *p12;
 676
 677                 f = fopen(vpninfo->cert, "r");
 678                 if (!f) {
 679                         vpn_progress(vpninfo, PRG_ERR,
 680                                      _("Failed to open certificate file %s: %s\n"),
 681                                      vpninfo->cert, strerror(errno));
 682                         return -ENOENT;
 683                 }
 684                 p12 = d2i_PKCS12_fp(f, NULL);
 685                 fclose(f);
 686                 if (p12)
 687                         return load_pkcs12_certificate(vpninfo, p12);
 688
 689                 /* Not PKCS#12 */
 690                 if (vpninfo->cert_type == CERT_TYPE_PKCS12) {
 691                         vpn_progress(vpninfo, PRG_ERR, _("Read PKCS#12 failed\n"));
 692                         openconnect_report_ssl_errors(vpninfo);
 693                         return -EINVAL;
 694                 }
 695                 /* Clear error and fall through to see if it's a PEM file... */
 696                 ERR_clear_error();
 697         }
 698
 699         /* It's PEM or TPM now, and either way we need to load the plain cert: */
 700 #ifdef ANDROID_KEYSTORE
 701         if (!strncmp(vpninfo->cert, "keystore:", 9)) {
 702                 BIO *b = BIO_from_keystore(vpninfo, vpninfo->cert);
 703                 if (!b)
 704                         return -EINVAL;
 705                 vpninfo->cert_x509 = PEM_read_bio_X509_AUX(b, NULL, pem_pw_cb, vpninfo);
 706                 BIO_free(b);
 707                 if (!vpninfo->cert_x509) {
 708                         vpn_progress(vpninfo, PRG_ERR,
 709                                      _("Failed to load X509 certificate from keystore\n"));
 710                         openconnect_report_ssl_errors(vpninfo);
 711                         BIO_free(b);
 712                         return -EINVAL;
 713                 }
 714                 if (!SSL_CTX_use_certificate(vpninfo->https_ctx, vpninfo->cert_x509)) {
 715                         vpn_progress(vpninfo, PRG_ERR,
 716                                      _("Failed to use X509 certificate from keystore\n"));
 717                         openconnect_report_ssl_errors(vpninfo);
 718                         X509_free(vpninfo->cert_x509);
 719                         vpninfo->cert_x509 = NULL;
 720                         return -EINVAL;
 721                 }
 722         } else
 723 #endif /* ANDROID_KEYSTORE */
 724         {
 725                 if (!SSL_CTX_use_certificate_chain_file(vpninfo->https_ctx,
 726                                                         vpninfo->cert)) {
 727                         vpn_progress(vpninfo, PRG_ERR,
 728                                      _("Loading certificate failed\n"));
 729                         openconnect_report_ssl_errors(vpninfo);
 730                         return -EINVAL;
 731                 }
 732
 733                 /* Ew, we can't get it back from the OpenSSL CTX in any sane fashion */
 734                 reload_pem_cert(vpninfo);
 735         }
 736
 737 #ifdef ANDROID_KEYSTORE
 738         if (!strncmp(vpninfo->sslkey, "keystore:", 9)) {
 739                 EVP_PKEY *key;
 740                 BIO *b;
 741
 742         again_android:
 743                 b = BIO_from_keystore(vpninfo, vpninfo->sslkey);
 744                 if (!b)
 745                         return -EINVAL;
 746                 key = PEM_read_bio_PrivateKey(b, NULL, pem_pw_cb, vpninfo);
 747                 BIO_free(b);
 748                 if (!key) {
 749                         if (is_pem_password_error(vpninfo))
 750                                 goto again_android;
 751                         return -EINVAL;
 752                 }
 753                 if (!SSL_CTX_use_PrivateKey(vpninfo->https_ctx, key)) {
 754                         vpn_progress(vpninfo, PRG_ERR,
 755                                      _("Failed to use private key from keystore\n"));
 756                         EVP_PKEY_free(key);
 757                         X509_free(vpninfo->cert_x509);
 758                         vpninfo->cert_x509 = NULL;
 759                         return -EINVAL;
 760                 }
 761                 return 0;
 762         }
 763 #endif /* ANDROID */
 764
 765         if (vpninfo->cert_type == CERT_TYPE_UNKNOWN) {
 766                 FILE *f = fopen(vpninfo->sslkey, "r");
 767                 char buf[256];
 768
 769                 if (!f) {
 770                         vpn_progress(vpninfo, PRG_ERR,
 771                                      _("Failed to open private key file %s: %s\n"),
 772                                      vpninfo->cert, strerror(errno));
 773                         return -ENOENT;
 774                 }
 775
 776                 buf[255] = 0;
 777                 while (fgets(buf, 255, f)) {
 778                         if (!strcmp(buf, "-----BEGIN TSS KEY BLOB-----\n")) {
 779                                 vpninfo->cert_type = CERT_TYPE_TPM;
 780                                 break;
 781                         } else if (!strcmp(buf, "-----BEGIN RSA PRIVATE KEY-----\n") ||
 782                                    !strcmp(buf, "-----BEGIN DSA PRIVATE KEY-----\n") ||
 783                                    !strcmp(buf, "-----BEGIN ENCRYPTED PRIVATE KEY-----\n")) {
 784                                 vpninfo->cert_type = CERT_TYPE_PEM;
 785                                 break;
 786                         }
 787                 }
 788                 fclose(f);
 789                 if (vpninfo->cert_type == CERT_TYPE_UNKNOWN) {
 790                         vpn_progress(vpninfo, PRG_ERR,
 791                                      _("Failed to identify private key type in '%s'\n"),
 792                                      vpninfo->sslkey);
 793                         return -EINVAL;
 794                 }
 795         }
 796
 797         if (vpninfo->cert_type == CERT_TYPE_TPM)
 798                 return load_tpm_certificate(vpninfo);
 799
 800         /* Standard PEM certificate */
 801         SSL_CTX_set_default_passwd_cb(vpninfo->https_ctx, pem_pw_cb);
 802         SSL_CTX_set_default_passwd_cb_userdata(vpninfo->https_ctx, vpninfo);
 803  again:
 804         if (!SSL_CTX_use_RSAPrivateKey_file(vpninfo->https_ctx, vpninfo->sslkey,
 805                                             SSL_FILETYPE_PEM)) {
 806                 if (is_pem_password_error(vpninfo))
 807                         goto again;
 808                 return -EINVAL;
 809         }
 810         return 0;
 811 }
 812
 813 static int get_cert_fingerprint(struct openconnect_info *vpninfo,
 814                                 OPENCONNECT_X509 *cert, const EVP_MD *type,
 815                                 char *buf)
 816 {
 817         unsigned char md[EVP_MAX_MD_SIZE];
 818         unsigned int i, n;
 819
 820         if (!X509_digest(cert, type, md, &n))
 821                 return -ENOMEM;
 822
 823         for (i=0; i < n; i++)
 824                 sprintf(&buf[i*2], "%02X", md[i]);
 825
 826         return 0;
 827 }
 828
 829 int get_cert_md5_fingerprint(struct openconnect_info *vpninfo,
 830                              OPENCONNECT_X509 *cert, char *buf)
 831 {
 832         return get_cert_fingerprint(vpninfo, cert, EVP_md5(), buf);
 833 }
 834
 835 int openconnect_get_cert_sha1(struct openconnect_info *vpninfo,
 836                               OPENCONNECT_X509 *cert, char *buf)
 837 {
 838         return get_cert_fingerprint(vpninfo, cert, EVP_sha1(), buf);
 839 }
 840
 841 static int check_server_cert(struct openconnect_info *vpninfo, X509 *cert)
 842 {
 843         char fingerprint[EVP_MAX_MD_SIZE * 2 + 1];
 844         int ret;
 845
 846         ret = openconnect_get_cert_sha1(vpninfo, cert, fingerprint);
 847         if (ret)
 848                 return ret;
 849
 850         if (strcasecmp(vpninfo->servercert, fingerprint)) {
 851                 vpn_progress(vpninfo, PRG_ERR,
 852                              _("Server SSL certificate didn't match: %s\n"), fingerprint);
 853                 return -EINVAL;
 854         }
 855         return 0;
 856 }
 857
 858 static int match_hostname_elem(const char *hostname, int helem_len,
 859                                const char *match, int melem_len)
 860 {
 861         if (!helem_len && !melem_len)
 862                 return 0;
 863
 864         if (!helem_len || !melem_len)
 865                 return -1;
 866
 867
 868         if (match[0] == '*') {
 869                 int i;
 870
 871                 for (i = 1 ; i <= helem_len; i++) {
 872                         if (!match_hostname_elem(hostname + i, helem_len - i,
 873                                                  match + 1, melem_len - 1))
 874                                 return 0;
 875                 }
 876                 return -1;
 877         }
 878
 879         /* From the NetBSD (5.1) man page for ctype(3):
 880            Values of type char or signed char must first be cast to unsigned char,
 881            to ensure that the values are within the correct range.  The result
 882            should then be cast to int to avoid warnings from some compilers.
 883            We do indeed get warning "array subscript has type 'char'" without
 884            the casts. Ick. */
 885         if (toupper((int)(unsigned char)hostname[0]) ==
 886             toupper((int)(unsigned char)match[0]))
 887                 return match_hostname_elem(hostname + 1, helem_len - 1,
 888                                            match + 1, melem_len - 1);
 889
 890         return -1;
 891 }
 892
 893 static int match_hostname(const char *hostname, const char *match)
 894 {
 895         while (*match) {
 896                 const char *h_dot, *m_dot;
 897                 int helem_len, melem_len;
 898
 899                 h_dot = strchr(hostname, '.');
 900                 m_dot = strchr(match, '.');
 901
 902                 if (h_dot && m_dot) {
 903                         helem_len = h_dot - hostname + 1;
 904                         melem_len = m_dot - match + 1;
 905                 } else if (!h_dot && !m_dot) {
 906                         helem_len = strlen(hostname);
 907                         melem_len = strlen(match);
 908                 } else
 909                         return -1;
 910
 911
 912                 if (match_hostname_elem(hostname, helem_len,
 913                                         match, melem_len))
 914                         return -1;
 915
 916                 hostname += helem_len;
 917                 match += melem_len;
 918         }
 919         if (*hostname)
 920                 return -1;
 921
 922         return 0;
 923 }
 924
 925 /* cf. RFC2818 and RFC2459 */
 926 static int match_cert_hostname(struct openconnect_info *vpninfo, X509 *peer_cert)
 927 {
 928         STACK_OF(GENERAL_NAME) *altnames;
 929         X509_NAME *subjname;
 930         ASN1_STRING *subjasn1;
 931         char *subjstr = NULL;
 932         int addrlen = 0;
 933         int i, altdns = 0;
 934         char addrbuf[sizeof(struct in6_addr)];
 935         int ret;
 936
 937         /* Allow GEN_IP in the certificate only if we actually connected
 938            by IP address rather than by name. */
 939         if (inet_pton(AF_INET, vpninfo->hostname, addrbuf) > 0)
 940                 addrlen = 4;
 941         else if (inet_pton(AF_INET6, vpninfo->hostname, addrbuf) > 0)
 942                 addrlen = 16;
 943         else if (vpninfo->hostname[0] == '[' &&
 944                  vpninfo->hostname[strlen(vpninfo->hostname)-1] == ']') {
 945                 char *p = &vpninfo->hostname[strlen(vpninfo->hostname)-1];
 946                 *p = 0;
 947                 if (inet_pton(AF_INET6, vpninfo->hostname + 1, addrbuf) > 0)
 948                         addrlen = 16;
 949                 *p = ']';
 950         }
 951
 952         altnames = X509_get_ext_d2i(peer_cert, NID_subject_alt_name,
 953                                     NULL, NULL);
 954         for (i = 0; i < sk_GENERAL_NAME_num(altnames); i++) {
 955                 const GENERAL_NAME *this = sk_GENERAL_NAME_value(altnames, i);
 956
 957                 if (this->type == GEN_DNS) {
 958                         char *str;
 959
 960                         int len = ASN1_STRING_to_UTF8((void *)&str, this->d.ia5);
 961                         if (len < 0)
 962                                 continue;
 963
 964                         altdns = 1;
 965
 966                         /* We don't like names with embedded NUL */
 967                         if (strlen(str) != len)
 968                                 continue;
 969
 970                         if (!match_hostname(vpninfo->hostname, str)) {
 971                                 vpn_progress(vpninfo, PRG_TRACE,
 972                                              _("Matched DNS altname '%s'\n"),
 973                                              str);
 974                                 GENERAL_NAMES_free(altnames);
 975                                 OPENSSL_free(str);
 976                                 return 0;
 977                         } else {
 978                                 vpn_progress(vpninfo, PRG_TRACE,
 979                                              _("No match for altname '%s'\n"),
 980                                              str);
 981                         }
 982                         OPENSSL_free(str);
 983                 } else if (this->type == GEN_IPADD && addrlen) {
 984                         char host[80];
 985                         int family;
 986
 987                         if (this->d.ip->length == 4) {
 988                                 family = AF_INET;
 989                         } else if (this->d.ip->length == 16) {
 990                                 family = AF_INET6;
 991                         } else {
 992                                 vpn_progress(vpninfo, PRG_ERR,
 993                                              _("Certificate has GEN_IPADD altname with bogus length %d\n"),
 994                                              this->d.ip->length);
 995                                 continue;
 996                         }
 997
 998                         /* We only do this for the debug messages */
 999                         inet_ntop(family, this->d.ip->data, host, sizeof(host));
1000
1001                         if (this->d.ip->length == addrlen &&
1002                             !memcmp(addrbuf, this->d.ip->data, addrlen)) {
1003                                 vpn_progress(vpninfo, PRG_TRACE,
1004                                              _("Matched %s address '%s'\n"),
1005                                              (family == AF_INET6)?"IPv6":"IPv4",
1006                                              host);
1007                                 GENERAL_NAMES_free(altnames);
1008                                 return 0;
1009                         } else {
1010                                 vpn_progress(vpninfo, PRG_TRACE,
1011                                              _("No match for %s address '%s'\n"),
1012                                              (family == AF_INET6)?"IPv6":"IPv4",
1013                                              host);
1014                         }
1015                 } else if (this->type == GEN_URI) {
1016                         char *str;
1017                         char *url_proto, *url_host, *url_path, *url_host2;
1018                         int url_port;
1019                         int len = ASN1_STRING_to_UTF8((void *)&str, this->d.ia5);
1020
1021                         if (len < 0)
1022                                 continue;
1023
1024                         /* We don't like names with embedded NUL */
1025                         if (strlen(str) != len)
1026                                 continue;
1027
1028                         if (internal_parse_url(str, &url_proto, &url_host, &url_port, &url_path, 0)) {
1029                                 OPENSSL_free(str);
1030                                 continue;
1031                         }
1032
1033                         if (!url_proto || strcasecmp(url_proto, "https"))
1034                                 goto no_uri_match;
1035
1036                         if (url_port != vpninfo->port)
1037                                 goto no_uri_match;
1038
1039                         /* Leave url_host as it was so that it can be freed */
1040                         url_host2 = url_host;
1041                         if (addrlen == 16 && vpninfo->hostname[0] != '[' &&
1042                             url_host[0] == '[' && url_host[strlen(url_host)-1] == ']') {
1043                                 /* Cope with https://[IPv6]/ when the hostname is bare IPv6 */
1044                                 url_host[strlen(url_host)-1] = 0;
1045                                 url_host2++;
1046                         }
1047
1048                         if (strcasecmp(vpninfo->hostname, url_host2))
1049                                 goto no_uri_match;
1050
1051                         if (url_path) {
1052                                 vpn_progress(vpninfo, PRG_TRACE,
1053                                              _("URI '%s' has non-empty path; ignoring\n"),
1054                                              str);
1055                                 goto no_uri_match_silent;
1056                         }
1057                         vpn_progress(vpninfo, PRG_TRACE,
1058                                      _("Matched URI '%s'\n"),
1059                                      str);
1060                         free(url_proto);
1061                         free(url_host);
1062                         free(url_path);
1063                         OPENSSL_free(str);
1064                         GENERAL_NAMES_free(altnames);
1065                         return 0;
1066
1067                 no_uri_match:
1068                         vpn_progress(vpninfo, PRG_TRACE,
1069                                      _("No match for URI '%s'\n"),
1070                                      str);
1071                 no_uri_match_silent:
1072                         free(url_proto);
1073                         free(url_host);
1074                         free(url_path);
1075                         OPENSSL_free(str);
1076                 }
1077         }
1078         GENERAL_NAMES_free(altnames);
1079
1080         /* According to RFC2818, we don't use the legacy subject name if
1081            there was an altname with DNS type. */
1082         if (altdns) {
1083                 vpn_progress(vpninfo, PRG_ERR,
1084                              _("No altname in peer cert matched '%s'\n"),
1085                              vpninfo->hostname);
1086                 return -EINVAL;
1087         }
1088
1089         subjname = X509_get_subject_name(peer_cert);
1090         if (!subjname) {
1091                 vpn_progress(vpninfo, PRG_ERR,
1092                              _("No subject name in peer cert!\n"));
1093                 return -EINVAL;
1094         }
1095
1096         /* Find the _last_ (most specific) commonName */
1097         i = -1;
1098         while (1) {
1099                 int j = X509_NAME_get_index_by_NID(subjname, NID_commonName, i);
1100                 if (j >= 0)
1101                         i = j;
1102                 else
1103                         break;
1104         }
1105
1106         subjasn1 = X509_NAME_ENTRY_get_data(X509_NAME_get_entry(subjname, i));
1107
1108         i = ASN1_STRING_to_UTF8((void *)&subjstr, subjasn1);
1109
1110         if (!subjstr || strlen(subjstr) != i) {
1111                 vpn_progress(vpninfo, PRG_ERR,
1112                              _("Failed to parse subject name in peer cert\n"));
1113                 return -EINVAL;
1114         }
1115         ret = 0;
1116
1117         if (match_hostname(vpninfo->hostname, subjstr)) {
1118                 vpn_progress(vpninfo, PRG_ERR,
1119                              _("Peer cert subject mismatch ('%s' != '%s')\n"),
1120                              subjstr, vpninfo->hostname);
1121                 ret = -EINVAL;
1122         } else {
1123                 vpn_progress(vpninfo, PRG_TRACE,
1124                              _("Matched peer certificate subject name '%s'\n"),
1125                              subjstr);
1126         }
1127
1128         OPENSSL_free(subjstr);
1129         return ret;
1130 }
1131
1132 static int verify_peer(struct openconnect_info *vpninfo, SSL *https_ssl)
1133 {
1134         X509 *peer_cert;
1135         int ret;
1136
1137         peer_cert = SSL_get_peer_certificate(https_ssl);
1138
1139         if (vpninfo->servercert) {
1140                 /* If given a cert fingerprint on the command line, that's
1141                    all we look for */
1142                 ret = check_server_cert(vpninfo, peer_cert);
1143         } else {
1144                 int vfy = SSL_get_verify_result(https_ssl);
1145                 const char *err_string = NULL;
1146
1147                 if (vfy != X509_V_OK)
1148                         err_string = X509_verify_cert_error_string(vfy);
1149                 else if (match_cert_hostname(vpninfo, peer_cert))
1150                         err_string = _("certificate does not match hostname");
1151
1152                 if (err_string) {
1153                         vpn_progress(vpninfo, PRG_INFO,
1154                                      _("Server certificate verify failed: %s\n"),
1155                                      err_string);
1156
1157                         if (vpninfo->validate_peer_cert)
1158                                 ret = vpninfo->validate_peer_cert(vpninfo->cbdata,
1159                                                                   peer_cert,
1160                                                                   err_string);
1161                         else
1162                                 ret = -EINVAL;
1163                 } else {
1164                         ret = 0;
1165                 }
1166         }
1167         X509_free(peer_cert);
1168
1169         return ret;
1170 }
1171
1172 static void workaround_openssl_certchain_bug(struct openconnect_info *vpninfo,
1173                                              SSL *ssl)
1174 {
1175         /* OpenSSL has problems with certificate chains -- if there are
1176            multiple certs with the same name, it doesn't necessarily
1177            choose the _right_ one. (RT#1942)
1178            Pick the right ones for ourselves and add them manually. */
1179         X509 *cert = SSL_get_certificate(ssl);
1180         X509 *cert2;
1181         X509_STORE *store = SSL_CTX_get_cert_store(vpninfo->https_ctx);
1182         X509_STORE_CTX ctx;
1183
1184         if (!cert || !store)
1185                 return;
1186
1187         /* If we already have 'supporting' certs, don't add them again */
1188         if (vpninfo->https_ctx->extra_certs)
1189                 return;
1190
1191         if (!X509_STORE_CTX_init(&ctx, store, NULL, NULL))
1192                 return;
1193
1194         while (ctx.get_issuer(&cert2, &ctx, cert) == 1) {
1195                 char buf[200];
1196                 if (cert2 == cert)
1197                         break;
1198                 if (X509_check_issued(cert2, cert2) == X509_V_OK)
1199                         break;
1200                 cert = cert2;
1201                 X509_NAME_oneline(X509_get_subject_name(cert),
1202                                   buf, sizeof(buf));
1203                 vpn_progress(vpninfo, PRG_DEBUG,
1204                              _("Extra cert from cafile: '%s'\n"), buf);
1205                 SSL_CTX_add_extra_chain_cert(vpninfo->https_ctx, cert);
1206         }
1207         X509_STORE_CTX_cleanup(&ctx);
1208 }
1209
1210 #if OPENSSL_VERSION_NUMBER >= 0x00908000
1211 static int ssl_app_verify_callback(X509_STORE_CTX *ctx, void *arg)
1212 {
1213         /* We've seen certificates in the wild which don't have the
1214            purpose fields filled in correctly */
1215         X509_VERIFY_PARAM_set_purpose(ctx->param, X509_PURPOSE_ANY);
1216         return X509_verify_cert(ctx);
1217 }
1218 #endif
1219
1220 static int check_certificate_expiry(struct openconnect_info *vpninfo)
1221 {
1222         ASN1_TIME *notAfter;
1223         const char *reason = NULL;
1224         time_t t;
1225         int i;
1226
1227         if (!vpninfo->cert_x509)
1228                 return 0;
1229
1230         t = time(NULL);
1231         notAfter = X509_get_notAfter(vpninfo->cert_x509);
1232         i = X509_cmp_time(notAfter, &t);
1233         if (!i) {
1234                 vpn_progress(vpninfo, PRG_ERR,
1235                              _("Error in client cert notAfter field\n"));
1236                 return -EINVAL;
1237         } else if (i < 0) {
1238                 reason = _("Client certificate has expired at");
1239         } else {
1240                 t += vpninfo->cert_expire_warning;
1241                 i = X509_cmp_time(notAfter, &t);
1242                 if (i < 0) {
1243                         reason = _("Client certificate expires soon at");
1244                 }
1245         }
1246         if (reason) {
1247                 BIO *bp = BIO_new(BIO_s_mem());
1248                 BUF_MEM *bm;
1249                 const char *expiry = _("<error>");
1250                 char zero = 0;
1251
1252                 if (bp) {
1253                         ASN1_TIME_print(bp, notAfter);
1254                         BIO_write(bp, &zero, 1);
1255                         BIO_get_mem_ptr(bp, &bm);
1256                         expiry = bm->data;
1257                 }
1258                 vpn_progress(vpninfo, PRG_ERR, "%s: %s\n", reason, expiry);
1259                 if (bp)
1260                         BIO_free(bp);
1261         }
1262         return 0;
1263 }
1264 int openconnect_open_https(struct openconnect_info *vpninfo)
1265 {
1266         method_const SSL_METHOD *ssl3_method;
1267         SSL *https_ssl;
1268         BIO *https_bio;
1269         int ssl_sock;
1270         int err;
1271
1272         if (vpninfo->https_ssl)
1273                 return 0;
1274
1275         if (vpninfo->peer_cert) {
1276                 X509_free(vpninfo->peer_cert);
1277                 vpninfo->peer_cert = NULL;
1278         }
1279
1280         ssl_sock = connect_https_socket(vpninfo);
1281         if (ssl_sock < 0)
1282                 return ssl_sock;
1283
1284         ssl3_method = TLSv1_client_method();
1285         if (!vpninfo->https_ctx) {
1286                 vpninfo->https_ctx = SSL_CTX_new(ssl3_method);
1287
1288                 /* Some servers (or their firewalls) really don't like seeing
1289                    extensions. */
1290 #ifdef SSL_OP_NO_TICKET
1291                 SSL_CTX_set_options (vpninfo->https_ctx, SSL_OP_NO_TICKET);
1292 #endif
1293
1294                 if (vpninfo->cert) {
1295                         err = load_certificate(vpninfo);
1296                         if (err) {
1297                                 vpn_progress(vpninfo, PRG_ERR,
1298                                              _("Loading certificate failed. Aborting.\n"));
1299                                 return err;
1300                         }
1301                         check_certificate_expiry(vpninfo);
1302                 }
1303
1304                 /* We just want to do:
1305                    SSL_CTX_set_purpose(vpninfo->https_ctx, X509_PURPOSE_ANY);
1306                    ... but it doesn't work with OpenSSL < 0.9.8k because of
1307                    problems with inheritance (fixed in v1.1.4.6 of
1308                    crypto/x509/x509_vpm.c) so we have to play silly buggers
1309                    instead. This trick doesn't work _either_ in < 0.9.7 but
1310                    I don't know of _any_ workaround which will, and can't
1311                    be bothered to find out either. */
1312 #if OPENSSL_VERSION_NUMBER >= 0x00908000
1313                 SSL_CTX_set_cert_verify_callback(vpninfo->https_ctx,
1314                                                  ssl_app_verify_callback, NULL);
1315 #endif
1316                 SSL_CTX_set_default_verify_paths(vpninfo->https_ctx);
1317
1318                 if (vpninfo->cafile) {
1319                         if (!SSL_CTX_load_verify_locations(vpninfo->https_ctx, vpninfo->cafile, NULL)) {
1320                                 vpn_progress(vpninfo, PRG_ERR,
1321                                              _("Failed to open CA file '%s'\n"),
1322                                              vpninfo->cafile);
1323                                 openconnect_report_ssl_errors(vpninfo);
1324                                 close(ssl_sock);
1325                                 return -EINVAL;
1326                         }
1327                 }
1328
1329         }
1330         https_ssl = SSL_new(vpninfo->https_ctx);
1331         workaround_openssl_certchain_bug(vpninfo, https_ssl);
1332
1333         https_bio = BIO_new_socket(ssl_sock, BIO_NOCLOSE);
1334         BIO_set_nbio(https_bio, 1);
1335         SSL_set_bio(https_ssl, https_bio, https_bio);
1336
1337         vpn_progress(vpninfo, PRG_INFO, _("SSL negotiation with %s\n"),
1338                      vpninfo->hostname);
1339
1340         while ((err = SSL_connect(https_ssl)) <= 0) {
1341                 fd_set wr_set, rd_set;
1342                 int maxfd = ssl_sock;
1343
1344                 FD_ZERO(&wr_set);
1345                 FD_ZERO(&rd_set);
1346
1347                 err = SSL_get_error(https_ssl, err);
1348                 if (err == SSL_ERROR_WANT_READ)
1349                         FD_SET(ssl_sock, &rd_set);
1350                 else if (err == SSL_ERROR_WANT_WRITE)
1351                         FD_SET(ssl_sock, &wr_set);
1352                 else {
1353                         vpn_progress(vpninfo, PRG_ERR, _("SSL connection failure\n"));
1354                         openconnect_report_ssl_errors(vpninfo);
1355                         SSL_free(https_ssl);
1356                         close(ssl_sock);
1357                         return -EINVAL;
1358                 }
1359
1360                 if (vpninfo->cancel_fd != -1) {
1361                         FD_SET(vpninfo->cancel_fd, &rd_set);
1362                         if (vpninfo->cancel_fd > ssl_sock)
1363                                 maxfd = vpninfo->cancel_fd;
1364                 }
1365                 select(maxfd + 1, &rd_set, &wr_set, NULL, NULL);
1366                 if (vpninfo->cancel_fd != -1 &&
1367                     FD_ISSET(vpninfo->cancel_fd, &rd_set)) {
1368                         vpn_progress(vpninfo, PRG_ERR, _("SSL connection cancelled\n"));
1369                         SSL_free(https_ssl);
1370                         close(ssl_sock);
1371                         return -EINVAL;
1372                 }
1373         }
1374
1375         if (verify_peer(vpninfo, https_ssl)) {
1376                 SSL_free(https_ssl);
1377                 close(ssl_sock);
1378                 return -EINVAL;
1379         }
1380
1381         vpninfo->ssl_fd = ssl_sock;
1382         vpninfo->https_ssl = https_ssl;
1383
1384         /* Stash this now, because it might not be available later if the
1385            server has disconnected. */
1386         vpninfo->peer_cert = SSL_get_peer_certificate(vpninfo->https_ssl);
1387
1388         vpn_progress(vpninfo, PRG_INFO, _("Connected to HTTPS on %s\n"),
1389                      vpninfo->hostname);
1390
1391         return 0;
1392 }
1393
1394 void openconnect_close_https(struct openconnect_info *vpninfo, int final)
1395 {
1396         if (vpninfo->peer_cert) {
1397                 X509_free(vpninfo->peer_cert);
1398                 vpninfo->peer_cert = NULL;
1399         }
1400         if (vpninfo->https_ssl) {
1401                 SSL_free(vpninfo->https_ssl);
1402                 vpninfo->https_ssl = NULL;
1403         }
1404         if (vpninfo->ssl_fd != -1) {
1405                 close(vpninfo->ssl_fd);
1406                 FD_CLR(vpninfo->ssl_fd, &vpninfo->select_rfds);
1407                 FD_CLR(vpninfo->ssl_fd, &vpninfo->select_wfds);
1408                 FD_CLR(vpninfo->ssl_fd, &vpninfo->select_efds);
1409                 vpninfo->ssl_fd = -1;
1410         }
1411         if (final) {
1412                 if (vpninfo->https_ctx) {
1413                         SSL_CTX_free(vpninfo->https_ctx);
1414                         vpninfo->https_ctx = NULL;
1415                 }
1416                 if (vpninfo->cert_x509) {
1417                         X509_free(vpninfo->cert_x509);
1418                         vpninfo->cert_x509 = NULL;
1419                 }
1420         }
1421 }
1422
1423 void openconnect_init_ssl(void)
1424 {
1425         SSL_library_init ();
1426         ERR_clear_error ();
1427         SSL_load_error_strings ();
1428         OpenSSL_add_all_algorithms ();
1429 }
1430
1431 char *openconnect_get_cert_details(struct openconnect_info *vpninfo,
1432                                    OPENCONNECT_X509 *cert)
1433 {
1434         BIO *bp = BIO_new(BIO_s_mem());
1435         BUF_MEM *certinfo;
1436         char zero = 0;
1437         char *ret;
1438
1439         X509_print_ex(bp, cert, 0, 0);
1440         BIO_write(bp, &zero, 1);
1441         BIO_get_mem_ptr(bp, &certinfo);
1442
1443         ret = strdup(certinfo->data);
1444         BIO_free(bp);
1445         return ret;
1446 }
1447
1448
1449 int openconnect_local_cert_md5(struct openconnect_info *vpninfo,
1450                                char *buf)
1451 {
1452         buf[0] = 0;
1453
1454         if (!vpninfo->cert_x509)
1455                 return -EIO;
1456
1457         if (get_cert_md5_fingerprint(vpninfo, vpninfo->cert_x509, buf))
1458                 return -EIO;
1459
1460         return 0;
1461 }