X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=lib%2Fstream-ssl.c;h=7a0d2189a73f29d92c614ecf1b0bf6bdb7fd649b;hb=HEAD;hp=ad572d3523c7a77d337498ab14a620e6dfbde90f;hpb=f1936eb65178f796d26a8d265697af8c19dce8cd;p=sliver-openvswitch.git diff --git a/lib/stream-ssl.c b/lib/stream-ssl.c index ad572d352..7a0d2189a 100644 --- a/lib/stream-ssl.c +++ b/lib/stream-ssl.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2008, 2009, 2010, 2011 Nicira Networks. + * Copyright (c) 2008, 2009, 2010, 2011, 2012, 2013, 2014 Nicira, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -17,7 +17,6 @@ #include #include "stream-ssl.h" #include "dhparams.h" -#include #include #include #include @@ -26,15 +25,16 @@ #include #include #include +#include #include #include #include -#include +#include #include #include #include "coverage.h" #include "dynamic-string.h" -#include "leak-checker.h" +#include "entropy.h" #include "ofpbuf.h" #include "openflow/openflow.h" #include "packets.h" @@ -47,6 +47,21 @@ #include "timeval.h" #include "vlog.h" +#ifdef _WIN32 +/* Ref: https://www.openssl.org/support/faq.html#PROG2 + * Your application must link against the same version of the Win32 C-Runtime + * against which your openssl libraries were linked. The default version for + * OpenSSL is /MD - "Multithreaded DLL". If we compile Open vSwitch with + * something other than /MD, instead of re-compiling OpenSSL + * toolkit, openssl/applink.c can be #included. Also, it is important + * to add CRYPTO_malloc_init prior first call to OpenSSL. + * + * XXX: The behavior of the following #include when Open vSwitch is + * compiled with /MD is not tested. */ +#include +#define SHUT_RDWR SD_BOTH +#endif + VLOG_DEFINE_THIS_MODULE(stream_ssl); /* Active SSL. */ @@ -67,6 +82,7 @@ struct ssl_stream enum ssl_state state; enum session_type type; int fd; + HANDLE wevent; SSL *ssl; struct ofpbuf *txbuf; unsigned int session_nr; @@ -183,13 +199,15 @@ static void stream_ssl_set_ca_cert_file__(const char *file_name, static void ssl_protocol_cb(int write_p, int version, int content_type, const void *, size_t, SSL *, void *sslv_); static bool update_ssl_config(struct ssl_config_file *, const char *file_name); +static int sock_errno(void); +static void clear_handle(int fd, HANDLE wevent); static short int want_to_poll_events(int want) { switch (want) { case SSL_NOTHING: - NOT_REACHED(); + OVS_NOT_REACHED(); case SSL_READING: return POLLIN; @@ -198,16 +216,15 @@ want_to_poll_events(int want) return POLLOUT; default: - NOT_REACHED(); + OVS_NOT_REACHED(); } } static int new_ssl_stream(const char *name, int fd, enum session_type type, - enum ssl_state state, const struct sockaddr_in *remote, - struct stream **streamp) + enum ssl_state state, struct stream **streamp) { - struct sockaddr_in local; + struct sockaddr_storage local; socklen_t local_len = sizeof local; struct ssl_stream *sslv; SSL *ssl = NULL; @@ -228,7 +245,7 @@ new_ssl_stream(const char *name, int fd, enum session_type type, VLOG_ERR("CA certificate must be configured to use SSL"); retval = ENOPROTOOPT; } - if (!SSL_CTX_check_private_key(ctx)) { + if (!retval && !SSL_CTX_check_private_key(ctx)) { VLOG_ERR("Private key does not match certificate public key: %s", ERR_error_string(ERR_get_error(), NULL)); retval = ENOPROTOOPT; @@ -246,8 +263,9 @@ new_ssl_stream(const char *name, int fd, enum session_type type, /* Disable Nagle. */ retval = setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &on, sizeof on); if (retval) { - VLOG_ERR("%s: setsockopt(TCP_NODELAY): %s", name, strerror(errno)); - retval = errno; + retval = sock_errno(); + VLOG_ERR("%s: setsockopt(TCP_NODELAY): %s", name, + sock_strerror(retval)); goto error; } @@ -270,13 +288,12 @@ new_ssl_stream(const char *name, int fd, enum session_type type, /* Create and return the ssl_stream. */ sslv = xmalloc(sizeof *sslv); stream_init(&sslv->stream, &ssl_stream_class, EAGAIN, name); - stream_set_remote_ip(&sslv->stream, remote->sin_addr.s_addr); - stream_set_remote_port(&sslv->stream, remote->sin_port); - stream_set_local_ip(&sslv->stream, local.sin_addr.s_addr); - stream_set_local_port(&sslv->stream, local.sin_port); sslv->state = state; sslv->type = type; sslv->fd = fd; +#ifdef _WIN32 + sslv->wevent = CreateEvent(NULL, FALSE, FALSE, NULL); +#endif sslv->ssl = ssl; sslv->txbuf = NULL; sslv->rx_want = sslv->tx_want = SSL_NOTHING; @@ -295,7 +312,7 @@ error: if (ssl) { SSL_free(ssl); } - close(fd); + closesocket(fd); return retval; } @@ -309,7 +326,6 @@ ssl_stream_cast(struct stream *stream) static int ssl_open(const char *name, char *suffix, struct stream **streamp, uint8_t dscp) { - struct sockaddr_in sin; int error, fd; error = ssl_init(); @@ -317,13 +333,13 @@ ssl_open(const char *name, char *suffix, struct stream **streamp, uint8_t dscp) return error; } - error = inet_open_active(SOCK_STREAM, suffix, OFP_SSL_PORT, &sin, &fd, + error = inet_open_active(SOCK_STREAM, suffix, OFP_OLD_PORT, NULL, &fd, dscp); if (fd >= 0) { int state = error ? STATE_TCP_CONNECTING : STATE_SSL_CONNECTING; - return new_ssl_stream(name, fd, CLIENT, state, &sin, streamp); + return new_ssl_stream(name, fd, CLIENT, state, streamp); } else { - VLOG_ERR("%s: connect: %s", name, strerror(error)); + VLOG_ERR("%s: connect: %s", name, ovs_strerror(error)); return error; } } @@ -369,7 +385,7 @@ do_ca_cert_bootstrap(struct stream *stream) return EPROTO; } else { VLOG_ERR("could not bootstrap CA cert: creating %s failed: %s", - ca_cert.file_name, strerror(errno)); + ca_cert.file_name, ovs_strerror(errno)); return errno; } } @@ -378,7 +394,7 @@ do_ca_cert_bootstrap(struct stream *stream) if (!file) { error = errno; VLOG_ERR("could not bootstrap CA cert: fdopen failed: %s", - strerror(error)); + ovs_strerror(error)); unlink(ca_cert.file_name); return error; } @@ -395,7 +411,7 @@ do_ca_cert_bootstrap(struct stream *stream) if (fclose(file)) { error = errno; VLOG_ERR("could not bootstrap CA cert: writing %s failed: %s", - ca_cert.file_name, strerror(error)); + ca_cert.file_name, ovs_strerror(error)); unlink(ca_cert.file_name); return error; } @@ -441,7 +457,7 @@ ssl_connect(struct stream *stream) case STATE_SSL_CONNECTING: /* Capture the first few bytes of received data so that we can guess - * what kind of funny data we've been sent if SSL negotation fails. */ + * what kind of funny data we've been sent if SSL negotiation fails. */ if (sslv->n_head <= 0) { sslv->n_head = recv(sslv->fd, sslv->head, sizeof sslv->head, MSG_PEEK); @@ -477,14 +493,14 @@ ssl_connect(struct stream *stream) * certificate, but that's more trouble than it's worth. These * connections will succeed the next time they retry, assuming that * they have a certificate against the correct CA.) */ - VLOG_ERR("rejecting SSL connection during bootstrap race window"); + VLOG_INFO("rejecting SSL connection during bootstrap race window"); return EPROTO; } else { return 0; } } - NOT_REACHED(); + OVS_NOT_REACHED(); } static void @@ -506,7 +522,8 @@ ssl_close(struct stream *stream) ERR_clear_error(); SSL_free(sslv->ssl); - close(sslv->fd); + clear_handle(sslv->fd, sslv->wevent); + closesocket(sslv->fd); free(sslv); } @@ -564,7 +581,7 @@ interpret_ssl_error(const char *function, int ret, int error, if (ret < 0) { int status = errno; VLOG_WARN_RL(&rl, "%s: system error (%s)", - function, strerror(status)); + function, ovs_strerror(status)); return status; } else { VLOG_WARN_RL(&rl, "%s: unexpected SSL connection close", @@ -597,7 +614,7 @@ ssl_recv(struct stream *stream, void *buffer, size_t n) ssize_t ret; /* Behavior of zero-byte SSL_read is poorly defined. */ - assert(n > 0); + ovs_assert(n > 0); old_state = SSL_get_state(sslv->ssl); ret = SSL_read(sslv->ssl, buffer, n); @@ -633,14 +650,15 @@ ssl_do_tx(struct stream *stream) for (;;) { int old_state = SSL_get_state(sslv->ssl); - int ret = SSL_write(sslv->ssl, sslv->txbuf->data, sslv->txbuf->size); + int ret = SSL_write(sslv->ssl, + ofpbuf_data(sslv->txbuf), ofpbuf_size(sslv->txbuf)); if (old_state != SSL_get_state(sslv->ssl)) { sslv->rx_want = SSL_NOTHING; } sslv->tx_want = SSL_NOTHING; if (ret > 0) { ofpbuf_pull(sslv->txbuf, ret); - if (sslv->txbuf->size == 0) { + if (ofpbuf_size(sslv->txbuf) == 0) { return 0; } } else { @@ -673,7 +691,6 @@ ssl_send(struct stream *stream, const void *buffer, size_t n) ssl_clear_txbuf(sslv); return n; case EAGAIN: - leak_checker_claim(buffer); return n; default: sslv->txbuf = NULL; @@ -698,7 +715,8 @@ ssl_run_wait(struct stream *stream) struct ssl_stream *sslv = ssl_stream_cast(stream); if (sslv->tx_want != SSL_NOTHING) { - poll_fd_wait(sslv->fd, want_to_poll_events(sslv->tx_want)); + poll_fd_wait_event(sslv->fd, sslv->wevent, + want_to_poll_events(sslv->tx_want)); } } @@ -714,25 +732,26 @@ ssl_wait(struct stream *stream, enum stream_wait_type wait) } else { switch (sslv->state) { case STATE_TCP_CONNECTING: - poll_fd_wait(sslv->fd, POLLOUT); + poll_fd_wait_event(sslv->fd, sslv->wevent, POLLOUT); break; case STATE_SSL_CONNECTING: /* ssl_connect() called SSL_accept() or SSL_connect(), which * set up the status that we test here. */ - poll_fd_wait(sslv->fd, - want_to_poll_events(SSL_want(sslv->ssl))); + poll_fd_wait_event(sslv->fd, sslv->wevent, + want_to_poll_events(SSL_want(sslv->ssl))); break; default: - NOT_REACHED(); + OVS_NOT_REACHED(); } } break; case STREAM_RECV: if (sslv->rx_want != SSL_NOTHING) { - poll_fd_wait(sslv->fd, want_to_poll_events(sslv->rx_want)); + poll_fd_wait_event(sslv->fd, sslv->wevent, + want_to_poll_events(sslv->rx_want)); } else { poll_immediate_wake(); } @@ -749,7 +768,7 @@ ssl_wait(struct stream *stream, enum stream_wait_type wait) break; default: - NOT_REACHED(); + OVS_NOT_REACHED(); } } @@ -772,6 +791,7 @@ struct pssl_pstream { struct pstream pstream; int fd; + HANDLE wevent; }; const struct pstream_class pssl_pstream_class; @@ -787,9 +807,11 @@ static int pssl_open(const char *name OVS_UNUSED, char *suffix, struct pstream **pstreamp, uint8_t dscp) { + char bound_name[SS_NTOP_BUFSIZE + 16]; + char addrbuf[SS_NTOP_BUFSIZE]; + struct sockaddr_storage ss; struct pssl_pstream *pssl; - struct sockaddr_in sin; - char bound_name[128]; + uint16_t port; int retval; int fd; @@ -798,16 +820,22 @@ pssl_open(const char *name OVS_UNUSED, char *suffix, struct pstream **pstreamp, return retval; } - fd = inet_open_passive(SOCK_STREAM, suffix, OFP_SSL_PORT, &sin, dscp); + fd = inet_open_passive(SOCK_STREAM, suffix, OFP_OLD_PORT, &ss, dscp); if (fd < 0) { return -fd; } - sprintf(bound_name, "pssl:%"PRIu16":"IP_FMT, - ntohs(sin.sin_port), IP_ARGS(&sin.sin_addr.s_addr)); + + port = ss_get_port(&ss); + snprintf(bound_name, sizeof bound_name, "ptcp:%"PRIu16":%s", + port, ss_format_address(&ss, addrbuf, sizeof addrbuf)); pssl = xmalloc(sizeof *pssl); pstream_init(&pssl->pstream, &pssl_pstream_class, bound_name); + pstream_set_bound_port(&pssl->pstream, htons(port)); pssl->fd = fd; +#ifdef _WIN32 + pssl->wevent = CreateEvent(NULL, FALSE, FALSE, NULL); +#endif *pstreamp = &pssl->pstream; return 0; } @@ -816,7 +844,8 @@ static void pssl_close(struct pstream *pstream) { struct pssl_pstream *pssl = pssl_pstream_cast(pstream); - close(pssl->fd); + clear_handle(pssl->fd, pssl->wevent); + closesocket(pssl->fd); free(pssl); } @@ -824,32 +853,37 @@ static int pssl_accept(struct pstream *pstream, struct stream **new_streamp) { struct pssl_pstream *pssl = pssl_pstream_cast(pstream); - struct sockaddr_in sin; - socklen_t sin_len = sizeof sin; - char name[128]; + char name[SS_NTOP_BUFSIZE + 16]; + char addrbuf[SS_NTOP_BUFSIZE]; + struct sockaddr_storage ss; + socklen_t ss_len = sizeof ss; int new_fd; int error; - new_fd = accept(pssl->fd, (struct sockaddr *) &sin, &sin_len); + new_fd = accept(pssl->fd, (struct sockaddr *) &ss, &ss_len); if (new_fd < 0) { - error = errno; + error = sock_errno(); +#ifdef _WIN32 + if (error == WSAEWOULDBLOCK) { + error = EAGAIN; + } +#endif if (error != EAGAIN) { - VLOG_DBG_RL(&rl, "accept: %s", strerror(error)); + VLOG_DBG_RL(&rl, "accept: %s", sock_strerror(error)); } return error; } error = set_nonblocking(new_fd); if (error) { - close(new_fd); + closesocket(new_fd); return error; } - sprintf(name, "ssl:"IP_FMT, IP_ARGS(&sin.sin_addr)); - if (sin.sin_port != htons(OFP_SSL_PORT)) { - sprintf(strchr(name, '\0'), ":%"PRIu16, ntohs(sin.sin_port)); - } - return new_ssl_stream(name, new_fd, SERVER, STATE_SSL_CONNECTING, &sin, + snprintf(name, sizeof name, "tcp:%s:%"PRIu16, + ss_format_address(&ss, addrbuf, sizeof addrbuf), + ss_get_port(&ss)); + return new_ssl_stream(name, new_fd, SERVER, STATE_SSL_CONNECTING, new_streamp); } @@ -857,7 +891,14 @@ static void pssl_wait(struct pstream *pstream) { struct pssl_pstream *pssl = pssl_pstream_cast(pstream); - poll_fd_wait(pssl->fd, POLLIN); + poll_fd_wait_event(pssl->fd, pssl->wevent, POLLIN); +} + +static int +pssl_set_dscp(struct pstream *pstream, uint8_t dscp) +{ + struct pssl_pstream *pssl = pssl_pstream_cast(pstream); + return set_dscp(pssl->fd, dscp); } const struct pstream_class pssl_pstream_class = { @@ -867,6 +908,7 @@ const struct pstream_class pssl_pstream_class = { pssl_close, pssl_accept, pssl_wait, + pssl_set_dscp, }; /* @@ -887,7 +929,7 @@ ssl_init(void) static int init_status = -1; if (init_status < 0) { init_status = do_ssl_init(); - assert(init_status >= 0); + ovs_assert(init_status >= 0); } return init_status; } @@ -897,12 +939,46 @@ do_ssl_init(void) { SSL_METHOD *method; +#ifdef _WIN32 + /* The following call is needed if we "#include ". */ + CRYPTO_malloc_init(); +#endif SSL_library_init(); SSL_load_error_strings(); + if (!RAND_status()) { + /* We occasionally see OpenSSL fail to seed its random number generator + * in heavily loaded hypervisors. I suspect the following scenario: + * + * 1. OpenSSL calls read() to get 32 bytes from /dev/urandom. + * 2. The kernel generates 10 bytes of randomness and copies it out. + * 3. A signal arrives (perhaps SIGALRM). + * 4. The kernel interrupts the system call to service the signal. + * 5. Userspace gets 10 bytes of entropy. + * 6. OpenSSL doesn't read again to get the final 22 bytes. Therefore + * OpenSSL doesn't have enough entropy to consider itself + * initialized. + * + * The only part I'm not entirely sure about is #6, because the OpenSSL + * code is so hard to read. */ + uint8_t seed[32]; + int retval; + + VLOG_WARN("OpenSSL random seeding failed, reseeding ourselves"); + + retval = get_entropy(seed, sizeof seed); + if (retval) { + VLOG_ERR("failed to obtain entropy (%s)", + ovs_retval_to_string(retval)); + return retval > 0 ? retval : ENOPROTOOPT; + } + + RAND_seed(seed, sizeof seed); + } + /* New OpenSSL changed TLSv1_method() to return a "const" pointer, so the * cast is needed to avoid a warning with those newer versions. */ - method = (SSL_METHOD *) TLSv1_method(); + method = CONST_CAST(SSL_METHOD *, TLSv1_method()); if (method == NULL) { VLOG_ERR("TLSv1_method: %s", ERR_error_string(ERR_get_error(), NULL)); return ENOPROTOOPT; @@ -977,7 +1053,8 @@ update_ssl_config(struct ssl_config_file *config, const char *file_name) * here. */ error = get_mtime(file_name, &mtime); if (error && error != ENOENT) { - VLOG_ERR_RL(&rl, "%s: stat failed (%s)", file_name, strerror(error)); + VLOG_ERR_RL(&rl, "%s: stat failed (%s)", + file_name, ovs_strerror(error)); } if (config->file_name && !strcmp(config->file_name, file_name) @@ -1085,7 +1162,7 @@ read_cert_file(const char *file_name, X509 ***certs, size_t *n_certs) file = fopen(file_name, "r"); if (!file) { VLOG_ERR("failed to open %s for reading: %s", - file_name, strerror(errno)); + file_name, ovs_strerror(errno)); return errno; } @@ -1173,7 +1250,7 @@ log_ca_cert(const char *file_name, X509 *cert) if (i) { ds_put_char(&fp, ':'); } - ds_put_format(&fp, "%02hhx", digest[i]); + ds_put_format(&fp, "%02x", digest[i]); } } subject = X509_NAME_oneline(X509_get_subject_name(cert), NULL, 0); @@ -1208,7 +1285,7 @@ stream_ssl_set_ca_cert_file__(const char *file_name, for (i = 0; i < n_certs; i++) { /* SSL_CTX_add_client_CA makes a copy of the relevant data. */ if (SSL_CTX_add_client_CA(ctx, certs[i]) != 1) { - VLOG_ERR("failed to add client certificate %zu from %s: %s", + VLOG_ERR("failed to add client certificate %"PRIuSIZE" from %s: %s", i, file_name, ERR_error_string(ERR_get_error(), NULL)); } else { @@ -1330,10 +1407,23 @@ ssl_protocol_cb(int write_p, int version OVS_UNUSED, int content_type, ds_put_format(&details, "type %d", content_type); } - VLOG_DBG("%s%u%s%s %s (%zu bytes)", + VLOG_DBG("%s%u%s%s %s (%"PRIuSIZE" bytes)", sslv->type == CLIENT ? "client" : "server", sslv->session_nr, write_p ? "-->" : "<--", stream_get_name(&sslv->stream), ds_cstr(&details), len); ds_destroy(&details); } + +static void +clear_handle(int fd OVS_UNUSED, HANDLE wevent OVS_UNUSED) +{ +#ifdef _WIN32 + if (fd) { + WSAEventSelect(fd, NULL, 0); + } + if (wevent) { + CloseHandle(wevent); + } +#endif +}