git.sur5r.net Git - bacula/bacula/blob - bacula/src/lib/tls.c

   1 /*
   2  * tls.c TLS support functions
   3  *
   4  * Author: Landon Fuller <landonf@threerings.net>
   5  *
   6  * Version $Id$
   7  *
   8  * This file was contributed to the Bacula project by Landon Fuller
   9  * and Three Rings Design, Inc.
  10  *
  11  * Three Rings Design, Inc. has been granted a perpetual, worldwide,
  12  * non-exclusive, no-charge, royalty-free, irrevocable copyright
  13  * license to reproduce, prepare derivative works of, publicly
  14  * display, publicly perform, sublicense, and distribute the original
  15  * work contributed by Three Rings Design, Inc. and its employees to
  16  * the Bacula project in source or object form.
  17  *
  18  * If you wish to license contributions from Three Rings Design, Inc,
  19  * under an alternate open source license please contact
  20  * Landon Fuller <landonf@threerings.net>.
  21  */
  22 /*
  23    Bacula® - The Network Backup Solution
  24
  25    Copyright (C) 2005-2007 Free Software Foundation Europe e.V.
  26
  27    The main author of Bacula is Kern Sibbald, with contributions from
  28    many others, a complete list can be found in the file AUTHORS.
  29    This program is Free Software; you can redistribute it and/or
  30    modify it under the terms of version two of the GNU General Public
  31    License as published by the Free Software Foundation plus additions
  32    that are listed in the file LICENSE.
  33
  34    This program is distributed in the hope that it will be useful, but
  35    WITHOUT ANY WARRANTY; without even the implied warranty of
  36    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  37    General Public License for more details.
  38
  39    You should have received a copy of the GNU General Public License
  40    along with this program; if not, write to the Free Software
  41    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  42    02110-1301, USA.
  43
  44    Bacula® is a registered trademark of John Walker.
  45    The licensor of Bacula is the Free Software Foundation Europe
  46    (FSFE), Fiduciary Program, Sumatrastrasse 25, 8006 Zürich,
  47    Switzerland, email:ftf@fsfeurope.org.
  48 */
  49
  50
  51 #include "bacula.h"
  52 #include <assert.h>
  53
  54 extern time_t watchdog_time;
  55
  56 #ifdef HAVE_TLS /* Is TLS enabled? */
  57
  58 #ifdef HAVE_OPENSSL /* How about OpenSSL? */
  59
  60 /* No anonymous ciphers, no <128 bit ciphers, no export ciphers, no MD5 ciphers */
  61 #define TLS_DEFAULT_CIPHERS "ALL:!ADH:!LOW:!EXP:!MD5:@STRENGTH"
  62
  63 /* TLS Context Structure */
  64 struct TLS_Context {
  65    SSL_CTX *openssl;
  66    CRYPTO_PEM_PASSWD_CB *pem_callback;
  67    const void *pem_userdata;
  68    bool tls_enable;
  69    bool tls_require;
  70 };
  71
  72 struct TLS_Connection {
  73    SSL *openssl;
  74 };
  75
  76 /*
  77  * OpenSSL certificate verification callback.
  78  * OpenSSL has already performed internal certificate verification.
  79  * We just report any errors that occured.
  80  */
  81 static int openssl_verify_peer(int ok, X509_STORE_CTX *store)
  82 {
  83    if (!ok) {
  84       X509 *cert = X509_STORE_CTX_get_current_cert(store);
  85       int depth = X509_STORE_CTX_get_error_depth(store);
  86       int err = X509_STORE_CTX_get_error(store);
  87       char issuer[256];
  88       char subject[256];
  89
  90       X509_NAME_oneline(X509_get_issuer_name(cert), issuer, 256);
  91       X509_NAME_oneline(X509_get_subject_name(cert), subject, 256);
  92
  93       Emsg5(M_ERROR, 0, _("Error with certificate at depth: %d, issuer = %s,"
  94                           " subject = %s, ERR=%d:%s\n"), depth, issuer,
  95                           subject, err, X509_verify_cert_error_string(err));
  96
  97    }
  98
  99    return ok;
 100 }
 101
 102 /* Dispatch user PEM encryption callbacks */
 103 static int tls_pem_callback_dispatch (char *buf, int size, int rwflag, void *userdata)
 104 {
 105    TLS_CONTEXT *ctx = (TLS_CONTEXT *)userdata;
 106    return (ctx->pem_callback(buf, size, ctx->pem_userdata));
 107 }
 108
 109 /*
 110  * Create a new TLS_CONTEXT instance.
 111  *  Returns: Pointer to TLS_CONTEXT instance on success
 112  *           NULL on failure;
 113  */
 114 TLS_CONTEXT *new_tls_context(const char *ca_certfile, const char *ca_certdir,
 115                              const char *certfile, const char *keyfile,
 116                              CRYPTO_PEM_PASSWD_CB *pem_callback,
 117                              const void *pem_userdata, const char *dhfile,
 118                              bool verify_peer)
 119 {
 120    TLS_CONTEXT *ctx;
 121    BIO *bio;
 122    DH *dh;
 123
 124    ctx = (TLS_CONTEXT *)malloc(sizeof(TLS_CONTEXT));
 125
 126    /* Allocate our OpenSSL TLSv1 Context */
 127    ctx->openssl = SSL_CTX_new(TLSv1_method());
 128
 129    if (!ctx->openssl) {
 130       openssl_post_errors(M_ERROR, _("Error initializing SSL context"));
 131       goto err;
 132    }
 133
 134    /* Set up pem encryption callback */
 135    if (pem_callback) {
 136       ctx->pem_callback = pem_callback;
 137       ctx->pem_userdata = pem_userdata;
 138    } else {
 139       ctx->pem_callback = crypto_default_pem_callback;
 140       ctx->pem_userdata = NULL;
 141    }
 142    SSL_CTX_set_default_passwd_cb(ctx->openssl, tls_pem_callback_dispatch);
 143    SSL_CTX_set_default_passwd_cb_userdata(ctx->openssl, (void *) ctx);
 144
 145    /*
 146     * Set certificate verification paths. This requires that at least one
 147     * value be non-NULL
 148     */
 149    if (ca_certfile || ca_certdir) {
 150       if (!SSL_CTX_load_verify_locations(ctx->openssl, ca_certfile, ca_certdir)) {
 151          openssl_post_errors(M_ERROR, _("Error loading certificate verification stores"));
 152          goto err;
 153       }
 154    } else if (verify_peer) {
 155       /* At least one CA is required for peer verification */
 156       Emsg0(M_ERROR, 0, _("Either a certificate file or a directory must be"
 157                          " specified as a verification store\n"));
 158       goto err;
 159    }
 160
 161    /*
 162     * Load our certificate file, if available. This file may also contain a
 163     * private key, though this usage is somewhat unusual.
 164     */
 165    if (certfile) {
 166       if (!SSL_CTX_use_certificate_chain_file(ctx->openssl, certfile)) {
 167          openssl_post_errors(M_ERROR, _("Error loading certificate file"));
 168          goto err;
 169       }
 170    }
 171
 172    /* Load our private key. */
 173    if (keyfile) {
 174       if (!SSL_CTX_use_PrivateKey_file(ctx->openssl, keyfile, SSL_FILETYPE_PEM)) {
 175          openssl_post_errors(M_ERROR, _("Error loading private key"));
 176          goto err;
 177       }
 178    }
 179
 180    /* Load Diffie-Hellman Parameters. */
 181    if (dhfile) {
 182       if (!(bio = BIO_new_file(dhfile, "r"))) {
 183          openssl_post_errors(M_ERROR, _("Unable to open DH parameters file"));
 184          goto err;
 185       }
 186       dh = PEM_read_bio_DHparams(bio, NULL, NULL, NULL);
 187       BIO_free(bio);
 188       if (!dh) {
 189          openssl_post_errors(M_ERROR, _("Unable to load DH parameters from specified file"));
 190          goto err;
 191       }
 192       if (!SSL_CTX_set_tmp_dh(ctx->openssl, dh)) {
 193          openssl_post_errors(M_ERROR, _("Failed to set TLS Diffie-Hellman parameters"));
 194          DH_free(dh);
 195          goto err;
 196       }
 197       /* Enable Single-Use DH for Ephemeral Keying */
 198       SSL_CTX_set_options(ctx->openssl, SSL_OP_SINGLE_DH_USE);
 199    }
 200
 201    if (SSL_CTX_set_cipher_list(ctx->openssl, TLS_DEFAULT_CIPHERS) != 1) {
 202       Emsg0(M_ERROR, 0, _("Error setting cipher list, no valid ciphers available\n"));
 203       goto err;
 204    }
 205
 206    /* Verify Peer Certificate */
 207    if (verify_peer) {
 208       /* SSL_VERIFY_FAIL_IF_NO_PEER_CERT has no effect in client mode */
 209       SSL_CTX_set_verify(ctx->openssl,
 210                          SSL_VERIFY_PEER|SSL_VERIFY_FAIL_IF_NO_PEER_CERT,
 211                          openssl_verify_peer);
 212    }
 213
 214    return ctx;
 215
 216 err:
 217    /* Clean up after ourselves */
 218    if(ctx->openssl) {
 219       SSL_CTX_free(ctx->openssl);
 220    }
 221    free(ctx);
 222    return NULL;
 223 }
 224
 225 /*
 226  * Free TLS_CONTEXT instance
 227  */
 228 void free_tls_context(TLS_CONTEXT *ctx)
 229 {
 230    SSL_CTX_free(ctx->openssl);
 231    free(ctx);
 232 }
 233
 234 bool get_tls_require(TLS_CONTEXT *ctx)
 235 {
 236    return ctx->tls_require;
 237 }
 238
 239 bool get_tls_enable(TLS_CONTEXT *ctx)
 240 {
 241    return ctx->tls_enable;
 242 }
 243
 244
 245 /*
 246  * Verifies a list of common names against the certificate
 247  * commonName attribute.
 248  *  Returns: true on success
 249  *           false on failure
 250  */
 251 bool tls_postconnect_verify_cn(TLS_CONNECTION *tls, alist *verify_list)
 252 {
 253    SSL *ssl = tls->openssl;
 254    X509 *cert;
 255    X509_NAME *subject;
 256    bool auth_success = false;
 257    char data[256];
 258
 259    /* Check if peer provided a certificate */
 260    if (!(cert = SSL_get_peer_certificate(ssl))) {
 261       Emsg0(M_ERROR, 0, _("Peer failed to present a TLS certificate\n"));
 262       return false;
 263    }
 264
 265    if ((subject = X509_get_subject_name(cert)) != NULL) {
 266       if (X509_NAME_get_text_by_NID(subject, NID_commonName, data, sizeof(data)) > 0) {
 267          char *cn;
 268          /* NULL terminate data */
 269          data[255] = 0;
 270
 271          /* Try all the CNs in the list */
 272          foreach_alist(cn, verify_list) {
 273             if (strcasecmp(data, cn) == 0) {
 274                auth_success = true;
 275             }
 276          }
 277       }
 278    }
 279
 280    X509_free(cert);
 281    return auth_success;
 282 }
 283
 284 /*
 285  * Verifies a peer's hostname against the subjectAltName and commonName
 286  * attributes.
 287  *  Returns: true on success
 288  *           false on failure
 289  */
 290 bool tls_postconnect_verify_host(TLS_CONNECTION *tls, const char *host)
 291 {
 292    SSL *ssl = tls->openssl;
 293    X509 *cert;
 294    X509_NAME *subject;
 295    bool auth_success = false;
 296    int extensions;
 297    char data[256];
 298    int i, j;
 299
 300
 301    /* Check if peer provided a certificate */
 302    if (!(cert = SSL_get_peer_certificate(ssl))) {
 303       Emsg1(M_ERROR, 0, _("Peer %s failed to present a TLS certificate\n"), host);
 304       return false;
 305    }
 306
 307    /* Check subjectAltName extensions first */
 308    if ((extensions = X509_get_ext_count(cert)) > 0) {
 309       for (i = 0; i < extensions; i++) {
 310          X509_EXTENSION *ext;
 311          const char *extname;
 312
 313          ext = X509_get_ext(cert, i);
 314          extname = OBJ_nid2sn(OBJ_obj2nid(X509_EXTENSION_get_object(ext)));
 315
 316          if (strcmp(extname, "subjectAltName") == 0) {
 317             X509V3_EXT_METHOD *method;
 318             STACK_OF(CONF_VALUE) *val;
 319             CONF_VALUE *nval;
 320             void *extstr = NULL;
 321 #if (OPENSSL_VERSION_NUMBER >= 0x0090800FL)
 322             const unsigned char *ext_value_data;
 323 #else
 324             unsigned char *ext_value_data;
 325 #endif
 326
 327             /* Get x509 extension method structure */
 328             if (!(method = X509V3_EXT_get(ext))) {
 329                break;
 330             }
 331
 332             ext_value_data = ext->value->data;
 333
 334 #if (OPENSSL_VERSION_NUMBER > 0x00907000L)
 335             if (method->it) {
 336                /* New style ASN1 */
 337
 338                /* Decode ASN1 item in data */
 339                extstr = ASN1_item_d2i(NULL, &ext_value_data, ext->value->length,
 340                                       ASN1_ITEM_ptr(method->it));
 341             } else {
 342                /* Old style ASN1 */
 343
 344                /* Decode ASN1 item in data */
 345                extstr = method->d2i(NULL, &ext_value_data, ext->value->length);
 346             }
 347
 348 #else
 349             extstr = method->d2i(NULL, &ext_value_data, ext->value->length);
 350 #endif
 351
 352             /* Iterate through to find the dNSName field(s) */
 353             val = method->i2v(method, extstr, NULL);
 354
 355             /* dNSName shortname is "DNS" */
 356             for (j = 0; j < sk_CONF_VALUE_num(val); j++) {
 357                nval = sk_CONF_VALUE_value(val, j);
 358                if (strcmp(nval->name, "DNS") == 0) {
 359                   if (strcasecmp(nval->value, host) == 0) {
 360                      auth_success = true;
 361                      goto success;
 362                   }
 363                }
 364             }
 365          }
 366       }
 367    }
 368
 369    /* Try verifying against the subject name */
 370    if (!auth_success) {
 371       if ((subject = X509_get_subject_name(cert)) != NULL) {
 372          if (X509_NAME_get_text_by_NID(subject, NID_commonName, data, sizeof(data)) > 0) {
 373             /* NULL terminate data */
 374             data[255] = 0;
 375             if (strcasecmp(data, host) == 0) {
 376                auth_success = true;
 377             }
 378          }
 379       }
 380    }
 381
 382 success:
 383    X509_free(cert);
 384
 385    return auth_success;
 386 }
 387
 388 /*
 389  * Create a new TLS_CONNECTION instance.
 390  *
 391  * Returns: Pointer to TLS_CONNECTION instance on success
 392  *          NULL on failure;
 393  */
 394 TLS_CONNECTION *new_tls_connection(TLS_CONTEXT *ctx, int fd)
 395 {
 396    BIO *bio;
 397
 398    /*
 399     * Create a new BIO and assign the fd.
 400     * The caller will remain responsible for closing the associated fd
 401     */
 402    bio = BIO_new(BIO_s_socket());
 403    if (!bio) {
 404       /* Not likely, but never say never */
 405       openssl_post_errors(M_ERROR, _("Error creating file descriptor-based BIO"));
 406       return NULL; /* Nothing allocated, nothing to clean up */
 407    }
 408    BIO_set_fd(bio, fd, BIO_NOCLOSE);
 409
 410    /* Allocate our new tls connection */
 411    TLS_CONNECTION *tls = (TLS_CONNECTION *)malloc(sizeof(TLS_CONNECTION));
 412
 413    /* Create the SSL object and attach the socket BIO */
 414    if ((tls->openssl = SSL_new(ctx->openssl)) == NULL) {
 415       /* Not likely, but never say never */
 416       openssl_post_errors(M_ERROR, _("Error creating new SSL object"));
 417       goto err;
 418    }
 419
 420    SSL_set_bio(tls->openssl, bio, bio);
 421
 422    /* Non-blocking partial writes */
 423    SSL_set_mode(tls->openssl, SSL_MODE_ENABLE_PARTIAL_WRITE|SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER);
 424
 425    return tls;
 426
 427 err:
 428    /* Clean up */
 429    BIO_free(bio);
 430    SSL_free(tls->openssl);
 431    free(tls);
 432
 433    return NULL;
 434 }
 435
 436 /*
 437  * Free TLS_CONNECTION instance
 438  */
 439 void free_tls_connection(TLS_CONNECTION *tls)
 440 {
 441    SSL_free(tls->openssl);
 442    free(tls);
 443 }
 444
 445 /* Does all the manual labor for tls_bsock_accept() and tls_bsock_connect() */
 446 static inline bool openssl_bsock_session_start(BSOCK *bsock, bool server)
 447 {
 448    TLS_CONNECTION *tls = bsock->tls;
 449    int err;
 450    int fdmax, flags;
 451    int stat = true;
 452    fd_set fdset;
 453    struct timeval tv;
 454
 455    /* Zero the fdset, we'll set our fd prior to each invocation of select() */
 456    FD_ZERO(&fdset);
 457    fdmax = bsock->m_fd + 1;
 458
 459    /* Ensure that socket is non-blocking */
 460    flags = bnet_set_nonblocking(bsock);
 461
 462    /* start timer */
 463    bsock->timer_start = watchdog_time;
 464    bsock->m_timed_out = 0;
 465
 466    for (;;) {
 467       if (server) {
 468          err = SSL_accept(tls->openssl);
 469       } else {
 470          err = SSL_connect(tls->openssl);
 471       }
 472
 473       /* Handle errors */
 474       switch (SSL_get_error(tls->openssl, err)) {
 475       case SSL_ERROR_NONE:
 476          stat = true;
 477          goto cleanup;
 478       case SSL_ERROR_ZERO_RETURN:
 479          /* TLS connection was cleanly shut down */
 480          openssl_post_errors(M_ERROR, _("Connect failure"));
 481          stat = false;
 482          goto cleanup;
 483       case SSL_ERROR_WANT_READ:
 484          /* If we timeout of a select, this will be unset */
 485          FD_SET((unsigned) bsock->m_fd, &fdset);
 486          /* Set our timeout */
 487          tv.tv_sec = 10;
 488          tv.tv_usec = 0;
 489          /* Block until we can read */
 490          select(fdmax, &fdset, NULL, &fdset, &tv);
 491          break;
 492       case SSL_ERROR_WANT_WRITE:
 493          /* If we timeout of a select, this will be unset */
 494          FD_SET((unsigned) bsock->m_fd, &fdset);
 495          /* Set our timeout */
 496          tv.tv_sec = 10;
 497          tv.tv_usec = 0;
 498          /* Block until we can write */
 499          select(fdmax, NULL, &fdset, &fdset, &tv);
 500          break;
 501       default:
 502          /* Socket Error Occured */
 503          openssl_post_errors(M_ERROR, _("Connect failure"));
 504          stat = false;
 505          goto cleanup;
 506       }
 507
 508       if (bsock->is_timed_out()) {
 509          goto cleanup;
 510       }
 511    }
 512
 513 cleanup:
 514    /* Restore saved flags */
 515    bnet_restore_blocking(bsock, flags);
 516    /* Clear timer */
 517    bsock->timer_start = 0;
 518
 519    return stat;
 520 }
 521
 522 /*
 523  * Initiates a TLS connection with the server.
 524  *  Returns: true on success
 525  *           false on failure
 526  */
 527 bool tls_bsock_connect(BSOCK *bsock)
 528 {
 529    /* SSL_connect(bsock->tls) */
 530    return (openssl_bsock_session_start(bsock, false));
 531 }
 532
 533 /*
 534  * Listens for a TLS connection from a client.
 535  *  Returns: true on success
 536  *           false on failure
 537  */
 538 bool tls_bsock_accept(BSOCK *bsock)
 539 {
 540    /* SSL_accept(bsock->tls) */
 541    return (openssl_bsock_session_start(bsock, true));
 542 }
 543
 544 /*
 545  * Shutdown TLS_CONNECTION instance
 546  */
 547 void tls_bsock_shutdown(BSOCK *bsock)
 548 {
 549    /*
 550     * SSL_shutdown must be called twice to fully complete the process -
 551     * The first time to initiate the shutdown handshake, and the second to
 552     * receive the peer's reply.
 553     *
 554     * However, it is valid to close the SSL connection after the initial
 555     * shutdown notification is sent to the peer, without waiting for the
 556     * peer's reply, as long as you do not plan to re-use that particular
 557     * SSL connection object.
 558     *
 559     * Because we do not re-use SSL connection objects, I do not bother
 560     * calling SSL_shutdown a second time.
 561     *
 562     * In addition, if the underlying socket is blocking, SSL_shutdown()
 563     * will not return until the current stage of the shutdown process has
 564     * completed or an error has occured. By setting the socket blocking
 565     * we can avoid the ugly for()/switch()/select() loop.
 566     */
 567    int err;
 568    int flags;
 569
 570    /* Set socket blocking for shutdown */
 571    flags = bsock->set_blocking();
 572
 573    err = SSL_shutdown(bsock->tls->openssl);
 574
 575    switch (SSL_get_error(bsock->tls->openssl, err)) {
 576       case SSL_ERROR_NONE:
 577          break;
 578       case SSL_ERROR_ZERO_RETURN:
 579          /* TLS connection was shut down on us via a TLS protocol-level closure */
 580          openssl_post_errors(M_ERROR, _("TLS shutdown failure."));
 581          break;
 582       default:
 583          /* Socket Error Occured */
 584          openssl_post_errors(M_ERROR, _("TLS shutdown failure."));
 585          break;
 586    }
 587
 588    /* Restore saved flags */
 589    bsock->restore_blocking(flags);
 590 }
 591
 592 /* Does all the manual labor for tls_bsock_readn() and tls_bsock_writen() */
 593 static inline int openssl_bsock_readwrite(BSOCK *bsock, char *ptr, int nbytes, bool write)
 594 {
 595    TLS_CONNECTION *tls = bsock->tls;
 596    int fdmax, flags;
 597    fd_set fdset;
 598    struct timeval tv;
 599    int nleft = 0;
 600    int nwritten = 0;
 601
 602    /* Zero the fdset, we'll set our fd prior to each invocation of select() */
 603    FD_ZERO(&fdset);
 604    fdmax = bsock->m_fd + 1;
 605
 606    /* Ensure that socket is non-blocking */
 607    flags = bsock->set_nonblocking();
 608
 609    /* start timer */
 610    bsock->timer_start = watchdog_time;
 611    bsock->m_timed_out = 0;
 612
 613    nleft = nbytes;
 614
 615    while (nleft > 0) {
 616
 617       if (write) {
 618          nwritten = SSL_write(tls->openssl, ptr, nleft);
 619       } else {
 620          nwritten = SSL_read(tls->openssl, ptr, nleft);
 621       }
 622
 623       /* Handle errors */
 624       switch (SSL_get_error(tls->openssl, nwritten)) {
 625       case SSL_ERROR_NONE:
 626          nleft -= nwritten;
 627          if (nleft) {
 628             ptr += nwritten;
 629          }
 630          break;
 631       case SSL_ERROR_ZERO_RETURN:
 632          /* TLS connection was cleanly shut down */
 633          openssl_post_errors(M_ERROR, _("TLS read/write failure."));
 634          goto cleanup;
 635       case SSL_ERROR_WANT_READ:
 636          /* If we timeout of a select, this will be unset */
 637          FD_SET((unsigned) bsock->m_fd, &fdset);
 638          tv.tv_sec = 10;
 639          tv.tv_usec = 0;
 640          /* Block until we can read */
 641          select(fdmax, &fdset, NULL, &fdset, &tv);
 642          break;
 643       case SSL_ERROR_WANT_WRITE:
 644          /* If we timeout of a select, this will be unset */
 645          FD_SET((unsigned) bsock->m_fd, &fdset);
 646          tv.tv_sec = 10;
 647          tv.tv_usec = 0;
 648          /* Block until we can write */
 649          select(fdmax, NULL, &fdset, &fdset, &tv);
 650          break;
 651       default:
 652          /* Socket Error Occured */
 653          openssl_post_errors(M_ERROR, _("TLS read/write failure."));
 654          goto cleanup;
 655       }
 656
 657       /* Everything done? */
 658       if (nleft == 0) {
 659          goto cleanup;
 660       }
 661
 662       /* Timeout/Termination, let's take what we can get */
 663       if (bsock->is_timed_out() || bsock->is_terminated()) {
 664          goto cleanup;
 665       }
 666    }
 667
 668 cleanup:
 669    /* Restore saved flags */
 670    bsock->restore_blocking(flags);
 671
 672    /* Clear timer */
 673    bsock->timer_start = 0;
 674
 675    return nbytes - nleft;
 676 }
 677
 678
 679 int tls_bsock_writen(BSOCK *bsock, char *ptr, int32_t nbytes) {
 680    /* SSL_write(bsock->tls->openssl, ptr, nbytes) */
 681    return (openssl_bsock_readwrite(bsock, ptr, nbytes, true));
 682 }
 683
 684 int tls_bsock_readn(BSOCK *bsock, char *ptr, int32_t nbytes) {
 685    /* SSL_read(bsock->tls->openssl, ptr, nbytes) */
 686    return (openssl_bsock_readwrite(bsock, ptr, nbytes, false));
 687 }
 688
 689 #else /* HAVE_OPENSSL */
 690 # error No TLS implementation available.
 691 #endif /* !HAVE_OPENSSL */
 692
 693 #else
 694
 695 /* Dummy routines */
 696 TLS_CONTEXT *new_tls_context(const char *ca_certfile, const char *ca_certdir,
 697                              const char *certfile, const char *keyfile,
 698                              CRYPTO_PEM_PASSWD_CB *pem_callback,
 699                              const void *pem_userdata, const char *dhfile,
 700                              bool verify_peer)
 701 {
 702    return NULL;
 703 }
 704 void free_tls_context(TLS_CONTEXT *ctx) { }
 705
 706 void tls_bsock_shutdown(BSOCK *bsock) { }
 707
 708 void free_tls_connection(TLS_CONNECTION *tls)
 709 {
 710    if (tls) {
 711       if (tls->openssl) {
 712          SSL_free(tls->openssl);
 713       }
 714       free(tls);
 715    }
 716 }
 717 bool get_tls_require(TLS_CONTEXT *ctx)
 718 {
 719    return false;
 720 }
 721
 722 bool get_tls_enable(TLS_CONTEXT *ctx)
 723 {
 724    return false;
 725 }
 726
 727 #endif /* HAVE_TLS */