librb/src/openssl.c

   1 /*
   2  *  librb: a library used by ircd-ratbox and other things
   3  *  openssl.c: OpenSSL backend
   4  *
   5  *  Copyright (C) 2007-2008 ircd-ratbox development team
   6  *  Copyright (C) 2007-2008 Aaron Sethman <androsyn@ratbox.org>
   7  *  Copyright (C) 2015-2016 Aaron Jones <aaronmdjones@gmail.com>
   8  *
   9  *  This program is free software; you can redistribute it and/or modify
  10  *  it under the terms of the GNU General Public License as published by
  11  *  the Free Software Foundation; either version 2 of the License, or
  12  *  (at your option) any later version.
  13  *
  14  *  This program is distributed in the hope that it will be useful,
  15  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  *  GNU General Public License for more details.
  18  *
  19  *  You should have received a copy of the GNU General Public License
  20  *  along with this program; if not, write to the Free Software
  21  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301
  22  *  USA
  23  *
  24  */
  25
  26 #include <librb_config.h>
  27 #include <rb_lib.h>
  28
  29 #ifdef HAVE_OPENSSL
  30
  31 #include <commio-int.h>
  32 #include <commio-ssl.h>
  33
  34 #include "openssl_ratbox.h"
  35
  36 typedef enum
  37 {
  38         RB_FD_TLS_DIRECTION_IN = 0,
  39         RB_FD_TLS_DIRECTION_OUT = 1
  40 } rb_fd_tls_direction;
  41
  42 #define SSL_P(x) ((SSL *)((x)->ssl))
  43
  44
  45
  46 static SSL_CTX *ssl_ctx = NULL;
  47
  48 struct ssl_connect
  49 {
  50         CNCB *callback;
  51         void *data;
  52         int timeout;
  53 };
  54
  55 static const char *rb_ssl_strerror(unsigned long);
  56 static void rb_ssl_connect_realcb(rb_fde_t *, int, struct ssl_connect *);
  57
  58
  59
  60 /*
  61  * Internal OpenSSL-specific code
  62  */
  63
  64 static unsigned long
  65 rb_ssl_last_err(void)
  66 {
  67         unsigned long err_saved, err = 0;
  68
  69         while((err_saved = ERR_get_error()) != 0)
  70                 err = err_saved;
  71
  72         return err;
  73 }
  74
  75 static void
  76 rb_ssl_init_fd(rb_fde_t *const F, const rb_fd_tls_direction dir)
  77 {
  78         (void) rb_ssl_last_err();
  79
  80         F->ssl = SSL_new(ssl_ctx);
  81
  82         if(F->ssl == NULL)
  83         {
  84                 rb_lib_log("%s: SSL_new: %s", __func__, rb_ssl_strerror(rb_ssl_last_err()));
  85                 rb_close(F);
  86                 return;
  87         }
  88
  89         switch(dir)
  90         {
  91         case RB_FD_TLS_DIRECTION_IN:
  92                 SSL_set_accept_state(SSL_P(F));
  93                 break;
  94         case RB_FD_TLS_DIRECTION_OUT:
  95                 SSL_set_connect_state(SSL_P(F));
  96                 break;
  97         }
  98
  99         SSL_set_fd(SSL_P(F), rb_get_fd(F));
 100 }
 101
 102 static void
 103 rb_ssl_accept_common(rb_fde_t *const F, void *const data __attribute__((unused)))
 104 {
 105         lrb_assert(F != NULL);
 106         lrb_assert(F->accept != NULL);
 107         lrb_assert(F->accept->callback != NULL);
 108         lrb_assert(F->ssl != NULL);
 109
 110         (void) rb_ssl_last_err();
 111
 112         int ret = SSL_do_handshake(SSL_P(F));
 113         int err = SSL_get_error(SSL_P(F), ret);
 114
 115         if(ret == 1)
 116         {
 117                 F->handshake_count++;
 118
 119                 rb_settimeout(F, 0, NULL, NULL);
 120                 rb_setselect(F, RB_SELECT_READ | RB_SELECT_WRITE, NULL, NULL);
 121
 122                 struct acceptdata *const ad = F->accept;
 123                 F->accept = NULL;
 124                 ad->callback(F, RB_OK, (struct sockaddr *)&ad->S, ad->addrlen, ad->data);
 125                 rb_free(ad);
 126
 127                 return;
 128         }
 129         if(ret == -1 && err == SSL_ERROR_WANT_READ)
 130         {
 131                 rb_setselect(F, RB_SELECT_READ, rb_ssl_accept_common, NULL);
 132                 return;
 133         }
 134         if(ret == -1 && err == SSL_ERROR_WANT_WRITE)
 135         {
 136                 rb_setselect(F, RB_SELECT_WRITE, rb_ssl_accept_common, NULL);
 137                 return;
 138         }
 139
 140         errno = EIO;
 141         F->ssl_errno = (unsigned long) err;
 142         F->accept->callback(F, RB_ERROR_SSL, NULL, 0, F->accept->data);
 143 }
 144
 145 static void
 146 rb_ssl_connect_common(rb_fde_t *const F, void *const data)
 147 {
 148         lrb_assert(F != NULL);
 149         lrb_assert(F->ssl != NULL);
 150
 151         (void) rb_ssl_last_err();
 152
 153         int ret = SSL_do_handshake(SSL_P(F));
 154         int err = SSL_get_error(SSL_P(F), ret);
 155
 156         if(ret == 1)
 157         {
 158                 F->handshake_count++;
 159
 160                 rb_settimeout(F, 0, NULL, NULL);
 161                 rb_setselect(F, RB_SELECT_READ | RB_SELECT_WRITE, NULL, NULL);
 162
 163                 rb_ssl_connect_realcb(F, RB_OK, data);
 164
 165                 return;
 166         }
 167         if(ret == -1 && err == SSL_ERROR_WANT_READ)
 168         {
 169                 rb_setselect(F, RB_SELECT_READ, rb_ssl_connect_common, data);
 170                 return;
 171         }
 172         if(ret == -1 && err == SSL_ERROR_WANT_WRITE)
 173         {
 174                 rb_setselect(F, RB_SELECT_WRITE, rb_ssl_connect_common, data);
 175                 return;
 176         }
 177
 178         errno = EIO;
 179         F->ssl_errno = (unsigned long) err;
 180         rb_ssl_connect_realcb(F, RB_ERROR_SSL, data);
 181 }
 182
 183 static const char *
 184 rb_ssl_strerror(const unsigned long err)
 185 {
 186         static char errbuf[512];
 187
 188         ERR_error_string_n(err, errbuf, sizeof errbuf);
 189
 190         return errbuf;
 191 }
 192
 193 static int
 194 verify_accept_all_cb(const int preverify_ok __attribute__((unused)), X509_STORE_CTX *const x509_ctx __attribute__((unused)))
 195 {
 196         return 1;
 197 }
 198
 199 static ssize_t
 200 rb_ssl_read_or_write(const int r_or_w, rb_fde_t *const F, void *const rbuf, const void *const wbuf, const size_t count)
 201 {
 202         ssize_t ret;
 203         unsigned long err;
 204
 205         (void) rb_ssl_last_err();
 206
 207         if(r_or_w == 0)
 208                 ret = (ssize_t) SSL_read(SSL_P(F), rbuf, (int)count);
 209         else
 210                 ret = (ssize_t) SSL_write(SSL_P(F), wbuf, (int)count);
 211
 212         if(ret < 0)
 213         {
 214                 switch(SSL_get_error(SSL_P(F), ret))
 215                 {
 216                 case SSL_ERROR_WANT_READ:
 217                         errno = EAGAIN;
 218                         return RB_RW_SSL_NEED_READ;
 219                 case SSL_ERROR_WANT_WRITE:
 220                         errno = EAGAIN;
 221                         return RB_RW_SSL_NEED_WRITE;
 222                 case SSL_ERROR_ZERO_RETURN:
 223                         return 0;
 224                 case SSL_ERROR_SYSCALL:
 225                         err = rb_ssl_last_err();
 226                         if(err == 0)
 227                         {
 228                                 F->ssl_errno = 0;
 229                                 return RB_RW_IO_ERROR;
 230                         }
 231                         break;
 232                 default:
 233                         err = rb_ssl_last_err();
 234                         break;
 235                 }
 236
 237                 F->ssl_errno = err;
 238                 if(err > 0)
 239                 {
 240                         errno = EIO;    /* not great but... */
 241                         return RB_RW_SSL_ERROR;
 242                 }
 243                 return RB_RW_IO_ERROR;
 244         }
 245         return ret;
 246 }
 247
 248 static int
 249 make_certfp(X509 *const cert, uint8_t certfp[const RB_SSL_CERTFP_LEN], const int method)
 250 {
 251         unsigned int hashlen = 0;
 252         const EVP_MD *md_type = NULL;
 253         const ASN1_ITEM *item = NULL;
 254         void *data = NULL;
 255
 256         switch(method)
 257         {
 258         case RB_SSL_CERTFP_METH_CERT_SHA1:
 259                 hashlen = RB_SSL_CERTFP_LEN_SHA1;
 260                 md_type = EVP_sha1();
 261                 item = ASN1_ITEM_rptr(X509);
 262                 data = cert;
 263                 break;
 264         case RB_SSL_CERTFP_METH_CERT_SHA256:
 265                 hashlen = RB_SSL_CERTFP_LEN_SHA256;
 266                 md_type = EVP_sha256();
 267                 item = ASN1_ITEM_rptr(X509);
 268                 data = cert;
 269                 break;
 270         case RB_SSL_CERTFP_METH_CERT_SHA512:
 271                 hashlen = RB_SSL_CERTFP_LEN_SHA512;
 272                 md_type = EVP_sha512();
 273                 item = ASN1_ITEM_rptr(X509);
 274                 data = cert;
 275                 break;
 276         case RB_SSL_CERTFP_METH_SPKI_SHA256:
 277                 hashlen = RB_SSL_CERTFP_LEN_SHA256;
 278                 md_type = EVP_sha256();
 279                 item = ASN1_ITEM_rptr(X509_PUBKEY);
 280                 data = X509_get_X509_PUBKEY(cert);
 281                 break;
 282         case RB_SSL_CERTFP_METH_SPKI_SHA512:
 283                 hashlen = RB_SSL_CERTFP_LEN_SHA512;
 284                 md_type = EVP_sha512();
 285                 item = ASN1_ITEM_rptr(X509_PUBKEY);
 286                 data = X509_get_X509_PUBKEY(cert);
 287                 break;
 288         default:
 289                 return 0;
 290         }
 291
 292         if(ASN1_item_digest(item, md_type, data, certfp, &hashlen) != 1)
 293         {
 294                 rb_lib_log("%s: ASN1_item_digest: %s", __func__, rb_ssl_strerror(rb_ssl_last_err()));
 295                 return 0;
 296         }
 297
 298         return (int) hashlen;
 299 }
 300
 301
 302
 303 /*
 304  * External OpenSSL-specific code
 305  */
 306
 307 void
 308 rb_ssl_shutdown(rb_fde_t *const F)
 309 {
 310         if(F == NULL || F->ssl == NULL)
 311                 return;
 312
 313         (void) rb_ssl_last_err();
 314
 315         for(int i = 0; i < 4; i++)
 316         {
 317                 int ret = SSL_shutdown(SSL_P(F));
 318                 int err = SSL_get_error(SSL_P(F), ret);
 319
 320                 if(ret >= 0 || (err != SSL_ERROR_WANT_READ && err != SSL_ERROR_WANT_WRITE))
 321                         break;
 322         }
 323
 324         SSL_free(SSL_P(F));
 325         F->ssl = NULL;
 326 }
 327
 328 int
 329 rb_init_ssl(void)
 330 {
 331 #ifndef LRB_SSL_NO_EXPLICIT_INIT
 332         (void) SSL_library_init();
 333         SSL_load_error_strings();
 334 #endif
 335
 336         rb_lib_log("%s: OpenSSL backend initialised", __func__);
 337         return 1;
 338 }
 339
 340 int
 341 rb_setup_ssl_server(const char *const certfile, const char *keyfile,
 342                     const char *const dhfile, const char *cipherlist)
 343 {
 344         if(certfile == NULL)
 345         {
 346                 rb_lib_log("%s: no certificate file specified", __func__);
 347                 return 0;
 348         }
 349
 350         if(keyfile == NULL)
 351                 keyfile = certfile;
 352
 353         if(cipherlist == NULL)
 354                 cipherlist = rb_default_ciphers;
 355
 356
 357         (void) rb_ssl_last_err();
 358
 359         #ifdef LRB_HAVE_TLS_METHOD_API
 360         SSL_CTX *const ssl_ctx_new = SSL_CTX_new(TLS_method());
 361         #else
 362         SSL_CTX *const ssl_ctx_new = SSL_CTX_new(SSLv23_method());
 363         #endif
 364
 365         if(ssl_ctx_new == NULL)
 366         {
 367                 rb_lib_log("%s: SSL_CTX_new: %s", __func__, rb_ssl_strerror(rb_ssl_last_err()));
 368                 return 0;
 369         }
 370
 371         if(SSL_CTX_use_certificate_chain_file(ssl_ctx_new, certfile) != 1)
 372         {
 373                 rb_lib_log("%s: SSL_CTX_use_certificate_chain_file ('%s'): %s", __func__, certfile,
 374                            rb_ssl_strerror(rb_ssl_last_err()));
 375
 376                 SSL_CTX_free(ssl_ctx_new);
 377                 return 0;
 378         }
 379
 380         if(SSL_CTX_use_PrivateKey_file(ssl_ctx_new, keyfile, SSL_FILETYPE_PEM) != 1)
 381         {
 382                 rb_lib_log("%s: SSL_CTX_use_PrivateKey_file ('%s'): %s", __func__, keyfile,
 383                            rb_ssl_strerror(rb_ssl_last_err()));
 384
 385                 SSL_CTX_free(ssl_ctx_new);
 386                 return 0;
 387         }
 388
 389         if(dhfile == NULL)
 390         {
 391                 rb_lib_log("%s: no DH parameters file specified", __func__);
 392         }
 393         else
 394         {
 395                 BIO *const dhf = BIO_new_file(dhfile, "r");
 396 #if (OPENSSL_VERSION_NUMBER >= 0x30000000L)
 397                 EVP_PKEY *dhp = NULL;
 398 #else
 399                 DH *dhp = NULL;
 400 #endif
 401
 402                 if(dhf == NULL)
 403                 {
 404                         rb_lib_log("%s: BIO_new_file ('%s'): %s", __func__, dhfile,
 405                                    rb_ssl_strerror(rb_ssl_last_err()));
 406                 }
 407 #if (OPENSSL_VERSION_NUMBER >= 0x30000000L)
 408                 else if(PEM_read_bio_Parameters(dhf, &dhp) == NULL)
 409                 {
 410                         rb_lib_log("%s: PEM_read_bio_Parameters ('%s'): %s", __func__, dhfile,
 411                                    rb_ssl_strerror(rb_ssl_last_err()));
 412                 }
 413 #else
 414                 else if(PEM_read_bio_DHparams(dhf, &dhp, NULL, NULL) == NULL)
 415                 {
 416                         rb_lib_log("%s: PEM_read_bio_DHparams ('%s'): %s", __func__, dhfile,
 417                                    rb_ssl_strerror(rb_ssl_last_err()));
 418                 }
 419 #endif
 420                 else
 421                 {
 422 #if (OPENSSL_VERSION_NUMBER >= 0x30000000L)
 423                         if(SSL_CTX_set0_tmp_dh_pkey(ssl_ctx_new, dhp) != 1)
 424                         {
 425                                 rb_lib_log("%s: SSL_CTX_set0_tmp_dh_pkey ('%s'): %s", __func__, dhfile,
 426                                            rb_ssl_strerror(rb_ssl_last_err()));
 427                                 EVP_PKEY_free(dhp);
 428                         }
 429 #else
 430                         SSL_CTX_set_tmp_dh(ssl_ctx_new, dhp);
 431                         DH_free(dhp);
 432 #endif
 433                 }
 434
 435                 BIO_free(dhf);
 436         }
 437
 438         int ret_old = SSL_CTX_set_cipher_list(ssl_ctx_new, cipherlist);
 439
 440         if (ret_old != 1)
 441         {
 442                 (void) rb_lib_log("%s: no valid old-style ciphersuites found "
 443                                   "in ssl_cipher_list; will use defaults",
 444                                   __func__);
 445
 446                 ret_old = SSL_CTX_set_cipher_list(ssl_ctx_new, rb_default_ciphers);
 447         }
 448
 449         #ifndef LRB_HAVE_TLS13
 450         int ret_new = 0;
 451         #else
 452         int ret_new = SSL_CTX_set_ciphersuites(ssl_ctx_new, cipherlist);
 453
 454         if (ret_new != 1)
 455         {
 456                 (void) rb_lib_log("%s: no valid new-style ciphersuites found "
 457                                   "in ssl_cipher_list; will use defaults",
 458                                   __func__);
 459
 460                 ret_new = SSL_CTX_set_ciphersuites(ssl_ctx_new, rb_default_ciphers);
 461         }
 462         #endif
 463
 464         if (ret_old != 1 && ret_new != 1)
 465         {
 466                 rb_lib_log("%s: could not configure any ciphers", __func__);
 467                 SSL_CTX_free(ssl_ctx_new);
 468                 return 0;
 469         }
 470
 471
 472         SSL_CTX_set_session_cache_mode(ssl_ctx_new, SSL_SESS_CACHE_OFF);
 473         SSL_CTX_set_verify(ssl_ctx_new, SSL_VERIFY_PEER | SSL_VERIFY_CLIENT_ONCE, verify_accept_all_cb);
 474
 475         #ifdef SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS
 476         (void) SSL_CTX_clear_options(ssl_ctx_new, SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS);
 477         #endif
 478
 479         #ifndef LRB_HAVE_TLS_METHOD_API
 480         (void) SSL_CTX_set_options(ssl_ctx_new, SSL_OP_NO_SSLv2 | SSL_OP_NO_SSLv3);
 481         #endif
 482
 483         #ifdef SSL_OP_NO_TICKET
 484         (void) SSL_CTX_set_options(ssl_ctx_new, SSL_OP_NO_TICKET);
 485         #endif
 486
 487         #ifdef SSL_OP_CIPHER_SERVER_PREFERENCE
 488         (void) SSL_CTX_set_options(ssl_ctx_new, SSL_OP_CIPHER_SERVER_PREFERENCE);
 489         #endif
 490
 491         #ifdef SSL_OP_SINGLE_DH_USE
 492         (void) SSL_CTX_set_options(ssl_ctx_new, SSL_OP_SINGLE_DH_USE);
 493         #endif
 494
 495         #ifdef SSL_OP_SINGLE_ECDH_USE
 496         (void) SSL_CTX_set_options(ssl_ctx_new, SSL_OP_SINGLE_ECDH_USE);
 497         #endif
 498
 499         #ifdef LRB_HAVE_TLS_ECDH_AUTO
 500         (void) SSL_CTX_set_ecdh_auto(ssl_ctx_new, 1);
 501         #endif
 502
 503         #ifdef LRB_HAVE_TLS_SET_CURVES
 504         (void) SSL_CTX_set1_curves_list(ssl_ctx_new, rb_default_curves);
 505         #else
 506         #  if (OPENSSL_VERSION_NUMBER >= 0x10000000L) && !defined(OPENSSL_NO_ECDH) && defined(NID_secp384r1)
 507         EC_KEY *const ec_key = EC_KEY_new_by_curve_name(NID_secp384r1);
 508         if(ec_key != NULL)
 509         {
 510                 SSL_CTX_set_tmp_ecdh(ssl_ctx_new, ec_key);
 511                 EC_KEY_free(ec_key);
 512         }
 513         else
 514                 rb_lib_log("%s: EC_KEY_new_by_curve_name failed; will not enable ECDHE- ciphers", __func__);
 515         #  else
 516              rb_lib_log("%s: OpenSSL built without ECDH support; will not enable ECDHE- ciphers", __func__);
 517         #  endif
 518         #endif
 519
 520
 521         if(ssl_ctx)
 522                 SSL_CTX_free(ssl_ctx);
 523
 524         ssl_ctx = ssl_ctx_new;
 525
 526
 527         rb_lib_log("%s: TLS configuration successful", __func__);
 528         return 1;
 529 }
 530
 531 int
 532 rb_init_prng(const char *const path, prng_seed_t seed_type)
 533 {
 534         (void) rb_ssl_last_err();
 535
 536         if(seed_type == RB_PRNG_FILE && RAND_load_file(path, -1) < 0)
 537                 rb_lib_log("%s: RAND_load_file: %s", __func__, rb_ssl_strerror(rb_ssl_last_err()));
 538
 539         if(RAND_status() != 1)
 540         {
 541                 rb_lib_log("%s: RAND_status: %s", __func__, rb_ssl_strerror(rb_ssl_last_err()));
 542                 return 0;
 543         }
 544
 545         rb_lib_log("%s: PRNG initialised", __func__);
 546         return 1;
 547 }
 548
 549 int
 550 rb_get_random(void *const buf, const size_t length)
 551 {
 552         (void) rb_ssl_last_err();
 553
 554         if(RAND_bytes(buf, (int) length) != 1)
 555         {
 556                 rb_lib_log("%s: RAND_bytes: %s", __func__, rb_ssl_strerror(rb_ssl_last_err()));
 557                 return 0;
 558         }
 559
 560         return 1;
 561 }
 562
 563 const char *
 564 rb_get_ssl_strerror(rb_fde_t *const F)
 565 {
 566         return rb_ssl_strerror(F->ssl_errno);
 567 }
 568
 569 int
 570 rb_get_ssl_certfp(rb_fde_t *const F, uint8_t certfp[const RB_SSL_CERTFP_LEN], const int method)
 571 {
 572         if(F == NULL || F->ssl == NULL)
 573                 return 0;
 574
 575         X509 *const peer_cert = SSL_get_peer_certificate(SSL_P(F));
 576         if(peer_cert == NULL)
 577                 return 0;
 578
 579         int len = 0;
 580
 581         switch(SSL_get_verify_result(SSL_P(F)))
 582         {
 583         case X509_V_OK:
 584         case X509_V_ERR_CERT_HAS_EXPIRED:
 585         case X509_V_ERR_SELF_SIGNED_CERT_IN_CHAIN:
 586         case X509_V_ERR_UNABLE_TO_VERIFY_LEAF_SIGNATURE:
 587         case X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT:
 588         case X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY:
 589         case X509_V_ERR_CERT_UNTRUSTED:
 590                 len = make_certfp(peer_cert, certfp, method);
 591                 // fallthrough
 592         default:
 593                 X509_free(peer_cert);
 594                 return len;
 595         }
 596 }
 597
 598 int
 599 rb_get_ssl_certfp_file(const char *const filename, uint8_t certfp[const RB_SSL_CERTFP_LEN], const int method)
 600 {
 601         FILE *const fp = fopen(filename, "r");
 602         if (fp == NULL)
 603                 return -1;
 604
 605         X509 *const cert = PEM_read_X509(fp, NULL, NULL, NULL);
 606         if (cert == NULL)
 607         {
 608                 fclose(fp);
 609                 return 0;
 610         }
 611
 612         int len = make_certfp(cert, certfp, method);
 613
 614         X509_free(cert);
 615         fclose(fp);
 616
 617         return len;
 618 }
 619
 620 void
 621 rb_get_ssl_info(char *const buf, const size_t len)
 622 {
 623 #ifdef LRB_SSL_FULL_VERSION_INFO
 624         if(LRB_SSL_VNUM_RUNTIME == LRB_SSL_VNUM_COMPILETIME)
 625                 (void) snprintf(buf, len, "OpenSSL: compiled 0x%lx, library %s",
 626                                 LRB_SSL_VNUM_COMPILETIME, LRB_SSL_VTEXT_COMPILETIME);
 627         else
 628                 (void) snprintf(buf, len, "OpenSSL: compiled (0x%lx, %s), library (0x%lx, %s)",
 629                                 LRB_SSL_VNUM_COMPILETIME, LRB_SSL_VTEXT_COMPILETIME,
 630                                 LRB_SSL_VNUM_RUNTIME, LRB_SSL_VTEXT_RUNTIME);
 631 #else
 632         (void) snprintf(buf, len, "OpenSSL: compiled 0x%lx, library %s",
 633                         LRB_SSL_VNUM_COMPILETIME, LRB_SSL_VTEXT_RUNTIME);
 634 #endif
 635 }
 636
 637 const char *
 638 rb_ssl_get_cipher(rb_fde_t *const F)
 639 {
 640         if(F == NULL || F->ssl == NULL)
 641                 return NULL;
 642
 643         static char buf[512];
 644
 645         const char *const version = SSL_get_version(SSL_P(F));
 646         const char *const cipher = SSL_get_cipher_name(SSL_P(F));
 647
 648         (void) snprintf(buf, sizeof buf, "%s, %s", version, cipher);
 649
 650         return buf;
 651 }
 652
 653 ssize_t
 654 rb_ssl_read(rb_fde_t *const F, void *const buf, const size_t count)
 655 {
 656         return rb_ssl_read_or_write(0, F, buf, NULL, count);
 657 }
 658
 659 ssize_t
 660 rb_ssl_write(rb_fde_t *const F, const void *const buf, const size_t count)
 661 {
 662         return rb_ssl_read_or_write(1, F, NULL, buf, count);
 663 }
 664
 665
 666
 667 /*
 668  * Internal library-agnostic code
 669  */
 670
 671 static void
 672 rb_ssl_connect_realcb(rb_fde_t *const F, const int status, struct ssl_connect *const sconn)
 673 {
 674         lrb_assert(F->connect != NULL);
 675
 676         F->connect->callback = sconn->callback;
 677         F->connect->data = sconn->data;
 678
 679         rb_connect_callback(F, status);
 680         rb_free(sconn);
 681 }
 682
 683 static void
 684 rb_ssl_timeout_cb(rb_fde_t *const F, void *const data __attribute__((unused)))
 685 {
 686         lrb_assert(F->accept != NULL);
 687         lrb_assert(F->accept->callback != NULL);
 688
 689         F->accept->callback(F, RB_ERR_TIMEOUT, NULL, 0, F->accept->data);
 690 }
 691
 692 static void
 693 rb_ssl_tryconn_timeout_cb(rb_fde_t *const F, void *const data)
 694 {
 695         rb_ssl_connect_realcb(F, RB_ERR_TIMEOUT, data);
 696 }
 697
 698 static void
 699 rb_ssl_tryconn(rb_fde_t *const F, const int status, void *const data)
 700 {
 701         lrb_assert(F != NULL);
 702
 703         struct ssl_connect *const sconn = data;
 704
 705         if(status != RB_OK)
 706         {
 707                 rb_ssl_connect_realcb(F, status, sconn);
 708                 return;
 709         }
 710
 711         F->type |= RB_FD_SSL;
 712
 713         rb_settimeout(F, sconn->timeout, rb_ssl_tryconn_timeout_cb, sconn);
 714         rb_ssl_init_fd(F, RB_FD_TLS_DIRECTION_OUT);
 715         rb_ssl_connect_common(F, sconn);
 716 }
 717
 718
 719
 720 /*
 721  * External library-agnostic code
 722  */
 723
 724 int
 725 rb_supports_ssl(void)
 726 {
 727         return 1;
 728 }
 729
 730 unsigned int
 731 rb_ssl_handshake_count(rb_fde_t *const F)
 732 {
 733         return F->handshake_count;
 734 }
 735
 736 void
 737 rb_ssl_clear_handshake_count(rb_fde_t *const F)
 738 {
 739         F->handshake_count = 0;
 740 }
 741
 742 void
 743 rb_ssl_start_accepted(rb_fde_t *const F, ACCB *const cb, void *const data, const int timeout)
 744 {
 745         F->type |= RB_FD_SSL;
 746
 747         F->accept = rb_malloc(sizeof(struct acceptdata));
 748         F->accept->callback = cb;
 749         F->accept->data = data;
 750         F->accept->addrlen = 0;
 751         (void) memset(&F->accept->S, 0x00, sizeof F->accept->S);
 752
 753         rb_settimeout(F, timeout, rb_ssl_timeout_cb, NULL);
 754         rb_ssl_init_fd(F, RB_FD_TLS_DIRECTION_IN);
 755         rb_ssl_accept_common(F, NULL);
 756 }
 757
 758 void
 759 rb_ssl_accept_setup(rb_fde_t *const srv_F, rb_fde_t *const cli_F, struct sockaddr *const st, const int addrlen)
 760 {
 761         cli_F->type |= RB_FD_SSL;
 762
 763         cli_F->accept = rb_malloc(sizeof(struct acceptdata));
 764         cli_F->accept->callback = srv_F->accept->callback;
 765         cli_F->accept->data = srv_F->accept->data;
 766         cli_F->accept->addrlen = (rb_socklen_t) addrlen;
 767         (void) memset(&cli_F->accept->S, 0x00, sizeof cli_F->accept->S);
 768         (void) memcpy(&cli_F->accept->S, st, (size_t) addrlen);
 769
 770         rb_settimeout(cli_F, 10, rb_ssl_timeout_cb, NULL);
 771         rb_ssl_init_fd(cli_F, RB_FD_TLS_DIRECTION_IN);
 772         rb_ssl_accept_common(cli_F, NULL);
 773 }
 774
 775 int
 776 rb_ssl_listen(rb_fde_t *const F, const int backlog, const int defer_accept)
 777 {
 778         int result = rb_listen(F, backlog, defer_accept);
 779
 780         F->type = RB_FD_SOCKET | RB_FD_LISTEN | RB_FD_SSL;
 781
 782         return result;
 783 }
 784
 785 void
 786 rb_connect_tcp_ssl(rb_fde_t *const F, struct sockaddr *const dest, struct sockaddr *const clocal,
 787                    CNCB *const callback, void *const data, const int timeout)
 788 {
 789         if(F == NULL)
 790                 return;
 791
 792         struct ssl_connect *const sconn = rb_malloc(sizeof *sconn);
 793         sconn->data = data;
 794         sconn->callback = callback;
 795         sconn->timeout = timeout;
 796
 797         rb_connect_tcp(F, dest, clocal, rb_ssl_tryconn, sconn, timeout);
 798 }
 799
 800 void
 801 rb_ssl_start_connected(rb_fde_t *const F, CNCB *const callback, void *const data, const int timeout)
 802 {
 803         if(F == NULL)
 804                 return;
 805
 806         struct ssl_connect *const sconn = rb_malloc(sizeof *sconn);
 807         sconn->data = data;
 808         sconn->callback = callback;
 809         sconn->timeout = timeout;
 810
 811         F->connect = rb_malloc(sizeof(struct conndata));
 812         F->connect->callback = callback;
 813         F->connect->data = data;
 814         F->type |= RB_FD_SSL;
 815
 816         rb_settimeout(F, sconn->timeout, rb_ssl_tryconn_timeout_cb, sconn);
 817         rb_ssl_init_fd(F, RB_FD_TLS_DIRECTION_OUT);
 818         rb_ssl_connect_common(F, sconn);
 819 }
 820
 821 #endif /* HAVE_OPENSSL */