lib/stream-ssl.c

   1 /*
   2  * Copyright (c) 2008, 2009, 2010, 2011, 2012, 2013, 2014, 2015 Nicira, Inc.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at:
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <config.h>
  18 #include "stream-ssl.h"
  19 #include "dhparams.h"
  20 #include <ctype.h>
  21 #include <errno.h>
  22 #include <inttypes.h>
  23 #include <string.h>
  24 #include <sys/types.h>
  25 #include <sys/socket.h>
  26 #include <netinet/tcp.h>
  27 #include <openssl/err.h>
  28 #include <openssl/rand.h>
  29 #include <openssl/ssl.h>
  30 #include <openssl/x509v3.h>
  31 #include <poll.h>
  32 #include <fcntl.h>
  33 #include <sys/stat.h>
  34 #include <unistd.h>
  35 #include "coverage.h"
  36 #include "dynamic-string.h"
  37 #include "entropy.h"
  38 #include "ofpbuf.h"
  39 #include "openflow/openflow.h"
  40 #include "packets.h"
  41 #include "poll-loop.h"
  42 #include "shash.h"
  43 #include "socket-util.h"
  44 #include "util.h"
  45 #include "stream-provider.h"
  46 #include "stream.h"
  47 #include "timeval.h"
  48 #include "openvswitch/vlog.h"
  49
  50 #ifdef _WIN32
  51 /* Ref: https://www.openssl.org/support/faq.html#PROG2
  52  * Your application must link against the same version of the Win32 C-Runtime
  53  * against which your openssl libraries were linked.  The default version for
  54  * OpenSSL is /MD - "Multithreaded DLL". If we compile Open vSwitch with
  55  * something other than /MD, instead of re-compiling OpenSSL
  56  * toolkit, openssl/applink.c can be #included. Also, it is important
  57  * to add CRYPTO_malloc_init prior first call to OpenSSL.
  58  *
  59  * XXX: The behavior of the following #include when Open vSwitch is
  60  * compiled with /MD is not tested. */
  61 #include <openssl/applink.c>
  62 #define SHUT_RDWR SD_BOTH
  63 #endif
  64
  65 VLOG_DEFINE_THIS_MODULE(stream_ssl);
  66
  67 /* Active SSL. */
  68
  69 enum ssl_state {
  70     STATE_TCP_CONNECTING,
  71     STATE_SSL_CONNECTING
  72 };
  73
  74 enum session_type {
  75     CLIENT,
  76     SERVER
  77 };
  78
  79 struct ssl_stream
  80 {
  81     struct stream stream;
  82     enum ssl_state state;
  83     enum session_type type;
  84     int fd;
  85     SSL *ssl;
  86     struct ofpbuf *txbuf;
  87     unsigned int session_nr;
  88
  89     /* rx_want and tx_want record the result of the last call to SSL_read()
  90      * and SSL_write(), respectively:
  91      *
  92      *    - If the call reported that data needed to be read from the file
  93      *      descriptor, the corresponding member is set to SSL_READING.
  94      *
  95      *    - If the call reported that data needed to be written to the file
  96      *      descriptor, the corresponding member is set to SSL_WRITING.
  97      *
  98      *    - Otherwise, the member is set to SSL_NOTHING, indicating that the
  99      *      call completed successfully (or with an error) and that there is no
 100      *      need to block.
 101      *
 102      * These are needed because there is no way to ask OpenSSL what a data read
 103      * or write would require without giving it a buffer to receive into or
 104      * data to send, respectively.  (Note that the SSL_want() status is
 105      * overwritten by each SSL_read() or SSL_write() call, so we can't rely on
 106      * its value.)
 107      *
 108      * A single call to SSL_read() or SSL_write() can perform both reading
 109      * and writing and thus invalidate not one of these values but actually
 110      * both.  Consider this situation, for example:
 111      *
 112      *    - SSL_write() blocks on a read, so tx_want gets SSL_READING.
 113      *
 114      *    - SSL_read() laters succeeds reading from 'fd' and clears out the
 115      *      whole receive buffer, so rx_want gets SSL_READING.
 116      *
 117      *    - Client calls stream_wait(STREAM_RECV) and stream_wait(STREAM_SEND)
 118      *      and blocks.
 119      *
 120      *    - Now we're stuck blocking until the peer sends us data, even though
 121      *      SSL_write() could now succeed, which could easily be a deadlock
 122      *      condition.
 123      *
 124      * On the other hand, we can't reset both tx_want and rx_want on every call
 125      * to SSL_read() or SSL_write(), because that would produce livelock,
 126      * e.g. in this situation:
 127      *
 128      *    - SSL_write() blocks, so tx_want gets SSL_READING or SSL_WRITING.
 129      *
 130      *    - SSL_read() blocks, so rx_want gets SSL_READING or SSL_WRITING,
 131      *      but tx_want gets reset to SSL_NOTHING.
 132      *
 133      *    - Client calls stream_wait(STREAM_RECV) and stream_wait(STREAM_SEND)
 134      *      and blocks.
 135      *
 136      *    - Client wakes up immediately since SSL_NOTHING in tx_want indicates
 137      *      that no blocking is necessary.
 138      *
 139      * The solution we adopt here is to set tx_want to SSL_NOTHING after
 140      * calling SSL_read() only if the SSL state of the connection changed,
 141      * which indicates that an SSL-level renegotiation made some progress, and
 142      * similarly for rx_want and SSL_write().  This prevents both the
 143      * deadlock and livelock situations above.
 144      */
 145     int rx_want, tx_want;
 146
 147     /* A few bytes of header data in case SSL negotiation fails. */
 148     uint8_t head[2];
 149     short int n_head;
 150 };
 151
 152 /* SSL context created by ssl_init(). */
 153 static SSL_CTX *ctx;
 154
 155 struct ssl_config_file {
 156     bool read;                  /* Whether the file was successfully read. */
 157     char *file_name;            /* Configured file name, if any. */
 158     struct timespec mtime;      /* File mtime as of last time we read it. */
 159 };
 160
 161 /* SSL configuration files. */
 162 static struct ssl_config_file private_key;
 163 static struct ssl_config_file certificate;
 164 static struct ssl_config_file ca_cert;
 165
 166 /* Ordinarily, the SSL client and server verify each other's certificates using
 167  * a CA certificate.  Setting this to false disables this behavior.  (This is a
 168  * security risk.) */
 169 static bool verify_peer_cert = true;
 170
 171 /* Ordinarily, we require a CA certificate for the peer to be locally
 172  * available.  We can, however, bootstrap the CA certificate from the peer at
 173  * the beginning of our first connection then use that certificate on all
 174  * subsequent connections, saving it to a file for use in future runs also.  In
 175  * this case, 'bootstrap_ca_cert' is true. */
 176 static bool bootstrap_ca_cert;
 177
 178 /* Session number.  Used in debug logging messages to uniquely identify a
 179  * session. */
 180 static unsigned int next_session_nr;
 181
 182 /* Who knows what can trigger various SSL errors, so let's throttle them down
 183  * quite a bit. */
 184 static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(10, 25);
 185
 186 static int ssl_init(void);
 187 static int do_ssl_init(void);
 188 static bool ssl_wants_io(int ssl_error);
 189 static void ssl_close(struct stream *);
 190 static void ssl_clear_txbuf(struct ssl_stream *);
 191 static void interpret_queued_ssl_error(const char *function);
 192 static int interpret_ssl_error(const char *function, int ret, int error,
 193                                int *want);
 194 static DH *tmp_dh_callback(SSL *ssl, int is_export OVS_UNUSED, int keylength);
 195 static void log_ca_cert(const char *file_name, X509 *cert);
 196 static void stream_ssl_set_ca_cert_file__(const char *file_name,
 197                                           bool bootstrap, bool force);
 198 static void ssl_protocol_cb(int write_p, int version, int content_type,
 199                             const void *, size_t, SSL *, void *sslv_);
 200 static bool update_ssl_config(struct ssl_config_file *, const char *file_name);
 201 static int sock_errno(void);
 202
 203 static short int
 204 want_to_poll_events(int want)
 205 {
 206     switch (want) {
 207     case SSL_NOTHING:
 208         OVS_NOT_REACHED();
 209
 210     case SSL_READING:
 211         return POLLIN;
 212
 213     case SSL_WRITING:
 214         return POLLOUT;
 215
 216     default:
 217         OVS_NOT_REACHED();
 218     }
 219 }
 220
 221 static int
 222 new_ssl_stream(const char *name, int fd, enum session_type type,
 223                enum ssl_state state, struct stream **streamp)
 224 {
 225     struct ssl_stream *sslv;
 226     SSL *ssl = NULL;
 227     int retval;
 228
 229     /* Check for all the needful configuration. */
 230     retval = 0;
 231     if (!private_key.read) {
 232         VLOG_ERR("Private key must be configured to use SSL");
 233         retval = ENOPROTOOPT;
 234     }
 235     if (!certificate.read) {
 236         VLOG_ERR("Certificate must be configured to use SSL");
 237         retval = ENOPROTOOPT;
 238     }
 239     if (!ca_cert.read && verify_peer_cert && !bootstrap_ca_cert) {
 240         VLOG_ERR("CA certificate must be configured to use SSL");
 241         retval = ENOPROTOOPT;
 242     }
 243     if (!retval && !SSL_CTX_check_private_key(ctx)) {
 244         VLOG_ERR("Private key does not match certificate public key: %s",
 245                  ERR_error_string(ERR_get_error(), NULL));
 246         retval = ENOPROTOOPT;
 247     }
 248     if (retval) {
 249         goto error;
 250     }
 251
 252     /* Disable Nagle.
 253      * On windows platforms, this can only be called upon TCP connected.
 254      */
 255     if (state == STATE_SSL_CONNECTING) {
 256         setsockopt_tcp_nodelay(fd);
 257     }
 258
 259     /* Create and configure OpenSSL stream. */
 260     ssl = SSL_new(ctx);
 261     if (ssl == NULL) {
 262         VLOG_ERR("SSL_new: %s", ERR_error_string(ERR_get_error(), NULL));
 263         retval = ENOPROTOOPT;
 264         goto error;
 265     }
 266     if (SSL_set_fd(ssl, fd) == 0) {
 267         VLOG_ERR("SSL_set_fd: %s", ERR_error_string(ERR_get_error(), NULL));
 268         retval = ENOPROTOOPT;
 269         goto error;
 270     }
 271     if (!verify_peer_cert || (bootstrap_ca_cert && type == CLIENT)) {
 272         SSL_set_verify(ssl, SSL_VERIFY_NONE, NULL);
 273     }
 274
 275     /* Create and return the ssl_stream. */
 276     sslv = xmalloc(sizeof *sslv);
 277     stream_init(&sslv->stream, &ssl_stream_class, EAGAIN, name);
 278     sslv->state = state;
 279     sslv->type = type;
 280     sslv->fd = fd;
 281     sslv->ssl = ssl;
 282     sslv->txbuf = NULL;
 283     sslv->rx_want = sslv->tx_want = SSL_NOTHING;
 284     sslv->session_nr = next_session_nr++;
 285     sslv->n_head = 0;
 286
 287     if (VLOG_IS_DBG_ENABLED()) {
 288         SSL_set_msg_callback(ssl, ssl_protocol_cb);
 289         SSL_set_msg_callback_arg(ssl, sslv);
 290     }
 291
 292     *streamp = &sslv->stream;
 293     return 0;
 294
 295 error:
 296     if (ssl) {
 297         SSL_free(ssl);
 298     }
 299     closesocket(fd);
 300     return retval;
 301 }
 302
 303 static struct ssl_stream *
 304 ssl_stream_cast(struct stream *stream)
 305 {
 306     stream_assert_class(stream, &ssl_stream_class);
 307     return CONTAINER_OF(stream, struct ssl_stream, stream);
 308 }
 309
 310 static int
 311 ssl_open(const char *name, char *suffix, struct stream **streamp, uint8_t dscp)
 312 {
 313     int error, fd;
 314
 315     error = ssl_init();
 316     if (error) {
 317         return error;
 318     }
 319
 320     error = inet_open_active(SOCK_STREAM, suffix, OFP_OLD_PORT, NULL, &fd,
 321                              dscp);
 322     if (fd >= 0) {
 323         int state = error ? STATE_TCP_CONNECTING : STATE_SSL_CONNECTING;
 324         return new_ssl_stream(name, fd, CLIENT, state, streamp);
 325     } else {
 326         VLOG_ERR("%s: connect: %s", name, ovs_strerror(error));
 327         return error;
 328     }
 329 }
 330
 331 static int
 332 do_ca_cert_bootstrap(struct stream *stream)
 333 {
 334     struct ssl_stream *sslv = ssl_stream_cast(stream);
 335     STACK_OF(X509) *chain;
 336     X509 *cert;
 337     FILE *file;
 338     int error;
 339     int fd;
 340
 341     chain = SSL_get_peer_cert_chain(sslv->ssl);
 342     if (!chain || !sk_X509_num(chain)) {
 343         VLOG_ERR("could not bootstrap CA cert: no certificate presented by "
 344                  "peer");
 345         return EPROTO;
 346     }
 347     cert = sk_X509_value(chain, sk_X509_num(chain) - 1);
 348
 349     /* Check that 'cert' is self-signed.  Otherwise it is not a CA
 350      * certificate and we should not attempt to use it as one. */
 351     error = X509_check_issued(cert, cert);
 352     if (error) {
 353         VLOG_ERR("could not bootstrap CA cert: obtained certificate is "
 354                  "not self-signed (%s)",
 355                  X509_verify_cert_error_string(error));
 356         if (sk_X509_num(chain) < 2) {
 357             VLOG_ERR("only one certificate was received, so probably the peer "
 358                      "is not configured to send its CA certificate");
 359         }
 360         return EPROTO;
 361     }
 362
 363     fd = open(ca_cert.file_name, O_CREAT | O_EXCL | O_WRONLY, 0444);
 364     if (fd < 0) {
 365         if (errno == EEXIST) {
 366             VLOG_INFO_RL(&rl, "reading CA cert %s created by another process",
 367                          ca_cert.file_name);
 368             stream_ssl_set_ca_cert_file__(ca_cert.file_name, true, true);
 369             return EPROTO;
 370         } else {
 371             VLOG_ERR("could not bootstrap CA cert: creating %s failed: %s",
 372                      ca_cert.file_name, ovs_strerror(errno));
 373             return errno;
 374         }
 375     }
 376
 377     file = fdopen(fd, "w");
 378     if (!file) {
 379         error = errno;
 380         VLOG_ERR("could not bootstrap CA cert: fdopen failed: %s",
 381                  ovs_strerror(error));
 382         unlink(ca_cert.file_name);
 383         return error;
 384     }
 385
 386     if (!PEM_write_X509(file, cert)) {
 387         VLOG_ERR("could not bootstrap CA cert: PEM_write_X509 to %s failed: "
 388                  "%s", ca_cert.file_name,
 389                  ERR_error_string(ERR_get_error(), NULL));
 390         fclose(file);
 391         unlink(ca_cert.file_name);
 392         return EIO;
 393     }
 394
 395     if (fclose(file)) {
 396         error = errno;
 397         VLOG_ERR("could not bootstrap CA cert: writing %s failed: %s",
 398                  ca_cert.file_name, ovs_strerror(error));
 399         unlink(ca_cert.file_name);
 400         return error;
 401     }
 402
 403     VLOG_INFO("successfully bootstrapped CA cert to %s", ca_cert.file_name);
 404     log_ca_cert(ca_cert.file_name, cert);
 405     bootstrap_ca_cert = false;
 406     ca_cert.read = true;
 407
 408     /* SSL_CTX_add_client_CA makes a copy of cert's relevant data. */
 409     SSL_CTX_add_client_CA(ctx, cert);
 410
 411     /* SSL_CTX_use_certificate() takes ownership of the certificate passed in.
 412      * 'cert' is owned by sslv->ssl, so we need to duplicate it. */
 413     cert = X509_dup(cert);
 414     if (!cert) {
 415         out_of_memory();
 416     }
 417     SSL_CTX_set_cert_store(ctx, X509_STORE_new());
 418     if (SSL_CTX_load_verify_locations(ctx, ca_cert.file_name, NULL) != 1) {
 419         VLOG_ERR("SSL_CTX_load_verify_locations: %s",
 420                  ERR_error_string(ERR_get_error(), NULL));
 421         return EPROTO;
 422     }
 423     VLOG_INFO("killing successful connection to retry using CA cert");
 424     return EPROTO;
 425 }
 426
 427 static int
 428 ssl_connect(struct stream *stream)
 429 {
 430     struct ssl_stream *sslv = ssl_stream_cast(stream);
 431     int retval;
 432
 433     switch (sslv->state) {
 434     case STATE_TCP_CONNECTING:
 435         retval = check_connection_completion(sslv->fd);
 436         if (retval) {
 437             return retval;
 438         }
 439         sslv->state = STATE_SSL_CONNECTING;
 440         setsockopt_tcp_nodelay(sslv->fd);
 441         /* Fall through. */
 442
 443     case STATE_SSL_CONNECTING:
 444         /* Capture the first few bytes of received data so that we can guess
 445          * what kind of funny data we've been sent if SSL negotiation fails. */
 446         if (sslv->n_head <= 0) {
 447             sslv->n_head = recv(sslv->fd, sslv->head, sizeof sslv->head,
 448                                 MSG_PEEK);
 449         }
 450
 451         retval = (sslv->type == CLIENT
 452                    ? SSL_connect(sslv->ssl) : SSL_accept(sslv->ssl));
 453         if (retval != 1) {
 454             int error = SSL_get_error(sslv->ssl, retval);
 455             if (retval < 0 && ssl_wants_io(error)) {
 456                 return EAGAIN;
 457             } else {
 458                 int unused;
 459
 460                 interpret_ssl_error((sslv->type == CLIENT ? "SSL_connect"
 461                                      : "SSL_accept"), retval, error, &unused);
 462                 shutdown(sslv->fd, SHUT_RDWR);
 463                 stream_report_content(sslv->head, sslv->n_head, STREAM_SSL,
 464                                       THIS_MODULE, stream_get_name(stream));
 465                 return EPROTO;
 466             }
 467         } else if (bootstrap_ca_cert) {
 468             return do_ca_cert_bootstrap(stream);
 469         } else if (verify_peer_cert
 470                    && ((SSL_get_verify_mode(sslv->ssl)
 471                        & (SSL_VERIFY_NONE | SSL_VERIFY_PEER))
 472                        != SSL_VERIFY_PEER)) {
 473             /* Two or more SSL connections completed at the same time while we
 474              * were in bootstrap mode.  Only one of these can finish the
 475              * bootstrap successfully.  The other one(s) must be rejected
 476              * because they were not verified against the bootstrapped CA
 477              * certificate.  (Alternatively we could verify them against the CA
 478              * certificate, but that's more trouble than it's worth.  These
 479              * connections will succeed the next time they retry, assuming that
 480              * they have a certificate against the correct CA.) */
 481             VLOG_INFO("rejecting SSL connection during bootstrap race window");
 482             return EPROTO;
 483         } else {
 484             return 0;
 485         }
 486     }
 487
 488     OVS_NOT_REACHED();
 489 }
 490
 491 static void
 492 ssl_close(struct stream *stream)
 493 {
 494     struct ssl_stream *sslv = ssl_stream_cast(stream);
 495     ssl_clear_txbuf(sslv);
 496
 497     /* Attempt clean shutdown of the SSL connection.  This will work most of
 498      * the time, as long as the kernel send buffer has some free space and the
 499      * SSL connection isn't renegotiating, etc.  That has to be good enough,
 500      * since we don't have any way to continue the close operation in the
 501      * background. */
 502     SSL_shutdown(sslv->ssl);
 503
 504     /* SSL_shutdown() might have signaled an error, in which case we need to
 505      * flush it out of the OpenSSL error queue or the next OpenSSL operation
 506      * will falsely signal an error. */
 507     ERR_clear_error();
 508
 509     SSL_free(sslv->ssl);
 510     closesocket(sslv->fd);
 511     free(sslv);
 512 }
 513
 514 static void
 515 interpret_queued_ssl_error(const char *function)
 516 {
 517     int queued_error = ERR_get_error();
 518     if (queued_error != 0) {
 519         VLOG_WARN_RL(&rl, "%s: %s",
 520                      function, ERR_error_string(queued_error, NULL));
 521     } else {
 522         VLOG_ERR_RL(&rl, "%s: SSL_ERROR_SSL without queued error", function);
 523     }
 524 }
 525
 526 static int
 527 interpret_ssl_error(const char *function, int ret, int error,
 528                     int *want)
 529 {
 530     *want = SSL_NOTHING;
 531
 532     switch (error) {
 533     case SSL_ERROR_NONE:
 534         VLOG_ERR_RL(&rl, "%s: unexpected SSL_ERROR_NONE", function);
 535         break;
 536
 537     case SSL_ERROR_ZERO_RETURN:
 538         VLOG_ERR_RL(&rl, "%s: unexpected SSL_ERROR_ZERO_RETURN", function);
 539         break;
 540
 541     case SSL_ERROR_WANT_READ:
 542         *want = SSL_READING;
 543         return EAGAIN;
 544
 545     case SSL_ERROR_WANT_WRITE:
 546         *want = SSL_WRITING;
 547         return EAGAIN;
 548
 549     case SSL_ERROR_WANT_CONNECT:
 550         VLOG_ERR_RL(&rl, "%s: unexpected SSL_ERROR_WANT_CONNECT", function);
 551         break;
 552
 553     case SSL_ERROR_WANT_ACCEPT:
 554         VLOG_ERR_RL(&rl, "%s: unexpected SSL_ERROR_WANT_ACCEPT", function);
 555         break;
 556
 557     case SSL_ERROR_WANT_X509_LOOKUP:
 558         VLOG_ERR_RL(&rl, "%s: unexpected SSL_ERROR_WANT_X509_LOOKUP",
 559                     function);
 560         break;
 561
 562     case SSL_ERROR_SYSCALL: {
 563         int queued_error = ERR_get_error();
 564         if (queued_error == 0) {
 565             if (ret < 0) {
 566                 int status = errno;
 567                 VLOG_WARN_RL(&rl, "%s: system error (%s)",
 568                              function, ovs_strerror(status));
 569                 return status;
 570             } else {
 571                 VLOG_WARN_RL(&rl, "%s: unexpected SSL connection close",
 572                              function);
 573                 return EPROTO;
 574             }
 575         } else {
 576             VLOG_WARN_RL(&rl, "%s: %s",
 577                          function, ERR_error_string(queued_error, NULL));
 578             break;
 579         }
 580     }
 581
 582     case SSL_ERROR_SSL:
 583         interpret_queued_ssl_error(function);
 584         break;
 585
 586     default:
 587         VLOG_ERR_RL(&rl, "%s: bad SSL error code %d", function, error);
 588         break;
 589     }
 590     return EIO;
 591 }
 592
 593 static ssize_t
 594 ssl_recv(struct stream *stream, void *buffer, size_t n)
 595 {
 596     struct ssl_stream *sslv = ssl_stream_cast(stream);
 597     int old_state;
 598     ssize_t ret;
 599
 600     /* Behavior of zero-byte SSL_read is poorly defined. */
 601     ovs_assert(n > 0);
 602
 603     old_state = SSL_get_state(sslv->ssl);
 604     ret = SSL_read(sslv->ssl, buffer, n);
 605     if (old_state != SSL_get_state(sslv->ssl)) {
 606         sslv->tx_want = SSL_NOTHING;
 607     }
 608     sslv->rx_want = SSL_NOTHING;
 609
 610     if (ret > 0) {
 611         return ret;
 612     } else {
 613         int error = SSL_get_error(sslv->ssl, ret);
 614         if (error == SSL_ERROR_ZERO_RETURN) {
 615             return 0;
 616         } else {
 617             return -interpret_ssl_error("SSL_read", ret, error,
 618                                         &sslv->rx_want);
 619         }
 620     }
 621 }
 622
 623 static void
 624 ssl_clear_txbuf(struct ssl_stream *sslv)
 625 {
 626     ofpbuf_delete(sslv->txbuf);
 627     sslv->txbuf = NULL;
 628 }
 629
 630 static int
 631 ssl_do_tx(struct stream *stream)
 632 {
 633     struct ssl_stream *sslv = ssl_stream_cast(stream);
 634
 635     for (;;) {
 636         int old_state = SSL_get_state(sslv->ssl);
 637         int ret = SSL_write(sslv->ssl,
 638                             ofpbuf_data(sslv->txbuf), ofpbuf_size(sslv->txbuf));
 639         if (old_state != SSL_get_state(sslv->ssl)) {
 640             sslv->rx_want = SSL_NOTHING;
 641         }
 642         sslv->tx_want = SSL_NOTHING;
 643         if (ret > 0) {
 644             ofpbuf_pull(sslv->txbuf, ret);
 645             if (ofpbuf_size(sslv->txbuf) == 0) {
 646                 return 0;
 647             }
 648         } else {
 649             int ssl_error = SSL_get_error(sslv->ssl, ret);
 650             if (ssl_error == SSL_ERROR_ZERO_RETURN) {
 651                 VLOG_WARN_RL(&rl, "SSL_write: connection closed");
 652                 return EPIPE;
 653             } else {
 654                 return interpret_ssl_error("SSL_write", ret, ssl_error,
 655                                            &sslv->tx_want);
 656             }
 657         }
 658     }
 659 }
 660
 661 static ssize_t
 662 ssl_send(struct stream *stream, const void *buffer, size_t n)
 663 {
 664     struct ssl_stream *sslv = ssl_stream_cast(stream);
 665
 666     if (sslv->txbuf) {
 667         return -EAGAIN;
 668     } else {
 669         int error;
 670
 671         sslv->txbuf = ofpbuf_clone_data(buffer, n);
 672         error = ssl_do_tx(stream);
 673         switch (error) {
 674         case 0:
 675             ssl_clear_txbuf(sslv);
 676             return n;
 677         case EAGAIN:
 678             return n;
 679         default:
 680             sslv->txbuf = NULL;
 681             return -error;
 682         }
 683     }
 684 }
 685
 686 static void
 687 ssl_run(struct stream *stream)
 688 {
 689     struct ssl_stream *sslv = ssl_stream_cast(stream);
 690
 691     if (sslv->txbuf && ssl_do_tx(stream) != EAGAIN) {
 692         ssl_clear_txbuf(sslv);
 693     }
 694 }
 695
 696 static void
 697 ssl_run_wait(struct stream *stream)
 698 {
 699     struct ssl_stream *sslv = ssl_stream_cast(stream);
 700
 701     if (sslv->tx_want != SSL_NOTHING) {
 702         poll_fd_wait(sslv->fd, want_to_poll_events(sslv->tx_want));
 703     }
 704 }
 705
 706 static void
 707 ssl_wait(struct stream *stream, enum stream_wait_type wait)
 708 {
 709     struct ssl_stream *sslv = ssl_stream_cast(stream);
 710
 711     switch (wait) {
 712     case STREAM_CONNECT:
 713         if (stream_connect(stream) != EAGAIN) {
 714             poll_immediate_wake();
 715         } else {
 716             switch (sslv->state) {
 717             case STATE_TCP_CONNECTING:
 718                 poll_fd_wait(sslv->fd, POLLOUT);
 719                 break;
 720
 721             case STATE_SSL_CONNECTING:
 722                 /* ssl_connect() called SSL_accept() or SSL_connect(), which
 723                  * set up the status that we test here. */
 724                 poll_fd_wait(sslv->fd,
 725                                want_to_poll_events(SSL_want(sslv->ssl)));
 726                 break;
 727
 728             default:
 729                 OVS_NOT_REACHED();
 730             }
 731         }
 732         break;
 733
 734     case STREAM_RECV:
 735         if (sslv->rx_want != SSL_NOTHING) {
 736             poll_fd_wait(sslv->fd, want_to_poll_events(sslv->rx_want));
 737         } else {
 738             poll_immediate_wake();
 739         }
 740         break;
 741
 742     case STREAM_SEND:
 743         if (!sslv->txbuf) {
 744             /* We have room in our tx queue. */
 745             poll_immediate_wake();
 746         } else {
 747             /* stream_run_wait() will do the right thing; don't bother with
 748              * redundancy. */
 749         }
 750         break;
 751
 752     default:
 753         OVS_NOT_REACHED();
 754     }
 755 }
 756
 757 const struct stream_class ssl_stream_class = {
 758     "ssl",                      /* name */
 759     true,                       /* needs_probes */
 760     ssl_open,                   /* open */
 761     ssl_close,                  /* close */
 762     ssl_connect,                /* connect */
 763     ssl_recv,                   /* recv */
 764     ssl_send,                   /* send */
 765     ssl_run,                    /* run */
 766     ssl_run_wait,               /* run_wait */
 767     ssl_wait,                   /* wait */
 768 };
 769 \f
 770 /* Passive SSL. */
 771
 772 struct pssl_pstream
 773 {
 774     struct pstream pstream;
 775     int fd;
 776 };
 777
 778 const struct pstream_class pssl_pstream_class;
 779
 780 static struct pssl_pstream *
 781 pssl_pstream_cast(struct pstream *pstream)
 782 {
 783     pstream_assert_class(pstream, &pssl_pstream_class);
 784     return CONTAINER_OF(pstream, struct pssl_pstream, pstream);
 785 }
 786
 787 static int
 788 pssl_open(const char *name OVS_UNUSED, char *suffix, struct pstream **pstreamp,
 789           uint8_t dscp)
 790 {
 791     char bound_name[SS_NTOP_BUFSIZE + 16];
 792     char addrbuf[SS_NTOP_BUFSIZE];
 793     struct sockaddr_storage ss;
 794     struct pssl_pstream *pssl;
 795     uint16_t port;
 796     int retval;
 797     int fd;
 798
 799     retval = ssl_init();
 800     if (retval) {
 801         return retval;
 802     }
 803
 804     fd = inet_open_passive(SOCK_STREAM, suffix, OFP_OLD_PORT, &ss, dscp, true);
 805     if (fd < 0) {
 806         return -fd;
 807     }
 808
 809     port = ss_get_port(&ss);
 810     snprintf(bound_name, sizeof bound_name, "ptcp:%"PRIu16":%s",
 811              port, ss_format_address(&ss, addrbuf, sizeof addrbuf));
 812
 813     pssl = xmalloc(sizeof *pssl);
 814     pstream_init(&pssl->pstream, &pssl_pstream_class, bound_name);
 815     pstream_set_bound_port(&pssl->pstream, htons(port));
 816     pssl->fd = fd;
 817     *pstreamp = &pssl->pstream;
 818     return 0;
 819 }
 820
 821 static void
 822 pssl_close(struct pstream *pstream)
 823 {
 824     struct pssl_pstream *pssl = pssl_pstream_cast(pstream);
 825     closesocket(pssl->fd);
 826     free(pssl);
 827 }
 828
 829 static int
 830 pssl_accept(struct pstream *pstream, struct stream **new_streamp)
 831 {
 832     struct pssl_pstream *pssl = pssl_pstream_cast(pstream);
 833     char name[SS_NTOP_BUFSIZE + 16];
 834     char addrbuf[SS_NTOP_BUFSIZE];
 835     struct sockaddr_storage ss;
 836     socklen_t ss_len = sizeof ss;
 837     int new_fd;
 838     int error;
 839
 840     new_fd = accept(pssl->fd, (struct sockaddr *) &ss, &ss_len);
 841     if (new_fd < 0) {
 842         error = sock_errno();
 843 #ifdef _WIN32
 844         if (error == WSAEWOULDBLOCK) {
 845             error = EAGAIN;
 846         }
 847 #endif
 848         if (error != EAGAIN) {
 849             VLOG_DBG_RL(&rl, "accept: %s", sock_strerror(error));
 850         }
 851         return error;
 852     }
 853
 854     error = set_nonblocking(new_fd);
 855     if (error) {
 856         closesocket(new_fd);
 857         return error;
 858     }
 859
 860     snprintf(name, sizeof name, "tcp:%s:%"PRIu16,
 861              ss_format_address(&ss, addrbuf, sizeof addrbuf),
 862              ss_get_port(&ss));
 863     return new_ssl_stream(name, new_fd, SERVER, STATE_SSL_CONNECTING,
 864                           new_streamp);
 865 }
 866
 867 static void
 868 pssl_wait(struct pstream *pstream)
 869 {
 870     struct pssl_pstream *pssl = pssl_pstream_cast(pstream);
 871     poll_fd_wait(pssl->fd, POLLIN);
 872 }
 873
 874 const struct pstream_class pssl_pstream_class = {
 875     "pssl",
 876     true,
 877     pssl_open,
 878     pssl_close,
 879     pssl_accept,
 880     pssl_wait,
 881 };
 882 \f
 883 /*
 884  * Returns true if OpenSSL error is WANT_READ or WANT_WRITE, indicating that
 885  * OpenSSL is requesting that we call it back when the socket is ready for read
 886  * or writing, respectively.
 887  */
 888 static bool
 889 ssl_wants_io(int ssl_error)
 890 {
 891     return (ssl_error == SSL_ERROR_WANT_WRITE
 892             || ssl_error == SSL_ERROR_WANT_READ);
 893 }
 894
 895 static int
 896 ssl_init(void)
 897 {
 898     static int init_status = -1;
 899     if (init_status < 0) {
 900         init_status = do_ssl_init();
 901         ovs_assert(init_status >= 0);
 902     }
 903     return init_status;
 904 }
 905
 906 static int
 907 do_ssl_init(void)
 908 {
 909     SSL_METHOD *method;
 910
 911 #ifdef _WIN32
 912     /* The following call is needed if we "#include <openssl/applink.c>". */
 913     CRYPTO_malloc_init();
 914 #endif
 915     SSL_library_init();
 916     SSL_load_error_strings();
 917
 918     if (!RAND_status()) {
 919         /* We occasionally see OpenSSL fail to seed its random number generator
 920          * in heavily loaded hypervisors.  I suspect the following scenario:
 921          *
 922          * 1. OpenSSL calls read() to get 32 bytes from /dev/urandom.
 923          * 2. The kernel generates 10 bytes of randomness and copies it out.
 924          * 3. A signal arrives (perhaps SIGALRM).
 925          * 4. The kernel interrupts the system call to service the signal.
 926          * 5. Userspace gets 10 bytes of entropy.
 927          * 6. OpenSSL doesn't read again to get the final 22 bytes.  Therefore
 928          *    OpenSSL doesn't have enough entropy to consider itself
 929          *    initialized.
 930          *
 931          * The only part I'm not entirely sure about is #6, because the OpenSSL
 932          * code is so hard to read. */
 933         uint8_t seed[32];
 934         int retval;
 935
 936         VLOG_WARN("OpenSSL random seeding failed, reseeding ourselves");
 937
 938         retval = get_entropy(seed, sizeof seed);
 939         if (retval) {
 940             VLOG_ERR("failed to obtain entropy (%s)",
 941                      ovs_retval_to_string(retval));
 942             return retval > 0 ? retval : ENOPROTOOPT;
 943         }
 944
 945         RAND_seed(seed, sizeof seed);
 946     }
 947
 948     /* OpenSSL has a bunch of "connection methods": SSLv2_method(),
 949      * SSLv3_method(), TLSv1_method(), SSLv23_method(), ...  Most of these
 950      * support exactly one version of SSL, e.g. TLSv1_method() supports TLSv1
 951      * only, not any earlier *or later* version.  The only exception is
 952      * SSLv23_method(), which in fact supports *any* version of SSL and TLS.
 953      * We don't want SSLv2 or SSLv3 support, so we turn it off below with
 954      * SSL_CTX_set_options().
 955      *
 956      * The cast is needed to avoid a warning with newer versions of OpenSSL in
 957      * which SSLv23_method() returns a "const" pointer. */
 958     method = CONST_CAST(SSL_METHOD *, SSLv23_method());
 959     if (method == NULL) {
 960         VLOG_ERR("TLSv1_method: %s", ERR_error_string(ERR_get_error(), NULL));
 961         return ENOPROTOOPT;
 962     }
 963
 964     ctx = SSL_CTX_new(method);
 965     if (ctx == NULL) {
 966         VLOG_ERR("SSL_CTX_new: %s", ERR_error_string(ERR_get_error(), NULL));
 967         return ENOPROTOOPT;
 968     }
 969     SSL_CTX_set_options(ctx, SSL_OP_NO_SSLv2 | SSL_OP_NO_SSLv3);
 970     SSL_CTX_set_tmp_dh_callback(ctx, tmp_dh_callback);
 971     SSL_CTX_set_mode(ctx, SSL_MODE_ENABLE_PARTIAL_WRITE);
 972     SSL_CTX_set_mode(ctx, SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER);
 973     SSL_CTX_set_verify(ctx, SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT,
 974                        NULL);
 975
 976     return 0;
 977 }
 978
 979 static DH *
 980 tmp_dh_callback(SSL *ssl OVS_UNUSED, int is_export OVS_UNUSED, int keylength)
 981 {
 982     struct dh {
 983         int keylength;
 984         DH *dh;
 985         DH *(*constructor)(void);
 986     };
 987
 988     static struct dh dh_table[] = {
 989         {1024, NULL, get_dh1024},
 990         {2048, NULL, get_dh2048},
 991         {4096, NULL, get_dh4096},
 992     };
 993
 994     struct dh *dh;
 995
 996     for (dh = dh_table; dh < &dh_table[ARRAY_SIZE(dh_table)]; dh++) {
 997         if (dh->keylength == keylength) {
 998             if (!dh->dh) {
 999                 dh->dh = dh->constructor();
1000                 if (!dh->dh) {
1001                     out_of_memory();
1002                 }
1003             }
1004             return dh->dh;
1005         }
1006     }
1007     VLOG_ERR_RL(&rl, "no Diffie-Hellman parameters for key length %d",
1008                 keylength);
1009     return NULL;
1010 }
1011
1012 /* Returns true if SSL is at least partially configured. */
1013 bool
1014 stream_ssl_is_configured(void)
1015 {
1016     return private_key.file_name || certificate.file_name || ca_cert.file_name;
1017 }
1018
1019 static bool
1020 update_ssl_config(struct ssl_config_file *config, const char *file_name)
1021 {
1022     struct timespec mtime;
1023     int error;
1024
1025     if (ssl_init() || !file_name) {
1026         return false;
1027     }
1028
1029     /* If the file name hasn't changed and neither has the file contents, stop
1030      * here. */
1031     error = get_mtime(file_name, &mtime);
1032     if (error && error != ENOENT) {
1033         VLOG_ERR_RL(&rl, "%s: stat failed (%s)",
1034                     file_name, ovs_strerror(error));
1035     }
1036     if (config->file_name
1037         && !strcmp(config->file_name, file_name)
1038         && mtime.tv_sec == config->mtime.tv_sec
1039         && mtime.tv_nsec == config->mtime.tv_nsec) {
1040         return false;
1041     }
1042
1043     /* Update 'config'. */
1044     config->mtime = mtime;
1045     if (file_name != config->file_name) {
1046         free(config->file_name);
1047         config->file_name = xstrdup(file_name);
1048     }
1049     return true;
1050 }
1051
1052 static void
1053 stream_ssl_set_private_key_file__(const char *file_name)
1054 {
1055     if (SSL_CTX_use_PrivateKey_file(ctx, file_name, SSL_FILETYPE_PEM) == 1) {
1056         private_key.read = true;
1057     } else {
1058         VLOG_ERR("SSL_use_PrivateKey_file: %s",
1059                  ERR_error_string(ERR_get_error(), NULL));
1060     }
1061 }
1062
1063 void
1064 stream_ssl_set_private_key_file(const char *file_name)
1065 {
1066     if (update_ssl_config(&private_key, file_name)) {
1067         stream_ssl_set_private_key_file__(file_name);
1068     }
1069 }
1070
1071 static void
1072 stream_ssl_set_certificate_file__(const char *file_name)
1073 {
1074     if (SSL_CTX_use_certificate_chain_file(ctx, file_name) == 1) {
1075         certificate.read = true;
1076     } else {
1077         VLOG_ERR("SSL_use_certificate_file: %s",
1078                  ERR_error_string(ERR_get_error(), NULL));
1079     }
1080 }
1081
1082 void
1083 stream_ssl_set_certificate_file(const char *file_name)
1084 {
1085     if (update_ssl_config(&certificate, file_name)) {
1086         stream_ssl_set_certificate_file__(file_name);
1087     }
1088 }
1089
1090 /* Sets the private key and certificate files in one operation.  Use this
1091  * interface, instead of calling stream_ssl_set_private_key_file() and
1092  * stream_ssl_set_certificate_file() individually, in the main loop of a
1093  * long-running program whose key and certificate might change at runtime.
1094  *
1095  * This is important because of OpenSSL's behavior.  If an OpenSSL context
1096  * already has a certificate, and stream_ssl_set_private_key_file() is called
1097  * to install a new private key, OpenSSL will report an error because the new
1098  * private key does not match the old certificate.  The other order, of setting
1099  * a new certificate, then setting a new private key, does work.
1100  *
1101  * If this were the only problem, calling stream_ssl_set_certificate_file()
1102  * before stream_ssl_set_private_key_file() would fix it.  But, if the private
1103  * key is changed before the certificate (e.g. someone "scp"s or "mv"s the new
1104  * private key in place before the certificate), then OpenSSL would reject that
1105  * change, and then the change of certificate would succeed, but there would be
1106  * no associated private key (because it had only changed once and therefore
1107  * there was no point in re-reading it).
1108  *
1109  * This function avoids both problems by, whenever either the certificate or
1110  * the private key file changes, re-reading both of them, in the correct order.
1111  */
1112 void
1113 stream_ssl_set_key_and_cert(const char *private_key_file,
1114                             const char *certificate_file)
1115 {
1116     if (update_ssl_config(&private_key, private_key_file)
1117         || update_ssl_config(&certificate, certificate_file)) {
1118         stream_ssl_set_certificate_file__(certificate_file);
1119         stream_ssl_set_private_key_file__(private_key_file);
1120     }
1121 }
1122
1123 /* Reads the X509 certificate or certificates in file 'file_name'.  On success,
1124  * stores the address of the first element in an array of pointers to
1125  * certificates in '*certs' and the number of certificates in the array in
1126  * '*n_certs', and returns 0.  On failure, stores a null pointer in '*certs', 0
1127  * in '*n_certs', and returns a positive errno value.
1128  *
1129  * The caller is responsible for freeing '*certs'. */
1130 static int
1131 read_cert_file(const char *file_name, X509 ***certs, size_t *n_certs)
1132 {
1133     FILE *file;
1134     size_t allocated_certs = 0;
1135
1136     *certs = NULL;
1137     *n_certs = 0;
1138
1139     file = fopen(file_name, "r");
1140     if (!file) {
1141         VLOG_ERR("failed to open %s for reading: %s",
1142                  file_name, ovs_strerror(errno));
1143         return errno;
1144     }
1145
1146     for (;;) {
1147         X509 *certificate;
1148         int c;
1149
1150         /* Read certificate from file. */
1151         certificate = PEM_read_X509(file, NULL, NULL, NULL);
1152         if (!certificate) {
1153             size_t i;
1154
1155             VLOG_ERR("PEM_read_X509 failed reading %s: %s",
1156                      file_name, ERR_error_string(ERR_get_error(), NULL));
1157             for (i = 0; i < *n_certs; i++) {
1158                 X509_free((*certs)[i]);
1159             }
1160             free(*certs);
1161             *certs = NULL;
1162             *n_certs = 0;
1163             fclose(file);
1164             return EIO;
1165         }
1166
1167         /* Add certificate to array. */
1168         if (*n_certs >= allocated_certs) {
1169             *certs = x2nrealloc(*certs, &allocated_certs, sizeof **certs);
1170         }
1171         (*certs)[(*n_certs)++] = certificate;
1172
1173         /* Are there additional certificates in the file? */
1174         do {
1175             c = getc(file);
1176         } while (isspace(c));
1177         if (c == EOF) {
1178             break;
1179         }
1180         ungetc(c, file);
1181     }
1182     fclose(file);
1183     return 0;
1184 }
1185
1186
1187 /* Sets 'file_name' as the name of a file containing one or more X509
1188  * certificates to send to the peer.  Typical use in OpenFlow is to send the CA
1189  * certificate to the peer, which enables a switch to pick up the controller's
1190  * CA certificate on its first connection. */
1191 void
1192 stream_ssl_set_peer_ca_cert_file(const char *file_name)
1193 {
1194     X509 **certs;
1195     size_t n_certs;
1196     size_t i;
1197
1198     if (ssl_init()) {
1199         return;
1200     }
1201
1202     if (!read_cert_file(file_name, &certs, &n_certs)) {
1203         for (i = 0; i < n_certs; i++) {
1204             if (SSL_CTX_add_extra_chain_cert(ctx, certs[i]) != 1) {
1205                 VLOG_ERR("SSL_CTX_add_extra_chain_cert: %s",
1206                          ERR_error_string(ERR_get_error(), NULL));
1207             }
1208         }
1209         free(certs);
1210     }
1211 }
1212
1213 /* Logs fingerprint of CA certificate 'cert' obtained from 'file_name'. */
1214 static void
1215 log_ca_cert(const char *file_name, X509 *cert)
1216 {
1217     unsigned char digest[EVP_MAX_MD_SIZE];
1218     unsigned int n_bytes;
1219     struct ds fp;
1220     char *subject;
1221
1222     ds_init(&fp);
1223     if (!X509_digest(cert, EVP_sha1(), digest, &n_bytes)) {
1224         ds_put_cstr(&fp, "<out of memory>");
1225     } else {
1226         unsigned int i;
1227         for (i = 0; i < n_bytes; i++) {
1228             if (i) {
1229                 ds_put_char(&fp, ':');
1230             }
1231             ds_put_format(&fp, "%02x", digest[i]);
1232         }
1233     }
1234     subject = X509_NAME_oneline(X509_get_subject_name(cert), NULL, 0);
1235     VLOG_INFO("Trusting CA cert from %s (%s) (fingerprint %s)", file_name,
1236               subject ? subject : "<out of memory>", ds_cstr(&fp));
1237     OPENSSL_free(subject);
1238     ds_destroy(&fp);
1239 }
1240
1241 static void
1242 stream_ssl_set_ca_cert_file__(const char *file_name,
1243                               bool bootstrap, bool force)
1244 {
1245     X509 **certs;
1246     size_t n_certs;
1247     struct stat s;
1248
1249     if (!update_ssl_config(&ca_cert, file_name) && !force) {
1250         return;
1251     }
1252
1253     if (!strcmp(file_name, "none")) {
1254         verify_peer_cert = false;
1255         VLOG_WARN("Peer certificate validation disabled "
1256                   "(this is a security risk)");
1257     } else if (bootstrap && stat(file_name, &s) && errno == ENOENT) {
1258         bootstrap_ca_cert = true;
1259     } else if (!read_cert_file(file_name, &certs, &n_certs)) {
1260         size_t i;
1261
1262         /* Set up list of CAs that the server will accept from the client. */
1263         for (i = 0; i < n_certs; i++) {
1264             /* SSL_CTX_add_client_CA makes a copy of the relevant data. */
1265             if (SSL_CTX_add_client_CA(ctx, certs[i]) != 1) {
1266                 VLOG_ERR("failed to add client certificate %"PRIuSIZE" from %s: %s",
1267                          i, file_name,
1268                          ERR_error_string(ERR_get_error(), NULL));
1269             } else {
1270                 log_ca_cert(file_name, certs[i]);
1271             }
1272             X509_free(certs[i]);
1273         }
1274         free(certs);
1275
1276         /* Set up CAs for OpenSSL to trust in verifying the peer's
1277          * certificate. */
1278         SSL_CTX_set_cert_store(ctx, X509_STORE_new());
1279         if (SSL_CTX_load_verify_locations(ctx, file_name, NULL) != 1) {
1280             VLOG_ERR("SSL_CTX_load_verify_locations: %s",
1281                      ERR_error_string(ERR_get_error(), NULL));
1282             return;
1283         }
1284
1285         bootstrap_ca_cert = false;
1286     }
1287     ca_cert.read = true;
1288 }
1289
1290 /* Sets 'file_name' as the name of the file from which to read the CA
1291  * certificate used to verify the peer within SSL connections.  If 'bootstrap'
1292  * is false, the file must exist.  If 'bootstrap' is false, then the file is
1293  * read if it is exists; if it does not, then it will be created from the CA
1294  * certificate received from the peer on the first SSL connection. */
1295 void
1296 stream_ssl_set_ca_cert_file(const char *file_name, bool bootstrap)
1297 {
1298     stream_ssl_set_ca_cert_file__(file_name, bootstrap, false);
1299 }
1300 \f
1301 /* SSL protocol logging. */
1302
1303 static const char *
1304 ssl_alert_level_to_string(uint8_t type)
1305 {
1306     switch (type) {
1307     case 1: return "warning";
1308     case 2: return "fatal";
1309     default: return "<unknown>";
1310     }
1311 }
1312
1313 static const char *
1314 ssl_alert_description_to_string(uint8_t type)
1315 {
1316     switch (type) {
1317     case 0: return "close_notify";
1318     case 10: return "unexpected_message";
1319     case 20: return "bad_record_mac";
1320     case 21: return "decryption_failed";
1321     case 22: return "record_overflow";
1322     case 30: return "decompression_failure";
1323     case 40: return "handshake_failure";
1324     case 42: return "bad_certificate";
1325     case 43: return "unsupported_certificate";
1326     case 44: return "certificate_revoked";
1327     case 45: return "certificate_expired";
1328     case 46: return "certificate_unknown";
1329     case 47: return "illegal_parameter";
1330     case 48: return "unknown_ca";
1331     case 49: return "access_denied";
1332     case 50: return "decode_error";
1333     case 51: return "decrypt_error";
1334     case 60: return "export_restriction";
1335     case 70: return "protocol_version";
1336     case 71: return "insufficient_security";
1337     case 80: return "internal_error";
1338     case 90: return "user_canceled";
1339     case 100: return "no_renegotiation";
1340     default: return "<unknown>";
1341     }
1342 }
1343
1344 static const char *
1345 ssl_handshake_type_to_string(uint8_t type)
1346 {
1347     switch (type) {
1348     case 0: return "hello_request";
1349     case 1: return "client_hello";
1350     case 2: return "server_hello";
1351     case 11: return "certificate";
1352     case 12: return "server_key_exchange";
1353     case 13: return "certificate_request";
1354     case 14: return "server_hello_done";
1355     case 15: return "certificate_verify";
1356     case 16: return "client_key_exchange";
1357     case 20: return "finished";
1358     default: return "<unknown>";
1359     }
1360 }
1361
1362 static void
1363 ssl_protocol_cb(int write_p, int version OVS_UNUSED, int content_type,
1364                 const void *buf_, size_t len, SSL *ssl OVS_UNUSED, void *sslv_)
1365 {
1366     const struct ssl_stream *sslv = sslv_;
1367     const uint8_t *buf = buf_;
1368     struct ds details;
1369
1370     if (!VLOG_IS_DBG_ENABLED()) {
1371         return;
1372     }
1373
1374     ds_init(&details);
1375     if (content_type == 20) {
1376         ds_put_cstr(&details, "change_cipher_spec");
1377     } else if (content_type == 21) {
1378         ds_put_format(&details, "alert: %s, %s",
1379                       ssl_alert_level_to_string(buf[0]),
1380                       ssl_alert_description_to_string(buf[1]));
1381     } else if (content_type == 22) {
1382         ds_put_format(&details, "handshake: %s",
1383                       ssl_handshake_type_to_string(buf[0]));
1384     } else {
1385         ds_put_format(&details, "type %d", content_type);
1386     }
1387
1388     VLOG_DBG("%s%u%s%s %s (%"PRIuSIZE" bytes)",
1389              sslv->type == CLIENT ? "client" : "server",
1390              sslv->session_nr, write_p ? "-->" : "<--",
1391              stream_get_name(&sslv->stream), ds_cstr(&details), len);
1392
1393     ds_destroy(&details);
1394 }