lib/stream-ssl.c

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