src/ngircd/conn-ssl.c

   1 /*
   2  * ngIRCd -- The Next Generation IRC Daemon
   3  * Copyright (c)2005-2008 Florian Westphal (fw@strlen.de).
   4  * Copyright (c)2008-2014 Alexander Barton (alex@barton.de) and Contributors.
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  * Please read the file COPYING, README and AUTHORS for more information.
  11  */
  12
  13 #include "portab.h"
  14
  15 /**
  16  * @file
  17  * SSL wrapper functions
  18  */
  19
  20 #include "conf-ssl.h"
  21
  22 #ifdef SSL_SUPPORT
  23
  24 #include "io.h"
  25 #include <assert.h>
  26 #include <stdio.h>
  27 #include <string.h>
  28 #include <stdlib.h>
  29 #include <errno.h>
  30
  31 #define CONN_MODULE
  32 #include "conn.h"
  33 #include "conf.h"
  34 #include "conn-func.h"
  35 #include "conn-ssl.h"
  36 #include "log.h"
  37
  38 #include "defines.h"
  39
  40 extern struct SSLOptions Conf_SSLOptions;
  41
  42 #ifdef HAVE_LIBSSL
  43 #include <openssl/err.h>
  44 #include <openssl/rand.h>
  45 #include <openssl/dh.h>
  46 #include <openssl/x509v3.h>
  47
  48 #define MAX_CERT_CHAIN_LENGTH   10      /* XXX: do not hardcode */
  49
  50 static SSL_CTX * ssl_ctx;
  51 static DH *dh_params;
  52
  53 static bool ConnSSL_LoadServerKey_openssl PARAMS(( SSL_CTX *c ));
  54 static bool ConnSSL_SetVerifyProperties_openssl PARAMS((SSL_CTX * c));
  55 #endif
  56
  57 #ifdef HAVE_LIBGNUTLS
  58 #include <sys/types.h>
  59 #include <sys/stat.h>
  60 #include <fcntl.h>
  61 #include <unistd.h>
  62 #include <gnutls/x509.h>
  63
  64 #define DH_BITS 2048
  65 #define DH_BITS_MIN 1024
  66
  67 #define MAX_HASH_SIZE   64      /* from gnutls-int.h */
  68
  69 typedef struct {
  70         int refcnt;
  71         gnutls_certificate_credentials_t x509_cred;
  72         gnutls_dh_params_t dh_params;
  73 } x509_cred_slot;
  74
  75 static array x509_creds = INIT_ARRAY;
  76 static size_t x509_cred_idx;
  77
  78 static gnutls_dh_params_t dh_params;
  79 static gnutls_priority_t priorities_cache = NULL;
  80 static bool ConnSSL_LoadServerKey_gnutls PARAMS(( void ));
  81 static bool ConnSSL_SetVerifyProperties_gnutls PARAMS((void));
  82 #endif
  83
  84 #define SHA256_STRING_LEN       (32 * 2 + 1)
  85
  86 static bool ConnSSL_Init_SSL PARAMS(( CONNECTION *c ));
  87 static int ConnectAccept PARAMS(( CONNECTION *c, bool connect ));
  88 static int ConnSSL_HandleError PARAMS(( CONNECTION *c, const int code, const char *fname ));
  89
  90 #ifdef HAVE_LIBGNUTLS
  91 static char * openreadclose(const char *name, size_t *len)
  92 {
  93         char *buf = NULL;
  94         struct stat s;
  95         ssize_t br;
  96         int fd = open(name, O_RDONLY);
  97         if (fd < 0) {
  98                 Log(LOG_ERR, "Could not open %s: %s", name, strerror(errno));
  99                 return NULL;
 100         }
 101         if (fstat(fd, &s)) {
 102                 Log(LOG_ERR, "Could not fstat %s: %s", name, strerror(errno));
 103                 goto out;
 104         }
 105         if (!S_ISREG(s.st_mode)) {
 106                 Log(LOG_ERR, "%s: Not a regular file", name);
 107                 goto out;
 108         }
 109         if (s.st_size <= 0) {
 110                 Log(LOG_ERR, "%s: invalid file length (size %ld <= 0)", name, (long) s.st_size);
 111                 goto out;
 112         }
 113         buf = malloc(s.st_size);
 114         if (!buf) {
 115                 Log(LOG_ERR, "Could not malloc %lu bytes for file %s: %s", s.st_size, name, strerror(errno));
 116                 goto out;
 117         }
 118         br = read(fd, buf, s.st_size);
 119         if (br != (ssize_t)s.st_size) {
 120                 Log(LOG_ERR, "Could not read file %s: read returned %ld, expected %ld: %s",
 121                         name, (long) br, (long) s.st_size, br == -1 ? strerror(errno):"short read?!");
 122                 memset(buf, 0, s.st_size);
 123                 free(buf);
 124                 buf = NULL;
 125         } else {
 126                 *len = br;
 127         }
 128 out:
 129         close(fd);
 130         return buf;
 131 }
 132 #endif
 133
 134
 135 #ifdef HAVE_LIBSSL
 136 /**
 137  * Log OpenSSL error message.
 138  *
 139  * @param level The log level
 140  * @param msg The error message.
 141  * @param info Additional information text or NULL.
 142  */
 143 static void
 144 LogOpenSSL_CertInfo(int level, X509 * cert, const char *msg)
 145 {
 146         BIO *mem;
 147         char *memptr;
 148         long len;
 149
 150         assert(cert);
 151         assert(msg);
 152
 153         if (!cert)
 154                 return;
 155         mem = BIO_new(BIO_s_mem());
 156         if (!mem)
 157                 return;
 158         X509_NAME_print_ex(mem, X509_get_subject_name(cert), 0,
 159                            XN_FLAG_ONELINE);
 160         X509_NAME_print_ex(mem, X509_get_issuer_name(cert), 2, XN_FLAG_ONELINE);
 161         if (BIO_write(mem, "", 1) == 1) {
 162                 len = BIO_get_mem_data(mem, &memptr);
 163                 if (memptr && len > 0)
 164                         Log(level, "%s: \"%s\".", msg, memptr);
 165         }
 166         (void)BIO_set_close(mem, BIO_CLOSE);
 167         BIO_free(mem);
 168 }
 169
 170 static void
 171 LogOpenSSLError(const char *error, const char *info)
 172 {
 173         unsigned long err = ERR_get_error();
 174         char * errmsg = err
 175                 ? ERR_error_string(err, NULL)
 176                 : "Unable to determine error";
 177
 178         assert(error != NULL);
 179
 180         if (info)
 181                 Log(LOG_ERR, "%s: %s (%s)", error, info, errmsg);
 182         else
 183                 Log(LOG_ERR, "%s: %s", error, errmsg);
 184 }
 185
 186
 187 static int
 188 pem_passwd_cb(char *buf, int size, int rwflag, void *password)
 189 {
 190         array *pass = password;
 191         int passlen;
 192
 193         (void)rwflag;           /* rwflag is unused if DEBUG is not set. */
 194         assert(rwflag == 0);    /* 0 -> callback used for decryption.
 195                                  * See SSL_CTX_set_default_passwd_cb(3) */
 196
 197         passlen = (int) array_bytes(pass);
 198
 199         LogDebug("pem_passwd_cb buf size %d, array size %d", size, passlen);
 200         assert(passlen >= 0);
 201         if (passlen <= 0) {
 202                 Log(LOG_ERR, "PEM password required but not set [in pem_passwd_cb()]!");
 203                 return 0;
 204         }
 205         size = passlen > size ? size : passlen;
 206         memcpy(buf, (char *)(array_start(pass)), size);
 207         return size;
 208 }
 209
 210
 211 static int
 212 Verify_openssl(int preverify_ok, X509_STORE_CTX * ctx)
 213 {
 214 #ifdef DEBUG
 215         if (!preverify_ok) {
 216                 int err = X509_STORE_CTX_get_error(ctx);
 217                 LogDebug("Certificate validation failed: %s",
 218                          X509_verify_cert_error_string(err));
 219         }
 220 #else
 221         (void)preverify_ok;
 222         (void)ctx;
 223 #endif
 224
 225         /* Always(!) return success as we have to deal with invalid
 226          * (self-signed, expired, ...) client certificates and with invalid
 227          * server certificates when "SSLVerify" is disabled, which we don't
 228          * know at this stage. Therefore we postpone this check, it will be
 229          * (and has to be!) handled in cb_connserver_login_ssl(). */
 230         return 1;
 231 }
 232 #endif
 233
 234
 235 static bool
 236 Load_DH_params(void)
 237 {
 238 #ifdef HAVE_LIBSSL
 239         FILE *fp;
 240         bool ret = true;
 241
 242         if (!Conf_SSLOptions.DHFile) {
 243                 Log(LOG_NOTICE, "Configuration option \"DHFile\" not set!");
 244                 return false;
 245         }
 246         fp = fopen(Conf_SSLOptions.DHFile, "r");
 247         if (!fp) {
 248                 Log(LOG_ERR, "%s: %s", Conf_SSLOptions.DHFile, strerror(errno));
 249                 return false;
 250         }
 251         dh_params = PEM_read_DHparams(fp, NULL, NULL, NULL);
 252         if (!dh_params) {
 253                 Log(LOG_ERR, "%s: Failed to read SSL DH parameters!",
 254                     Conf_SSLOptions.DHFile);
 255                 ret = false;
 256         }
 257         fclose(fp);
 258         return ret;
 259 #endif
 260 #ifdef HAVE_LIBGNUTLS
 261         bool need_dhgenerate = true;
 262         int err;
 263         gnutls_dh_params_t tmp_dh_params;
 264
 265         err = gnutls_dh_params_init(&tmp_dh_params);
 266         if (err < 0) {
 267                 Log(LOG_ERR, "Failed to initialize SSL DH parameters: %s",
 268                     gnutls_strerror(err));
 269                 return false;
 270         }
 271         if (Conf_SSLOptions.DHFile) {
 272                 gnutls_datum_t dhparms;
 273                 size_t size;
 274                 dhparms.data = (unsigned char *) openreadclose(Conf_SSLOptions.DHFile, &size);
 275                 if (dhparms.data) {
 276                         dhparms.size = size;
 277                         err = gnutls_dh_params_import_pkcs3(tmp_dh_params, &dhparms, GNUTLS_X509_FMT_PEM);
 278                         if (err == 0)
 279                                 need_dhgenerate = false;
 280                         else
 281                                 Log(LOG_ERR,
 282                                     "Failed to initialize SSL DH parameters: %s",
 283                                     gnutls_strerror(err));
 284
 285                         memset(dhparms.data, 0, size);
 286                         free(dhparms.data);
 287                 }
 288         }
 289         if (need_dhgenerate) {
 290                 Log(LOG_WARNING,
 291                     "DHFile not set, generating %u bit DH parameters. This may take a while ...",
 292                     DH_BITS);
 293                 err = gnutls_dh_params_generate2(tmp_dh_params, DH_BITS);
 294                 if (err < 0) {
 295                         Log(LOG_ERR, "Failed to generate SSL DH parameters: %s",
 296                             gnutls_strerror(err));
 297                         return false;
 298                 }
 299         }
 300         dh_params = tmp_dh_params;
 301         return true;
 302 #endif
 303 }
 304
 305
 306 void ConnSSL_Free(CONNECTION *c)
 307 {
 308 #ifdef HAVE_LIBSSL
 309         SSL *ssl = c->ssl_state.ssl;
 310         if (ssl) {
 311                 SSL_shutdown(ssl);
 312                 SSL_free(ssl);
 313                 c->ssl_state.ssl = NULL;
 314                 if (c->ssl_state.fingerprint) {
 315                         free(c->ssl_state.fingerprint);
 316                         c->ssl_state.fingerprint = NULL;
 317                 }
 318         }
 319 #endif
 320 #ifdef HAVE_LIBGNUTLS
 321         gnutls_session_t sess = c->ssl_state.gnutls_session;
 322         if (Conn_OPTION_ISSET(c, CONN_SSL)) {
 323                 gnutls_bye(sess, GNUTLS_SHUT_RDWR);
 324                 gnutls_deinit(sess);
 325         }
 326         x509_cred_slot *slot = array_get(&x509_creds, sizeof(x509_cred_slot), c->ssl_state.x509_cred_idx);
 327         assert(slot != NULL);
 328         assert(slot->refcnt > 0);
 329         assert(slot->x509_cred != NULL);
 330         slot->refcnt--;
 331         if ((c->ssl_state.x509_cred_idx != x509_cred_idx) && (slot->refcnt <= 0)) {
 332                 LogDebug("Discarding X509 certificate credentials from slot %zd.",
 333                          c->ssl_state.x509_cred_idx);
 334                 gnutls_certificate_free_keys(slot->x509_cred);
 335                 gnutls_certificate_free_credentials(slot->x509_cred);
 336                 slot->x509_cred = NULL;
 337                 gnutls_dh_params_deinit(slot->dh_params);
 338                 slot->dh_params = NULL;
 339                 slot->refcnt = 0;
 340         }
 341 #endif
 342         assert(Conn_OPTION_ISSET(c, CONN_SSL));
 343         /* can't just set bitmask to 0 -- there are other, non-ssl related flags, e.g. CONN_ZIP. */
 344         Conn_OPTION_DEL(c, CONN_SSL_FLAGS_ALL);
 345 }
 346
 347
 348 bool
 349 ConnSSL_InitLibrary( void )
 350 {
 351         if (!Conf_SSLInUse()) {
 352                 LogDebug("SSL not in use, skipping initialization.");
 353                 return true;
 354         }
 355
 356 #ifdef HAVE_LIBSSL
 357         SSL_CTX *newctx;
 358
 359 #if OPENSSL_API_COMPAT < 0x10100000L
 360         if (!ssl_ctx) {
 361                 SSL_library_init();
 362                 SSL_load_error_strings();
 363         }
 364 #endif
 365
 366         if (!RAND_status()) {
 367                 Log(LOG_ERR, "OpenSSL PRNG not seeded: /dev/urandom missing?");
 368                 /*
 369                  * it is probably best to fail and let the user install EGD or
 370                  * a similar program if no kernel random device is available.
 371                  * According to OpenSSL RAND_egd(3): "The automatic query of
 372                  * /var/run/egd-pool et al was added in OpenSSL 0.9.7";
 373                  * so it makes little sense to deal with PRNGD seeding ourselves.
 374                  */
 375                 array_free(&Conf_SSLOptions.ListenPorts);
 376                 return false;
 377         }
 378
 379         newctx = SSL_CTX_new(SSLv23_method());
 380         if (!newctx) {
 381                 LogOpenSSLError("Failed to create SSL context", NULL);
 382                 array_free(&Conf_SSLOptions.ListenPorts);
 383                 return false;
 384         }
 385
 386         if (!ConnSSL_LoadServerKey_openssl(newctx)) {
 387                 /* Failed to read new key but an old ssl context
 388                  * already exists -> reuse old context */
 389                 if (ssl_ctx) {
 390                         SSL_CTX_free(newctx);
 391                         Log(LOG_WARNING,
 392                         "Re-Initializing of SSL failed, using old keys!");
 393                         return true;
 394                 }
 395                 /* No preexisting old context -> error. */
 396                 goto out;
 397         }
 398
 399         if (SSL_CTX_set_cipher_list(newctx, Conf_SSLOptions.CipherList) == 0) {
 400                 Log(LOG_ERR, "Failed to apply OpenSSL cipher list \"%s\"!",
 401                     Conf_SSLOptions.CipherList);
 402                 goto out;
 403         }
 404
 405         SSL_CTX_set_session_id_context(newctx, (unsigned char *)"ngircd", 6);
 406         if (!ConnSSL_SetVerifyProperties_openssl(newctx))
 407                 goto out;
 408         SSL_CTX_set_options(newctx,
 409                             SSL_OP_SINGLE_DH_USE | SSL_OP_NO_SSLv2 |
 410                             SSL_OP_NO_SSLv3 | SSL_OP_NO_TLSv1 | SSL_OP_NO_TLSv1_1 |
 411                             SSL_OP_NO_COMPRESSION);
 412         SSL_CTX_set_mode(newctx, SSL_MODE_ENABLE_PARTIAL_WRITE);
 413         SSL_CTX_free(ssl_ctx);
 414         ssl_ctx = newctx;
 415         Log(LOG_INFO, "%s initialized.", OpenSSL_version(OPENSSL_VERSION));
 416         return true;
 417 out:
 418         SSL_CTX_free(newctx);
 419         array_free(&Conf_SSLOptions.ListenPorts);
 420         return false;
 421 #endif
 422 #ifdef HAVE_LIBGNUTLS
 423         int err;
 424         static bool initialized;
 425
 426         if (!initialized) {
 427                 err = gnutls_global_init();
 428                 if (err) {
 429                         Log(LOG_ERR, "Failed to initialize GnuTLS: %s",
 430                             gnutls_strerror(err));
 431                         goto out;
 432                 }
 433         }
 434
 435         if (!ConnSSL_LoadServerKey_gnutls())
 436                 goto out;
 437
 438         if (priorities_cache != NULL) {
 439                 gnutls_priority_deinit(priorities_cache);
 440         }
 441         if (gnutls_priority_init(&priorities_cache, Conf_SSLOptions.CipherList,
 442                                  NULL) != GNUTLS_E_SUCCESS) {
 443                 Log(LOG_ERR,
 444                     "Failed to apply GnuTLS cipher list \"%s\"!",
 445                     Conf_SSLOptions.CipherList);
 446                 goto out;
 447         }
 448
 449         if (!ConnSSL_SetVerifyProperties_gnutls())
 450                 goto out;
 451
 452         Log(LOG_INFO, "GnuTLS %s initialized.", gnutls_check_version(NULL));
 453         initialized = true;
 454         return true;
 455 out:
 456         array_free(&Conf_SSLOptions.ListenPorts);
 457         return false;
 458 #endif
 459 }
 460
 461
 462 #ifdef HAVE_LIBGNUTLS
 463 static bool
 464 ConnSSL_SetVerifyProperties_gnutls(void)
 465 {
 466         int err;
 467
 468         if (!Conf_SSLOptions.CAFile)
 469                 return true;
 470
 471         x509_cred_slot *slot = array_get(&x509_creds, sizeof(x509_cred_slot), x509_cred_idx);
 472         gnutls_certificate_credentials_t x509_cred = slot->x509_cred;
 473
 474         err = gnutls_certificate_set_x509_trust_file(x509_cred,
 475                                                      Conf_SSLOptions.CAFile,
 476                                                      GNUTLS_X509_FMT_PEM);
 477         if (err < 0) {
 478                 Log(LOG_ERR, "Failed to load x509 trust file %s: %s",
 479                     Conf_SSLOptions.CAFile, gnutls_strerror(err));
 480                 return false;
 481         }
 482         if (Conf_SSLOptions.CRLFile) {
 483                 err =
 484                     gnutls_certificate_set_x509_crl_file(x509_cred,
 485                                                          Conf_SSLOptions.CRLFile,
 486                                                          GNUTLS_X509_FMT_PEM);
 487                 if (err < 0) {
 488                         Log(LOG_ERR, "Failed to load x509 crl file %s: %s",
 489                             Conf_SSLOptions.CRLFile, gnutls_strerror(err));
 490                         return false;
 491                 }
 492         }
 493         return true;
 494 }
 495
 496
 497 static bool
 498 ConnSSL_LoadServerKey_gnutls(void)
 499 {
 500         int err;
 501         const char *cert_file;
 502
 503         x509_cred_slot *slot = NULL;
 504         gnutls_certificate_credentials_t x509_cred;
 505
 506         err = gnutls_certificate_allocate_credentials(&x509_cred);
 507         if (err < 0) {
 508                 Log(LOG_ERR, "Failed to allocate certificate credentials: %s",
 509                     gnutls_strerror(err));
 510                 return false;
 511         }
 512
 513         if (array_bytes(&Conf_SSLOptions.KeyFilePassword))
 514                 Log(LOG_WARNING,
 515                     "Ignoring SSL \"KeyFilePassword\": Not supported by GnuTLS.");
 516
 517         if (!Load_DH_params())
 518                 return false;
 519
 520         gnutls_certificate_set_dh_params(x509_cred, dh_params);
 521         gnutls_certificate_set_flags(x509_cred, GNUTLS_CERTIFICATE_VERIFY_CRLS);
 522
 523         cert_file = Conf_SSLOptions.CertFile ?
 524                         Conf_SSLOptions.CertFile : Conf_SSLOptions.KeyFile;
 525         if (Conf_SSLOptions.KeyFile) {
 526                 err = gnutls_certificate_set_x509_key_file(x509_cred, cert_file,
 527                                                            Conf_SSLOptions.KeyFile,
 528                                                            GNUTLS_X509_FMT_PEM);
 529                 if (err < 0) {
 530                         Log(LOG_ERR,
 531                             "Failed to set certificate key file (cert %s, key %s): %s",
 532                             cert_file,
 533                             Conf_SSLOptions.KeyFile ? Conf_SSLOptions.KeyFile : "(NULL)",
 534                             gnutls_strerror(err));
 535                         return false;
 536                 }
 537         }
 538
 539         /* Free currently active x509 context (if any) unless it is still in use */
 540         slot = array_get(&x509_creds, sizeof(x509_cred_slot), x509_cred_idx);
 541         if ((slot != NULL) && (slot->refcnt <= 0) && (slot->x509_cred != NULL)) {
 542                 LogDebug("Discarding X509 certificate credentials from slot %zd.",
 543                          x509_cred_idx);
 544                 gnutls_certificate_free_keys(slot->x509_cred);
 545                 gnutls_certificate_free_credentials(slot->x509_cred);
 546                 slot->x509_cred = NULL;
 547                 gnutls_dh_params_deinit(slot->dh_params);
 548                 slot->dh_params = NULL;
 549                 slot->refcnt = 0;
 550         }
 551
 552         /* Find free slot */
 553         x509_cred_idx = (size_t) -1;
 554         size_t i;
 555         for (slot = array_start(&x509_creds), i = 0;
 556              i < array_length(&x509_creds, sizeof(x509_cred_slot));
 557              slot++, i++) {
 558                 if (slot->refcnt <= 0) {
 559                         x509_cred_idx = i;
 560                         break;
 561                 }
 562         }
 563         /* ... allocate new slot otherwise. */
 564         if (x509_cred_idx == (size_t) -1) {
 565                 x509_cred_idx = array_length(&x509_creds, sizeof(x509_cred_slot));
 566                 slot = array_alloc(&x509_creds, sizeof(x509_cred_slot), x509_cred_idx);
 567                 if (slot == NULL) {
 568                         Log(LOG_ERR, "Failed to allocate new slot for certificate credentials");
 569                         return false;
 570                 }
 571         }
 572         LogDebug("Storing new X509 certificate credentials in slot %zd.", x509_cred_idx);
 573         slot->x509_cred = x509_cred;
 574         slot->refcnt = 0;
 575
 576         return true;
 577 }
 578 #endif
 579
 580
 581 #ifdef HAVE_LIBSSL
 582 static bool
 583 ConnSSL_LoadServerKey_openssl(SSL_CTX *ctx)
 584 {
 585         char *cert_key;
 586
 587         assert(ctx);
 588         SSL_CTX_set_default_passwd_cb(ctx, pem_passwd_cb);
 589         SSL_CTX_set_default_passwd_cb_userdata(ctx, &Conf_SSLOptions.KeyFilePassword);
 590
 591         if (!Conf_SSLOptions.KeyFile)
 592                 return true;
 593
 594         if (SSL_CTX_use_PrivateKey_file(ctx, Conf_SSLOptions.KeyFile, SSL_FILETYPE_PEM) != 1) {
 595                 array_free_wipe(&Conf_SSLOptions.KeyFilePassword);
 596                 LogOpenSSLError("Failed to add private key", Conf_SSLOptions.KeyFile);
 597                 return false;
 598         }
 599
 600         cert_key = Conf_SSLOptions.CertFile ? Conf_SSLOptions.CertFile:Conf_SSLOptions.KeyFile;
 601         if (SSL_CTX_use_certificate_chain_file(ctx, cert_key) != 1) {
 602                 array_free_wipe(&Conf_SSLOptions.KeyFilePassword);
 603                 LogOpenSSLError("Failed to load certificate chain", cert_key);
 604                 return false;
 605         }
 606
 607         array_free_wipe(&Conf_SSLOptions.KeyFilePassword);
 608
 609         if (!SSL_CTX_check_private_key(ctx)) {
 610                 LogOpenSSLError("Server private key does not match certificate", NULL);
 611                 return false;
 612         }
 613         if (Load_DH_params()) {
 614                 if (SSL_CTX_set_tmp_dh(ctx, dh_params) != 1)
 615                         LogOpenSSLError("Error setting DH parameters", Conf_SSLOptions.DHFile);
 616                 /* don't return false here: the non-DH modes will still work */
 617                 DH_free(dh_params);
 618                 dh_params = NULL;
 619         }
 620         return true;
 621 }
 622
 623
 624 static bool
 625 ConnSSL_SetVerifyProperties_openssl(SSL_CTX * ctx)
 626 {
 627         X509_STORE *store = NULL;
 628         X509_LOOKUP *lookup;
 629         bool ret = false;
 630
 631         if (!Conf_SSLOptions.CAFile)
 632                 return true;
 633
 634         if (SSL_CTX_load_verify_locations(ctx, Conf_SSLOptions.CAFile, NULL) !=
 635             1) {
 636                 LogOpenSSLError("SSL_CTX_load_verify_locations", NULL);
 637                 goto out;
 638         }
 639
 640         if (Conf_SSLOptions.CRLFile) {
 641                 X509_VERIFY_PARAM *param = X509_VERIFY_PARAM_new();
 642                 X509_VERIFY_PARAM_set_flags(param, X509_V_FLAG_CRL_CHECK);
 643                 SSL_CTX_set1_param(ctx, param);
 644
 645                 store = SSL_CTX_get_cert_store(ctx);
 646                 assert(store);
 647                 lookup = X509_STORE_add_lookup(store, X509_LOOKUP_file());
 648                 if (!lookup) {
 649                         LogOpenSSLError("X509_STORE_add_lookup",
 650                                         Conf_SSLOptions.CRLFile);
 651                         goto out;
 652                 }
 653
 654                 if (X509_load_crl_file
 655                     (lookup, Conf_SSLOptions.CRLFile, X509_FILETYPE_PEM) != 1) {
 656                         LogOpenSSLError("X509_load_crl_file",
 657                                         Conf_SSLOptions.CRLFile);
 658                         goto out;
 659                 }
 660         }
 661
 662         SSL_CTX_set_verify(ctx, SSL_VERIFY_PEER|SSL_VERIFY_CLIENT_ONCE,
 663                            Verify_openssl);
 664         SSL_CTX_set_verify_depth(ctx, MAX_CERT_CHAIN_LENGTH);
 665         ret = true;
 666 out:
 667         if (Conf_SSLOptions.CRLFile)
 668                 free(Conf_SSLOptions.CRLFile);
 669         Conf_SSLOptions.CRLFile = NULL;
 670         return ret;
 671 }
 672
 673
 674 #endif
 675 static bool
 676 ConnSSL_Init_SSL(CONNECTION *c)
 677 {
 678         int ret;
 679
 680         LogDebug("Initializing SSL ...");
 681         assert(c != NULL);
 682
 683 #ifdef HAVE_LIBSSL
 684         if (!ssl_ctx) {
 685                 Log(LOG_ERR,
 686                     "Can't initialize SSL context, OpenSSL initialization failed at startup!");
 687                 return false;
 688         }
 689         assert(c->ssl_state.ssl == NULL);
 690         assert(c->ssl_state.fingerprint == NULL);
 691
 692         c->ssl_state.ssl = SSL_new(ssl_ctx);
 693         if (!c->ssl_state.ssl) {
 694                 LogOpenSSLError("Failed to create SSL structure", NULL);
 695                 return false;
 696         }
 697         Conn_OPTION_ADD(c, CONN_SSL);
 698
 699         ret = SSL_set_fd(c->ssl_state.ssl, c->sock);
 700         if (ret != 1) {
 701                 LogOpenSSLError("Failed to set SSL file descriptor", NULL);
 702                 ConnSSL_Free(c);
 703                 return false;
 704         }
 705 #endif
 706 #ifdef HAVE_LIBGNUTLS
 707         Conn_OPTION_ADD(c, CONN_SSL);
 708         ret = gnutls_priority_set(c->ssl_state.gnutls_session, priorities_cache);
 709         if (ret != GNUTLS_E_SUCCESS) {
 710                 Log(LOG_ERR, "Failed to set GnuTLS session priorities: %s",
 711                     gnutls_strerror(ret));
 712                 ConnSSL_Free(c);
 713                 return false;
 714         }
 715         /*
 716          * The intermediate (long) cast is here to avoid a warning like:
 717          * "cast to pointer from integer of different size" on 64-bit platforms.
 718          * There doesn't seem to be an alternate GNUTLS API we could use instead, see e.g.
 719          * http://www.mail-archive.com/help-gnutls@gnu.org/msg00286.html
 720          */
 721         gnutls_transport_set_ptr(c->ssl_state.gnutls_session,
 722                                  (gnutls_transport_ptr_t) (long) c->sock);
 723         gnutls_certificate_server_set_request(c->ssl_state.gnutls_session,
 724                                               GNUTLS_CERT_REQUEST);
 725
 726         LogDebug("Using X509 credentials from slot %zd.", x509_cred_idx);
 727         c->ssl_state.x509_cred_idx = x509_cred_idx;
 728         x509_cred_slot *slot = array_get(&x509_creds, sizeof(x509_cred_slot), x509_cred_idx);
 729         slot->refcnt++;
 730         ret = gnutls_credentials_set(c->ssl_state.gnutls_session,
 731                                      GNUTLS_CRD_CERTIFICATE, slot->x509_cred);
 732         if (ret != 0) {
 733                 Log(LOG_ERR, "Failed to set SSL credentials: %s",
 734                     gnutls_strerror(ret));
 735                 ConnSSL_Free(c);
 736                 return false;
 737         }
 738         gnutls_dh_set_prime_bits(c->ssl_state.gnutls_session, DH_BITS_MIN);
 739 #endif
 740         return true;
 741 }
 742
 743
 744 bool
 745 ConnSSL_PrepareConnect(CONNECTION * c, CONF_SERVER * s)
 746 {
 747         bool ret;
 748 #ifdef HAVE_LIBGNUTLS
 749         int err;
 750
 751         (void)s;
 752         err = gnutls_init(&c->ssl_state.gnutls_session, GNUTLS_CLIENT);
 753         if (err) {
 754                 Log(LOG_ERR, "Failed to initialize new SSL session: %s",
 755                     gnutls_strerror(err));
 756                 return false;
 757         }
 758 #endif
 759         ret = ConnSSL_Init_SSL(c);
 760         if (!ret)
 761                 return false;
 762         Conn_OPTION_ADD(c, CONN_SSL_CONNECT);
 763
 764 #ifdef HAVE_LIBSSL
 765         assert(c->ssl_state.ssl);
 766
 767         X509_VERIFY_PARAM *param = SSL_get0_param(c->ssl_state.ssl);
 768         X509_VERIFY_PARAM_set_hostflags(param, X509_CHECK_FLAG_NO_PARTIAL_WILDCARDS);
 769         int err = X509_VERIFY_PARAM_set1_host(param, s->host, 0);
 770         if (err != 1) {
 771                 Log(LOG_ERR,
 772                     "Cannot set up hostname verification for '%s': %u",
 773                     s->host, err);
 774                 return false;
 775         }
 776
 777         if (s->SSLVerify)
 778                 SSL_set_verify(c->ssl_state.ssl, SSL_VERIFY_PEER,
 779                                Verify_openssl);
 780         else
 781                 SSL_set_verify(c->ssl_state.ssl, SSL_VERIFY_NONE, NULL);
 782 #endif
 783
 784         return true;
 785 }
 786
 787
 788 /**
 789  * Check and handle error return codes after failed calls to SSL functions.
 790  *
 791  * OpenSSL:
 792  * SSL_connect(), SSL_accept(), SSL_do_handshake(), SSL_read(), SSL_peek(), or
 793  * SSL_write() on ssl.
 794  *
 795  * GnuTLS:
 796  * gnutlsssl_read(), gnutls_write() or gnutls_handshake().
 797  *
 798  * @param c The connection handle.
 799  * @prarm code The return code.
 800  * @param fname The name of the function in which the error occurred.
 801  * @return -1 on fatal errors, 0 if we can try again later.
 802  */
 803 static int
 804 ConnSSL_HandleError(CONNECTION * c, const int code, const char *fname)
 805 {
 806 #ifdef HAVE_LIBSSL
 807         int ret = SSL_ERROR_SYSCALL;
 808         unsigned long sslerr;
 809         int real_errno = errno;
 810
 811         ret = SSL_get_error(c->ssl_state.ssl, code);
 812
 813         switch (ret) {
 814         case SSL_ERROR_WANT_READ:
 815                 io_event_del(c->sock, IO_WANTWRITE);
 816                 Conn_OPTION_ADD(c, CONN_SSL_WANT_READ);
 817                 return 0;       /* try again later */
 818         case SSL_ERROR_WANT_WRITE:
 819                 io_event_del(c->sock, IO_WANTREAD);
 820                 Conn_OPTION_ADD(c, CONN_SSL_WANT_WRITE); /* fall through */
 821         case SSL_ERROR_NONE:
 822                 return 0;       /* try again later */
 823         case SSL_ERROR_ZERO_RETURN:
 824                 LogDebug("SSL connection shut down normally.");
 825                 break;
 826         case SSL_ERROR_SYSCALL:
 827                 /* SSL_ERROR_WANT_CONNECT, SSL_ERROR_WANT_ACCEPT,
 828                  * and SSL_ERROR_WANT_X509_LOOKUP */
 829                 sslerr = ERR_get_error();
 830                 if (sslerr) {
 831                         Log(LOG_ERR, "SSL error: %s [in %s()]!",
 832                             ERR_error_string(sslerr, NULL), fname);
 833                 } else {
 834                         switch (code) { /* EOF that violated protocol */
 835                         case 0:
 836                                 Log(LOG_ERR,
 837                                     "SSL error, client disconnected [in %s()]!",
 838                                     fname);
 839                                 break;
 840                         case -1:
 841                                 /* Low level socket I/O error, check errno. But
 842                                  * we don't need to log this here, the generic
 843                                  * connection layer will take care of it. */
 844                                 LogDebug("SSL error: %s [in %s()]!",
 845                                          strerror(real_errno), fname);
 846                         }
 847                 }
 848                 break;
 849         case SSL_ERROR_SSL:
 850                 LogOpenSSLError("SSL protocol error", fname);
 851                 break;
 852         default:
 853                 Log(LOG_ERR, "Unknown SSL error %d [in %s()]!", ret, fname);
 854         }
 855         ConnSSL_Free(c);
 856         return -1;
 857 #endif
 858 #ifdef HAVE_LIBGNUTLS
 859         switch (code) {
 860         case GNUTLS_E_AGAIN:
 861         case GNUTLS_E_INTERRUPTED:
 862                 if (gnutls_record_get_direction(c->ssl_state.gnutls_session)) {
 863                         Conn_OPTION_ADD(c, CONN_SSL_WANT_WRITE);
 864                         io_event_del(c->sock, IO_WANTREAD);
 865                 } else {
 866                         Conn_OPTION_ADD(c, CONN_SSL_WANT_READ);
 867                         io_event_del(c->sock, IO_WANTWRITE);
 868                 }
 869                 break;
 870         default:
 871                 assert(code < 0);
 872                 if (gnutls_error_is_fatal(code)) {
 873                         /* We don't need to log this here, the generic
 874                          * connection layer will take care of it. */
 875                         LogDebug("SSL error: %s [%s].",
 876                                  gnutls_strerror(code), fname);
 877                         ConnSSL_Free(c);
 878                         return -1;
 879                 }
 880         }
 881         return 0;
 882 #endif
 883 }
 884
 885
 886 #ifdef HAVE_LIBGNUTLS
 887 static void *
 888 LogMalloc(size_t s)
 889 {
 890         void *mem = malloc(s);
 891         if (!mem)
 892                 Log(LOG_ERR, "Out of memory: Could not allocate %lu byte",
 893                     (unsigned long)s);
 894         return mem;
 895 }
 896
 897
 898 static void
 899 LogGnuTLS_CertInfo(int level, gnutls_x509_crt_t cert, const char *msg)
 900 {
 901         char *dn, *issuer_dn;
 902         size_t size = 0;
 903         int err = gnutls_x509_crt_get_dn(cert, NULL, &size);
 904         if (size == 0) {
 905                 Log(LOG_ERR, "gnutls_x509_crt_get_dn: size == 0");
 906                 return;
 907         }
 908         if (err && err != GNUTLS_E_SHORT_MEMORY_BUFFER)
 909                 goto err_crt_get;
 910         dn = LogMalloc(size);
 911         if (!dn)
 912                 return;
 913         err = gnutls_x509_crt_get_dn(cert, dn, &size);
 914         if (err)
 915                 goto err_crt_get;
 916         gnutls_x509_crt_get_issuer_dn(cert, NULL, &size);
 917         assert(size);
 918         issuer_dn = LogMalloc(size);
 919         if (!issuer_dn) {
 920                 Log(level, "%s: Distinguished Name \"%s\".", msg, dn);
 921                 free(dn);
 922                 return;
 923         }
 924         gnutls_x509_crt_get_issuer_dn(cert, issuer_dn, &size);
 925         Log(level, "%s: Distinguished Name \"%s\", Issuer \"%s\".", msg, dn,
 926             issuer_dn);
 927         free(dn);
 928         free(issuer_dn);
 929         return;
 930
 931       err_crt_get:
 932         Log(LOG_ERR, "gnutls_x509_crt_get_dn: %s", gnutls_strerror(err));
 933         return;
 934 }
 935 #endif
 936
 937
 938 static void
 939 ConnSSL_LogCertInfo( CONNECTION * c, bool connect)
 940 {
 941         bool cert_seen = false, cert_ok = false;
 942         char msg[128];
 943 #ifdef HAVE_LIBSSL
 944         const char *comp_alg = "no compression";
 945         const void *comp;
 946         X509 *peer_cert = NULL;
 947         SSL *ssl = c->ssl_state.ssl;
 948
 949         assert(ssl);
 950
 951         comp = SSL_get_current_compression(ssl);
 952         if (comp)
 953                 comp_alg = SSL_COMP_get_name(comp);
 954         Log(LOG_INFO, "Connection %d: initialized %s using cipher %s, %s.",
 955             c->sock, SSL_get_version(ssl), SSL_get_cipher(ssl), comp_alg);
 956         peer_cert = SSL_get_peer_certificate(ssl);
 957         if (peer_cert) {
 958                 cert_seen = true;
 959
 960                 if (connect) {
 961                         /* Outgoing connection. Verify the remote server! */
 962                         int err = SSL_get_verify_result(ssl);
 963                         if (err == X509_V_OK) {
 964                                 const char *peername = SSL_get0_peername(ssl);
 965                                 if (peername != NULL)
 966                                         cert_ok = true;
 967                                 LogDebug("X509_V_OK, peername = '%s'", peername);
 968                         } else
 969                                 Log(LOG_WARNING, "Certificate validation failed: %s!",
 970                                     X509_verify_cert_error_string(err));
 971
 972                         snprintf(msg, sizeof(msg), "Got %svalid server certificate",
 973                                  cert_ok ? "" : "in");
 974                         LogOpenSSL_CertInfo(LOG_INFO, peer_cert, msg);
 975                 } else {
 976                         /* Incoming connection.
 977                          * Accept all certificates, don't depend on their
 978                          * validity: for example, we don't know the hostname
 979                          * to check, because we not yet even know if this is a
 980                          * server connection at all and if so, which one, so we
 981                          * don't know a host name to look for. On the other
 982                          * hand we want client certificates, for example for
 983                          * "CertFP" authentication with services ... */
 984                         LogOpenSSL_CertInfo(LOG_INFO, peer_cert,
 985                                             "Got unchecked peer certificate");
 986                 }
 987
 988                 X509_free(peer_cert);
 989         }
 990 #endif
 991 #ifdef HAVE_LIBGNUTLS
 992         unsigned int status;
 993         gnutls_credentials_type_t cred;
 994         gnutls_session_t sess = c->ssl_state.gnutls_session;
 995         gnutls_cipher_algorithm_t cipher = gnutls_cipher_get(sess);
 996
 997         Log(LOG_INFO, "Connection %d: initialized %s using cipher %s-%s.",
 998             c->sock,
 999             gnutls_protocol_get_name(gnutls_protocol_get_version(sess)),
1000             gnutls_cipher_get_name(cipher),
1001             gnutls_mac_get_name(gnutls_mac_get(sess)));
1002         cred = gnutls_auth_get_type(c->ssl_state.gnutls_session);
1003         if (cred == GNUTLS_CRD_CERTIFICATE) {
1004                 gnutls_x509_crt_t cert;
1005                 unsigned cert_list_size;
1006                 const gnutls_datum_t *cert_list =
1007                     gnutls_certificate_get_peers(sess, &cert_list_size);
1008
1009                 if (!cert_list || cert_list_size == 0)
1010                         goto done_cn_validation;
1011
1012                 cert_seen = true;
1013                 int err = gnutls_x509_crt_init(&cert);
1014                 if (err < 0) {
1015                         Log(LOG_ERR,
1016                             "Failed to initialize x509 certificate: %s",
1017                             gnutls_strerror(err));
1018                         goto done_cn_validation;
1019                 }
1020                 err = gnutls_x509_crt_import(cert, cert_list,
1021                                            GNUTLS_X509_FMT_DER);
1022                 if (err < 0) {
1023                         Log(LOG_ERR, "Failed to parse the certificate: %s",
1024                             gnutls_strerror(err));
1025                         goto done_cn_validation;
1026                 }
1027
1028                 if (connect) {
1029                         int verify =
1030                             gnutls_certificate_verify_peers2(c->
1031                                                              ssl_state.gnutls_session,
1032                                                              &status);
1033                         if (verify < 0) {
1034                                 Log(LOG_ERR,
1035                                     "gnutls_certificate_verify_peers2 failed: %s",
1036                                     gnutls_strerror(verify));
1037                                 goto done_cn_validation;
1038                         } else if (status) {
1039                                 gnutls_datum_t out;
1040
1041                                 if (gnutls_certificate_verification_status_print
1042                                     (status, gnutls_certificate_type_get(sess), &out,
1043                                      0) == GNUTLS_E_SUCCESS) {
1044                                         Log(LOG_ERR,
1045                                             "Certificate validation failed: %s",
1046                                             out.data);
1047                                         gnutls_free(out.data);
1048                                 }
1049                         }
1050
1051                         err = gnutls_x509_crt_check_hostname(cert, c->host);
1052                         if (err == 0)
1053                                 Log(LOG_ERR,
1054                                     "Failed to verify the hostname, expected \"%s\"",
1055                                     c->host);
1056                         else
1057                                 cert_ok = verify == 0 && status == 0;
1058
1059                         snprintf(msg, sizeof(msg), "Got %svalid server certificate",
1060                                 cert_ok ? "" : "in");
1061                         LogGnuTLS_CertInfo(LOG_INFO, cert, msg);
1062                 } else {
1063                         /* Incoming connection. Please see comments for OpenSSL! */
1064                         LogGnuTLS_CertInfo(LOG_INFO, cert,
1065                                             "Got unchecked peer certificate");
1066                 }
1067
1068                 gnutls_x509_crt_deinit(cert);
1069 done_cn_validation:
1070                 ;
1071         }
1072 #endif
1073         /*
1074          * can be used later to check if connection was authenticated, e.g.
1075          * if inbound connection tries to register itself as server.
1076          * Could also restrict /OPER to authenticated connections, etc.
1077          */
1078         if (cert_ok)
1079                 Conn_OPTION_ADD(c, CONN_SSL_PEERCERT_OK);
1080         if (!cert_seen)
1081                 Log(LOG_INFO, "Peer did not present a certificate.");
1082 }
1083
1084
1085 /*
1086  Accept incoming SSL connection.
1087  Return Values:
1088          1: SSL Connection established
1089          0: try again
1090         -1: SSL Connection not established due to fatal error.
1091 */
1092 int
1093 ConnSSL_Accept( CONNECTION *c )
1094 {
1095         assert(c != NULL);
1096         if (!Conn_OPTION_ISSET(c, CONN_SSL)) {
1097 #ifdef HAVE_LIBGNUTLS
1098                 int err = gnutls_init(&c->ssl_state.gnutls_session, GNUTLS_SERVER);
1099                 if (err) {
1100                         Log(LOG_ERR, "Failed to initialize new SSL session: %s",
1101                             gnutls_strerror(err));
1102                         return false;
1103                 }
1104 #endif
1105                 if (!ConnSSL_Init_SSL(c))
1106                         return -1;
1107         }
1108         return ConnectAccept(c, false );
1109 }
1110
1111
1112 int
1113 ConnSSL_Connect( CONNECTION *c )
1114 {
1115         assert(c != NULL);
1116 #ifdef HAVE_LIBSSL
1117         assert(c->ssl_state.ssl);
1118 #endif
1119         assert(Conn_OPTION_ISSET(c, CONN_SSL));
1120         return ConnectAccept(c, true);
1121 }
1122
1123 static int
1124 ConnSSL_InitCertFp( CONNECTION *c )
1125 {
1126         const char hex[] = "0123456789abcdef";
1127         int i;
1128
1129 #ifdef HAVE_LIBSSL
1130         unsigned char digest[EVP_MAX_MD_SIZE];
1131         unsigned int digest_size;
1132         X509 *cert;
1133
1134         cert = SSL_get_peer_certificate(c->ssl_state.ssl);
1135         if (!cert)
1136                 return 0;
1137
1138         if (!X509_digest(cert, EVP_sha256(), digest, &digest_size)) {
1139                 X509_free(cert);
1140                 return 0;
1141         }
1142
1143         X509_free(cert);
1144 #endif /* HAVE_LIBSSL */
1145 #ifdef HAVE_LIBGNUTLS
1146         gnutls_x509_crt_t cert;
1147         unsigned int cert_list_size;
1148         const gnutls_datum_t *cert_list;
1149         unsigned char digest[MAX_HASH_SIZE];
1150         size_t digest_size;
1151
1152         if (gnutls_certificate_type_get(c->ssl_state.gnutls_session) !=
1153                                         GNUTLS_CRT_X509)
1154                 return 0;
1155
1156         if (gnutls_x509_crt_init(&cert) != GNUTLS_E_SUCCESS)
1157                 return 0;
1158
1159         cert_list_size = 0;
1160         cert_list = gnutls_certificate_get_peers(c->ssl_state.gnutls_session,
1161                                                  &cert_list_size);
1162         if (!cert_list) {
1163                 gnutls_x509_crt_deinit(cert);
1164                 return 0;
1165         }
1166
1167         if (gnutls_x509_crt_import(cert, &cert_list[0],
1168                                    GNUTLS_X509_FMT_DER) != GNUTLS_E_SUCCESS) {
1169                 gnutls_x509_crt_deinit(cert);
1170                 return 0;
1171         }
1172
1173         digest_size = sizeof(digest);
1174         if (gnutls_x509_crt_get_fingerprint(cert, GNUTLS_DIG_SHA256, digest,
1175                                             &digest_size)) {
1176                 gnutls_x509_crt_deinit(cert);
1177                 return 0;
1178         }
1179
1180         gnutls_x509_crt_deinit(cert);
1181 #endif /* HAVE_LIBGNUTLS */
1182
1183         assert(c->ssl_state.fingerprint == NULL);
1184
1185         c->ssl_state.fingerprint = malloc(SHA256_STRING_LEN);
1186         if (!c->ssl_state.fingerprint)
1187                 return 0;
1188
1189         for (i = 0; i < (int)digest_size; i++) {
1190                 c->ssl_state.fingerprint[i * 2] = hex[digest[i] / 16];
1191                 c->ssl_state.fingerprint[i * 2 + 1] = hex[digest[i] % 16];
1192         }
1193         c->ssl_state.fingerprint[i * 2] = '\0';
1194
1195         return 1;
1196 }
1197
1198 /* accept/connect wrapper. if connect is true, connect to peer, otherwise wait for incoming connection */
1199 static int
1200 ConnectAccept( CONNECTION *c, bool connect)
1201 {
1202         int ret;
1203 #ifdef HAVE_LIBSSL
1204         SSL *ssl = c->ssl_state.ssl;
1205         assert(ssl != NULL);
1206
1207         ret = connect ? SSL_connect(ssl) : SSL_accept(ssl);
1208         if (1 != ret)
1209                 return ConnSSL_HandleError(c, ret, connect ? "SSL_connect": "SSL_accept");
1210 #endif
1211 #ifdef HAVE_LIBGNUTLS
1212         (void) connect;
1213         ret = gnutls_handshake(c->ssl_state.gnutls_session);
1214         if (ret)
1215                 return ConnSSL_HandleError(c, ret, "gnutls_handshake");
1216 #endif /* _GNUTLS */
1217         (void)ConnSSL_InitCertFp(c);
1218
1219         Conn_OPTION_DEL(c, (CONN_SSL_WANT_WRITE|CONN_SSL_WANT_READ|CONN_SSL_CONNECT));
1220         ConnSSL_LogCertInfo(c, connect);
1221
1222         Conn_StartLogin(CONNECTION2ID(c));
1223         return 1;
1224 }
1225
1226
1227 ssize_t
1228 ConnSSL_Write(CONNECTION *c, const void *buf, size_t count)
1229 {
1230         ssize_t bw;
1231
1232         Conn_OPTION_DEL(c, CONN_SSL_WANT_WRITE|CONN_SSL_WANT_READ);
1233
1234         assert(count > 0);
1235 #ifdef HAVE_LIBSSL
1236         bw = (ssize_t) SSL_write(c->ssl_state.ssl, buf, count);
1237 #endif
1238 #ifdef HAVE_LIBGNUTLS
1239         bw = gnutls_write(c->ssl_state.gnutls_session, buf, count);
1240 #endif
1241         if (bw > 0)
1242                 return bw;
1243         if (ConnSSL_HandleError( c, bw, "ConnSSL_Write") == 0)
1244                 errno = EAGAIN; /* try again */
1245         return -1;
1246 }
1247
1248
1249 ssize_t
1250 ConnSSL_Read(CONNECTION *c, void * buf, size_t count)
1251 {
1252         ssize_t br;
1253
1254         Conn_OPTION_DEL(c, CONN_SSL_WANT_WRITE|CONN_SSL_WANT_READ);
1255 #ifdef HAVE_LIBSSL
1256         br = (ssize_t) SSL_read(c->ssl_state.ssl, buf, count);
1257         if (br > 0)     /* on EOF we have to call ConnSSL_HandleError(), see SSL_read(3) */
1258                 return br;
1259 #endif
1260 #ifdef HAVE_LIBGNUTLS
1261         br = gnutls_read(c->ssl_state.gnutls_session, buf, count);
1262         if (br >= 0)    /* on EOF we must _not_ call ConnSSL_HandleError, see gnutls_record_recv(3) */
1263                 return br;
1264 #endif
1265         /* error on read: switch ConnSSL_HandleError() return values -> 0 is "try again", so return -1 and set EAGAIN */
1266         if (ConnSSL_HandleError(c, br, "ConnSSL_Read") == 0) {
1267                 errno = EAGAIN;
1268                 return -1;
1269         }
1270         return 0;
1271 }
1272
1273
1274 bool
1275 ConnSSL_GetCipherInfo(CONNECTION *c, char *buf, size_t len)
1276 {
1277 #ifdef HAVE_LIBSSL
1278         char *nl;
1279         SSL *ssl = c->ssl_state.ssl;
1280
1281         if (!ssl)
1282                 return false;
1283         *buf = 0;
1284         SSL_CIPHER_description(SSL_get_current_cipher(ssl), buf, len);
1285         nl = strchr(buf, '\n');
1286         if (nl)
1287                 *nl = 0;
1288         return true;
1289 #endif
1290 #ifdef HAVE_LIBGNUTLS
1291         if (Conn_OPTION_ISSET(c, CONN_SSL)) {
1292                 const char *name_cipher, *name_mac, *name_proto, *name_keyexchange;
1293                 unsigned keysize;
1294
1295                 gnutls_session_t sess = c->ssl_state.gnutls_session;
1296                 gnutls_cipher_algorithm_t cipher = gnutls_cipher_get(sess);
1297                 name_cipher = gnutls_cipher_get_name(cipher);
1298                 name_mac = gnutls_mac_get_name(gnutls_mac_get(sess));
1299                 keysize = gnutls_cipher_get_key_size(cipher) * 8;
1300                 name_proto = gnutls_protocol_get_name(gnutls_protocol_get_version(sess));
1301                 name_keyexchange = gnutls_kx_get_name(gnutls_kx_get(sess));
1302
1303                 return snprintf(buf, len, "%s-%s%15s Kx=%s      Enc=%s(%u) Mac=%s",
1304                         name_cipher, name_mac, name_proto, name_keyexchange, name_cipher, keysize, name_mac) > 0;
1305         }
1306         return false;
1307 #endif
1308 }
1309
1310 char *
1311 ConnSSL_GetCertFp(CONNECTION *c)
1312 {
1313         return c->ssl_state.fingerprint;
1314 }
1315
1316 bool
1317 ConnSSL_SetCertFp(CONNECTION *c, const char *fingerprint)
1318 {
1319         assert (c != NULL);
1320         c->ssl_state.fingerprint = strndup(fingerprint, SHA256_STRING_LEN - 1);
1321         return c->ssl_state.fingerprint != NULL;
1322 }
1323 #else
1324
1325 bool
1326 ConnSSL_InitLibrary(void)
1327 {
1328         return true;
1329 }
1330
1331 #endif /* SSL_SUPPORT */
1332 /* -eof- */