diff --git a/modules/ssl/mod_ssl.c b/modules/ssl/mod_ssl.c index 987b256..c24c6e1 100644 --- a/modules/ssl/mod_ssl.c +++ b/modules/ssl/mod_ssl.c @@ -514,6 +514,13 @@ int ssl_engine_disable(conn_rec *c) return 1; } +static int modssl_register_npn(conn_rec *c, + ssl_npn_advertise_protos advertisefn, + ssl_npn_proto_negotiated negotiatedfn) +{ + return DECLINED; +} + int ssl_init_ssl_connection(conn_rec *c, request_rec *r) { SSLSrvConfigRec *sc; @@ -706,6 +713,7 @@ static void ssl_register_hooks(apr_pool_t *p) APR_REGISTER_OPTIONAL_FN(ssl_proxy_enable); APR_REGISTER_OPTIONAL_FN(ssl_engine_disable); + APR_REGISTER_OPTIONAL_FN(modssl_register_npn); ap_register_auth_provider(p, AUTHZ_PROVIDER_GROUP, "ssl", AUTHZ_PROVIDER_VERSION, diff --git a/modules/ssl/mod_ssl.h b/modules/ssl/mod_ssl.h index db8ffaf..d381901 100644 --- a/modules/ssl/mod_ssl.h +++ b/modules/ssl/mod_ssl.h @@ -84,5 +84,40 @@ APR_DECLARE_OPTIONAL_FN(int, ssl_proxy_enable, (conn_rec *)); APR_DECLARE_OPTIONAL_FN(int, ssl_engine_disable, (conn_rec *)); +/** The npn_advertise_protos callback allows another modules to add + * entries to the list of protocol names advertised by the server + * during the Next Protocol Negotiation (NPN) portion of the SSL + * handshake. The callback is given the connection and an APR array; + * it should push one or more char*'s pointing to NUL-terminated + * strings (such as "http/1.1" or "spdy/2") onto the array and return + * OK. To prevent further processing of (other modules') callbacks, + * return DONE. */ +typedef int (*ssl_npn_advertise_protos)(conn_rec *connection, + apr_array_header_t *protos); + +/** The npn_proto_negotiated callback allows other modules to discover + * the name of the protocol that was chosen during the Next Protocol + * Negotiation (NPN) portion of the SSL handshake. Note that this may + * be the empty string (in which case modules should probably assume + * HTTP), or it may be a protocol that was never even advertised by + * the server. The callback is given the connection, a + * non-NUL-terminated string containing the protocol name, and the + * length of the string; it should do something appropriate + * (i.e. insert or remove filters) and return OK. To prevent further + * processing of (other modules') callbacks, return DONE. */ +typedef int (*ssl_npn_proto_negotiated)(conn_rec *connection, + const char *proto_name, + apr_size_t proto_name_len); + +/* An optional function which can be used to register a pair of + * callbacks for NPN handling. This optional function should be + * invoked from a pre_connection hook which runs *after* mod_ssl.c's + * pre_connection hook. The function returns OK if the callbacks are + * register, or DECLINED otherwise (for example if mod_ssl does not +l * support NPN). */ +APR_DECLARE_OPTIONAL_FN(int, modssl_register_npn, (conn_rec *conn, + ssl_npn_advertise_protos advertisefn, + ssl_npn_proto_negotiated negotiatedfn)); + #endif /* __MOD_SSL_H__ */ /** @} */ diff --git a/modules/ssl/ssl_engine_init.c b/modules/ssl/ssl_engine_init.c index 9526f1b..12b2115 100644 --- a/modules/ssl/ssl_engine_init.c +++ b/modules/ssl/ssl_engine_init.c @@ -736,6 +736,11 @@ static void ssl_init_ctx_callbacks(server_rec *s, #ifdef HAVE_TLS_ALPN SSL_CTX_set_alpn_select_cb(ctx, ssl_callback_alpn_select, NULL); #endif + +#ifdef HAVE_TLS_NPN + SSL_CTX_set_next_protos_advertised_cb( + ctx, ssl_callback_AdvertiseNextProtos, NULL); +#endif } static apr_status_t ssl_init_ctx_verify(server_rec *s, diff --git a/modules/ssl/ssl_engine_io.c b/modules/ssl/ssl_engine_io.c index d1f44e9..26ee301 100644 --- a/modules/ssl/ssl_engine_io.c +++ b/modules/ssl/ssl_engine_io.c @@ -317,6 +317,7 @@ typedef struct { apr_pool_t *pool; char buffer[AP_IOBUFSIZE]; ssl_filter_ctx_t *filter_ctx; + int npn_finished; /* 1 if NPN has finished, 0 otherwise */ } bio_filter_in_ctx_t; /* @@ -1517,6 +1518,38 @@ static apr_status_t ssl_io_filter_input(ap_filter_t *f, return ssl_io_filter_error(inctx, bb, status, is_init); } +#ifdef HAVE_TLS_NPN + /* By this point, Next Protocol Negotiation (NPN) should be completed (if + * our version of OpenSSL supports it). If we haven't already, find out + * which protocol was decided upon and inform other modules by calling + * npn_proto_negotiated_hook. */ + if (!inctx->npn_finished) { + SSLConnRec *sslconn = myConnConfig(f->c); + apr_array_header_t *protos = apr_array_make(f->c->pool, 1, sizeof(char *)); + const unsigned char *next_proto = NULL; + unsigned next_proto_len = 0; + const unsigned char *out; + unsigned char outlen; + + SSL_get0_next_proto_negotiated(inctx->ssl, &next_proto, &next_proto_len); + if (next_proto_len) { + ap_log_cerror(APLOG_MARK, APLOG_TRACE1, 0, f->c, + APLOGNO(02306) "SSL NPN negotiated protocol: '%.*s'", + next_proto_len, (const char*)next_proto); + + APR_ARRAY_PUSH(protos, char *) = + apr_pstrmemdup(f->c->pool, (const char *)next_proto, next_proto_len); + + if (modssl_select_protocol(inctx->ssl, f->c, sslconn, protos, + &out, &outlen) != SSL_TLSEXT_ERR_OK) + ap_log_cerror(APLOG_MARK, APLOG_INFO, 0, f->c, + "SSL NPN negotiation failed"); + } + + inctx->npn_finished = 1; + } +#endif + if (is_init) { /* protocol module needs to handshake before sending * data to client (e.g. NNTP or FTP) @@ -2041,6 +2074,7 @@ static void ssl_io_input_add_filter(ssl_filter_ctx_t *filter_ctx, conn_rec *c, inctx->block = APR_BLOCK_READ; inctx->pool = c->pool; inctx->filter_ctx = filter_ctx; + inctx->npn_finished = 0; } /* The request_rec pointer is passed in here only to ensure that the diff --git a/modules/ssl/ssl_engine_kernel.c b/modules/ssl/ssl_engine_kernel.c index 02acd22..dced334 100644 --- a/modules/ssl/ssl_engine_kernel.c +++ b/modules/ssl/ssl_engine_kernel.c @@ -2332,6 +2332,142 @@ int ssl_callback_SessionTicket(SSL *ssl, } #endif /* HAVE_TLS_SESSION_TICKETS */ +#if defined(HAVE_TLS_NPN) || defined(HAVE_TLS_ALPN) +int modssl_select_protocol(SSL *ssl, conn_rec *c, SSLConnRec *sslconn, + apr_array_header_t *client_protos, + const unsigned char **out, unsigned char *outlen) +{ + const char *proposed; + size_t len; + + /* The order the callbacks are invoked from TLS extensions is, unfortunately + * not defined and older openssl versions do call ALPN selection before + * they callback the SNI. We need to make sure that we know which vhost + * we are dealing with so we respect the correct protocols. + */ + init_vhost(c, ssl); + + proposed = ap_select_protocol(c, NULL, sslconn->server, client_protos); + if (!proposed) { + proposed = ap_get_protocol(c); + } + + len = strlen(proposed); + if (len > 255) { + ap_log_cerror(APLOG_MARK, APLOG_ERR, 0, c, APLOGNO(02840) + "ALPN negotiated protocol name too long"); + return SSL_TLSEXT_ERR_ALERT_FATAL; + } + *out = (const unsigned char *)proposed; + *outlen = (unsigned char)len; + + ap_log_cerror(APLOG_MARK, APLOG_TRACE8, 0, c, + "protocol switching from '%s' to '%s'", + ap_get_protocol(c), proposed); + + if (strcmp(proposed, ap_get_protocol(c))) { + apr_status_t status; + + status = ap_switch_protocol(c, NULL, sslconn->server, proposed); + if (status != APR_SUCCESS) { + ap_log_cerror(APLOG_MARK, APLOG_ERR, status, c, + APLOGNO(02908) "protocol switch to '%s' failed", + proposed); + return SSL_TLSEXT_ERR_ALERT_FATAL; + } + } + + return SSL_TLSEXT_ERR_OK; +} +#endif /* defined(HAVE_TLS_NPN) || defined(HAVE_TLS_ALPN) */ + +#ifdef HAVE_TLS_NPN +/* + * This callback function is executed when SSL needs to decide what protocols + * to advertise during Next Protocol Negotiation (NPN). It must produce a + * string in wire format -- a sequence of length-prefixed strings -- indicating + * the advertised protocols. Refer to SSL_CTX_set_next_protos_advertised_cb + * in OpenSSL for reference. + */ +int ssl_callback_AdvertiseNextProtos(SSL *ssl, const unsigned char **data_out, + unsigned int *size_out, void *arg) +{ + conn_rec *c = (conn_rec*)SSL_get_app_data(ssl); + SSLConnRec *sslconn = myConnConfig(c); + const apr_array_header_t *protos; + int num_protos; + unsigned int size; + int i; + unsigned char *data; + unsigned char *start; + + *data_out = NULL; + *size_out = 0; + + /* If the connection object is not available, or there are no + upgrades available, do nothing. */ + if (!c || ap_get_protocol_upgrades(c, NULL, sslconn->server, 0, &protos)) { + return SSL_TLSEXT_ERR_NOACK; + } + + num_protos = protos ? protos->nelts : 0; + + if (num_protos == 0) { + return SSL_TLSEXT_ERR_NOACK; + } + + /* We now have a list of null-terminated strings; we need to concatenate + * them together into a single string, where each protocol name is prefixed + * by its length. First, calculate how long that string will be. */ + size = 0; + for (i = 0; i < num_protos; ++i) { + const char *string = APR_ARRAY_IDX(protos, i, const char*); + unsigned int length = strlen(string); + /* If the protocol name is too long (the length must fit in one byte), + * then log an error and skip it. */ + if (length > 255) { + ap_log_cerror(APLOG_MARK, APLOG_ERR, 0, c, APLOGNO(02307) + "SSL NPN protocol name too long (length=%u): %s", + length, string); + continue; + } + /* Leave room for the length prefix (one byte) plus the protocol name + * itself. */ + size += 1 + length; + } + + /* If there is nothing to advertise (either because no modules added + * anything to the protos array, or because all strings added to the array + * were skipped), then we're done. */ + if (size == 0) { + return SSL_TLSEXT_ERR_OK; + } + + /* Now we can build the string. Copy each protocol name string into the + * larger string, prefixed by its length. */ + data = apr_palloc(c->pool, size * sizeof(unsigned char)); + start = data; + for (i = 0; i < num_protos; ++i) { + const char *string = APR_ARRAY_IDX(protos, i, const char*); + apr_size_t length = strlen(string); + if (length > 255) + continue; + *start = (unsigned char)length; + ++start; + memcpy(start, string, length * sizeof(unsigned char)); + start += length; + ap_log_cerror(APLOG_MARK, APLOG_DEBUG, 0, c, + "SSL NPN protocol advertising: %s", string); + } + + /* Success. */ + *data_out = data; + *size_out = size; + return SSL_TLSEXT_ERR_OK; +} + +#endif /* HAVE_TLS_NPN */ + #ifdef HAVE_TLS_ALPN /* @@ -2354,8 +2490,6 @@ int ssl_callback_alpn_select(SSL *ssl, conn_rec *c = (conn_rec*)SSL_get_app_data(ssl); SSLConnRec *sslconn = myConnConfig(c); apr_array_header_t *client_protos; - const char *proposed; - size_t len; int i; /* If the connection object is not available, @@ -2385,40 +2519,7 @@ int ssl_callback_alpn_select(SSL *ssl, i += plen; } - /* The order the callbacks are invoked from TLS extensions is, unfortunately - * not defined and older openssl versions do call ALPN selection before - * they callback the SNI. We need to make sure that we know which vhost - * we are dealing with so we respect the correct protocols. - */ - init_vhost(c, ssl); - - proposed = ap_select_protocol(c, NULL, sslconn->server, client_protos); - if (!proposed) { - proposed = ap_get_protocol(c); - } - - len = strlen(proposed); - if (len > 255) { - ap_log_cerror(APLOG_MARK, APLOG_ERR, 0, c, APLOGNO(02840) - "ALPN negotiated protocol name too long"); - return SSL_TLSEXT_ERR_ALERT_FATAL; - } - *out = (const unsigned char *)proposed; - *outlen = (unsigned char)len; - - if (strcmp(proposed, ap_get_protocol(c))) { - apr_status_t status; - - status = ap_switch_protocol(c, NULL, sslconn->server, proposed); - if (status != APR_SUCCESS) { - ap_log_cerror(APLOG_MARK, APLOG_ERR, status, c, - APLOGNO(02908) "protocol switch to '%s' failed", - proposed); - return SSL_TLSEXT_ERR_ALERT_FATAL; - } - } - - return SSL_TLSEXT_ERR_OK; + return modssl_select_protocol(ssl, c, sslconn, client_protos, out, outlen); } #endif /* HAVE_TLS_ALPN */ diff --git a/modules/ssl/ssl_private.h b/modules/ssl/ssl_private.h index 41b4387..7c440ef 100644 --- a/modules/ssl/ssl_private.h +++ b/modules/ssl/ssl_private.h @@ -98,6 +98,8 @@ #include #include +#include "mod_ssl.h" + /* Avoid tripping over an engine build installed globally and detected * when the user points at an explicit non-engine flavor of OpenSSL */ @@ -127,6 +129,11 @@ #define HAVE_FIPS #endif +#if OPENSSL_VERSION_NUMBER >= 0x10001000L && !defined(OPENSSL_NO_NEXTPROTONEG) \ + && !defined(OPENSSL_NO_TLSEXT) +#define HAVE_TLS_NPN +#endif + #if defined(SSL_OP_NO_TLSv1_2) #define HAVE_TLSV1_X #endif @@ -872,6 +879,10 @@ int ssl_callback_ServerNameIndication(SSL *, int *, modssl_ctx_t *); int ssl_callback_SessionTicket(SSL *, unsigned char *, unsigned char *, EVP_CIPHER_CTX *, HMAC_CTX *, int); #endif +int ssl_callback_AdvertiseNextProtos(SSL *ssl, const unsigned char **data, unsigned int *len, void *arg); +int modssl_select_protocol(SSL *ssl, conn_rec *c, SSLConnRec *sslconn, + apr_array_header_t *client_protos, + const unsigned char **out, unsigned char *outlen); #ifdef HAVE_TLS_ALPN int ssl_callback_alpn_select(SSL *ssl, const unsigned char **out,