lib/stream-ssl.c

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