| /* Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| #include <assert.h> |
| #include <apr_lib.h> |
| #include <apr_strings.h> |
| |
| #include <httpd.h> |
| #include <http_connection.h> |
| #include <http_core.h> |
| #include <http_request.h> |
| #include <http_log.h> |
| #include <ap_socache.h> |
| |
| #include <rustls.h> |
| |
| #include "tls_proto.h" |
| #include "tls_conf.h" |
| #include "tls_core.h" |
| #include "tls_filter.h" |
| #include "tls_util.h" |
| |
| |
| extern module AP_MODULE_DECLARE_DATA tls_module; |
| APLOG_USE_MODULE(tls); |
| |
| |
| static rustls_io_result tls_read_callback( |
| void *userdata, unsigned char *buf, size_t n, size_t *out_n) |
| { |
| tls_data_t *d = userdata; |
| size_t len = d->len > n? n : d->len; |
| memcpy(buf, d->data, len); |
| *out_n = len; |
| return 0; |
| } |
| |
| /** |
| * Provide TLS encrypted data to the rustls server_session in <fctx->cc->rustls_connection>. |
| * |
| * If <fctx->fin_tls_bb> holds data, take it from there. Otherwise perform a |
| * read via the network filters below us into that brigade. |
| * |
| * <fctx->fin_block> determines if we do a blocking read inititally or not. |
| * If the first read did to not produce enough data, any secondary read is done |
| * non-blocking. |
| * |
| * Had any data been added to <fctx->cc->rustls_connection>, call its "processing" |
| * function to handle the added data before leaving. |
| */ |
| static apr_status_t read_tls_to_rustls( |
| tls_filter_ctx_t *fctx, apr_size_t len, apr_read_type_e block, int errors_expected) |
| { |
| tls_data_t d; |
| apr_size_t rlen; |
| apr_off_t passed = 0; |
| rustls_result rr = RUSTLS_RESULT_OK; |
| int os_err; |
| apr_status_t rv = APR_SUCCESS; |
| |
| if (APR_BRIGADE_EMPTY(fctx->fin_tls_bb)) { |
| ap_log_error(APLOG_MARK, APLOG_TRACE2, rv, fctx->cc->server, |
| "read_tls_to_rustls, get data from network, block=%d", block); |
| rv = ap_get_brigade(fctx->fin_ctx->next, fctx->fin_tls_bb, |
| AP_MODE_READBYTES, block, (apr_off_t)len); |
| if (APR_SUCCESS != rv) { |
| goto cleanup; |
| } |
| } |
| |
| while (!APR_BRIGADE_EMPTY(fctx->fin_tls_bb) && passed < (apr_off_t)len) { |
| apr_bucket *b = APR_BRIGADE_FIRST(fctx->fin_tls_bb); |
| |
| if (APR_BUCKET_IS_EOS(b)) { |
| ap_log_error(APLOG_MARK, APLOG_TRACE2, rv, fctx->cc->server, |
| "read_tls_to_rustls, EOS"); |
| if (fctx->fin_tls_buffer_bb) { |
| apr_brigade_cleanup(fctx->fin_tls_buffer_bb); |
| } |
| rv = APR_EOF; goto cleanup; |
| } |
| |
| rv = apr_bucket_read(b, (const char**)&d.data, &d.len, block); |
| if (APR_STATUS_IS_EOF(rv)) { |
| apr_bucket_delete(b); |
| continue; |
| } |
| else if (APR_SUCCESS != rv) { |
| goto cleanup; |
| } |
| |
| if (d.len > 0) { |
| /* got something, do not block on getting more */ |
| block = APR_NONBLOCK_READ; |
| |
| os_err = rustls_connection_read_tls(fctx->cc->rustls_connection, |
| tls_read_callback, &d, &rlen); |
| if (os_err) { |
| rv = APR_FROM_OS_ERROR(os_err); |
| goto cleanup; |
| } |
| |
| if (fctx->fin_tls_buffer_bb) { |
| /* we buffer for later replay on the 'real' rustls_connection */ |
| apr_brigade_write(fctx->fin_tls_buffer_bb, NULL, NULL, (const char*)d.data, rlen); |
| } |
| if (rlen >= d.len) { |
| apr_bucket_delete(b); |
| } |
| else { |
| b->start += (apr_off_t)rlen; |
| b->length -= rlen; |
| } |
| fctx->fin_bytes_in_rustls += (apr_off_t)d.len; |
| passed += (apr_off_t)rlen; |
| } |
| else if (d.len == 0) { |
| apr_bucket_delete(b); |
| } |
| } |
| |
| if (passed > 0) { |
| rr = rustls_connection_process_new_packets(fctx->cc->rustls_connection); |
| if (rr != RUSTLS_RESULT_OK) goto cleanup; |
| } |
| |
| cleanup: |
| if (rr != RUSTLS_RESULT_OK) { |
| rv = APR_ECONNRESET; |
| if (!errors_expected) { |
| const char *err_descr = ""; |
| rv = tls_core_error(fctx->c, rr, &err_descr); |
| ap_log_cerror(APLOG_MARK, APLOG_WARNING, rv, fctx->c, APLOGNO(10353) |
| "processing TLS data: [%d] %s", (int)rr, err_descr); |
| } |
| } |
| else if (APR_STATUS_IS_EOF(rv) && passed > 0) { |
| /* encountering EOF while actually having read sth is a success. */ |
| rv = APR_SUCCESS; |
| } |
| else if (APR_SUCCESS == rv && passed == 0 && fctx->fin_block == APR_NONBLOCK_READ) { |
| rv = APR_EAGAIN; |
| } |
| else { |
| ap_log_error(APLOG_MARK, APLOG_TRACE2, rv, fctx->cc->server, |
| "read_tls_to_rustls, passed %ld bytes to rustls", (long)passed); |
| } |
| return rv; |
| } |
| |
| static apr_status_t fout_pass_tls_to_net(tls_filter_ctx_t *fctx) |
| { |
| apr_status_t rv = APR_SUCCESS; |
| |
| if (!APR_BRIGADE_EMPTY(fctx->fout_tls_bb)) { |
| rv = ap_pass_brigade(fctx->fout_ctx->next, fctx->fout_tls_bb); |
| if (APR_SUCCESS == rv && fctx->c->aborted) { |
| rv = APR_ECONNRESET; |
| } |
| fctx->fout_bytes_in_tls_bb = 0; |
| apr_brigade_cleanup(fctx->fout_tls_bb); |
| } |
| return rv; |
| } |
| |
| static apr_status_t fout_pass_all_to_net( |
| tls_filter_ctx_t *fctx, int flush); |
| |
| static apr_status_t filter_abort( |
| tls_filter_ctx_t *fctx) |
| { |
| apr_status_t rv; |
| |
| if (fctx->cc->state != TLS_CONN_ST_DONE) { |
| if (fctx->cc->state > TLS_CONN_ST_CLIENT_HELLO) { |
| rustls_connection_send_close_notify(fctx->cc->rustls_connection); |
| rv = fout_pass_all_to_net(fctx, 1); |
| ap_log_cerror(APLOG_MARK, APLOG_TRACE2, rv, fctx->c, "filter_abort, flushed output"); |
| } |
| fctx->c->aborted = 1; |
| fctx->cc->state = TLS_CONN_ST_DONE; |
| } |
| return APR_ECONNABORTED; |
| } |
| |
| static apr_status_t filter_recv_client_hello(tls_filter_ctx_t *fctx) |
| { |
| apr_status_t rv = APR_SUCCESS; |
| |
| ap_log_error(APLOG_MARK, APLOG_TRACE2, 0, fctx->cc->server, |
| "tls_filter, server=%s, recv client hello", fctx->cc->server->server_hostname); |
| /* only for incoming connections */ |
| ap_assert(!fctx->cc->outgoing); |
| |
| if (rustls_connection_is_handshaking(fctx->cc->rustls_connection)) { |
| apr_bucket_brigade *bb_tmp; |
| |
| ap_log_cerror(APLOG_MARK, APLOG_TRACE2, rv, fctx->c, "filter_recv_client_hello: start"); |
| fctx->fin_tls_buffer_bb = apr_brigade_create(fctx->c->pool, fctx->c->bucket_alloc); |
| do { |
| if (rustls_connection_wants_read(fctx->cc->rustls_connection)) { |
| rv = read_tls_to_rustls(fctx, fctx->fin_max_in_rustls, APR_BLOCK_READ, 1); |
| if (APR_SUCCESS != rv) { |
| if (fctx->cc->client_hello_seen) { |
| rv = APR_EAGAIN; /* we got what we needed */ |
| break; |
| } |
| /* Something went wrong before we saw the client hello. |
| * This is a real error on which we should not continue. */ |
| goto cleanup; |
| } |
| } |
| /* Notice: we never write here to the client. We just want to inspect |
| * the client hello. */ |
| } while (!fctx->cc->client_hello_seen); |
| |
| /* We have seen the client hello and selected the server (vhost) to use |
| * on this connection. Set up the 'real' rustls_connection based on the |
| * servers 'real' rustls_config. */ |
| rv = tls_core_conn_seen_client_hello(fctx->c); |
| if (APR_SUCCESS != rv) goto cleanup; |
| |
| bb_tmp = fctx->fin_tls_bb; /* data we have yet to feed to rustls */ |
| fctx->fin_tls_bb = fctx->fin_tls_buffer_bb; /* data we already fed to the pre_session */ |
| fctx->fin_tls_buffer_bb = NULL; |
| APR_BRIGADE_CONCAT(fctx->fin_tls_bb, bb_tmp); /* all tls data from the client so far, reloaded */ |
| apr_brigade_destroy(bb_tmp); |
| rv = APR_SUCCESS; |
| } |
| |
| cleanup: |
| ap_log_cerror(APLOG_MARK, APLOG_TRACE2, rv, fctx->c, "filter_recv_client_hello: done"); |
| return rv; |
| } |
| |
| static apr_status_t filter_send_client_hello(tls_filter_ctx_t *fctx) |
| { |
| apr_status_t rv = APR_SUCCESS; |
| |
| ap_log_error(APLOG_MARK, APLOG_TRACE2, 0, fctx->cc->server, |
| "tls_filter, server=%s, send client hello", fctx->cc->server->server_hostname); |
| /* Only for outgoing connections */ |
| ap_assert(fctx->cc->outgoing); |
| if (rustls_connection_is_handshaking(fctx->cc->rustls_connection)) { |
| while (rustls_connection_wants_write(fctx->cc->rustls_connection)) { |
| /* write flushed, so it really gets out */ |
| rv = fout_pass_all_to_net(fctx, 1); |
| if (APR_SUCCESS != rv) goto cleanup; |
| } |
| } |
| |
| cleanup: |
| return rv; |
| } |
| |
| /** |
| * While <fctx->cc->rustls_connection> indicates that a handshake is ongoing, |
| * write TLS data from and read network TLS data to the server session. |
| * |
| * @return APR_SUCCESS when the handshake is completed |
| */ |
| static apr_status_t filter_do_handshake( |
| tls_filter_ctx_t *fctx) |
| { |
| apr_status_t rv = APR_SUCCESS; |
| |
| ap_log_error(APLOG_MARK, APLOG_TRACE2, 0, fctx->cc->server, |
| "tls_filter, server=%s, do handshake", fctx->cc->server->server_hostname); |
| if (rustls_connection_is_handshaking(fctx->cc->rustls_connection)) { |
| do { |
| if (rustls_connection_wants_write(fctx->cc->rustls_connection)) { |
| rv = fout_pass_all_to_net(fctx, 1); |
| if (APR_SUCCESS != rv) goto cleanup; |
| } |
| else if (rustls_connection_wants_read(fctx->cc->rustls_connection)) { |
| rv = read_tls_to_rustls(fctx, fctx->fin_max_in_rustls, APR_BLOCK_READ, 0); |
| if (APR_SUCCESS != rv) goto cleanup; |
| } |
| } |
| while (rustls_connection_is_handshaking(fctx->cc->rustls_connection)); |
| |
| /* rustls reports the TLS handshake to be done, when it *internally* has |
| * processed everything into its buffers. Not when the buffers have been |
| * send to the other side. */ |
| if (rustls_connection_wants_write(fctx->cc->rustls_connection)) { |
| rv = fout_pass_all_to_net(fctx, 1); |
| if (APR_SUCCESS != rv) goto cleanup; |
| } |
| } |
| cleanup: |
| ap_log_error(APLOG_MARK, APLOG_TRACE2, rv, fctx->cc->server, |
| "tls_filter, server=%s, handshake done", fctx->cc->server->server_hostname); |
| if (APR_SUCCESS != rv) { |
| if (fctx->cc->last_error_descr) { |
| ap_log_cerror(APLOG_MARK, APLOG_INFO, APR_ECONNABORTED, fctx->c, APLOGNO(10354) |
| "handshake failed: %s", fctx->cc->last_error_descr); |
| } |
| } |
| return rv; |
| } |
| |
| static apr_status_t progress_tls_atleast_to(tls_filter_ctx_t *fctx, tls_conn_state_t state) |
| { |
| apr_status_t rv = APR_SUCCESS; |
| |
| /* handle termination immediately */ |
| if (state == TLS_CONN_ST_DONE) { |
| rv = APR_ECONNABORTED; |
| goto cleanup; |
| } |
| |
| if (state > TLS_CONN_ST_CLIENT_HELLO |
| && TLS_CONN_ST_CLIENT_HELLO == fctx->cc->state) { |
| rv = tls_core_conn_init(fctx->c); |
| if (APR_SUCCESS != rv) goto cleanup; |
| |
| if (fctx->cc->outgoing) { |
| rv = filter_send_client_hello(fctx); |
| } |
| else { |
| rv = filter_recv_client_hello(fctx); |
| } |
| if (APR_SUCCESS != rv) goto cleanup; |
| fctx->cc->state = TLS_CONN_ST_HANDSHAKE; |
| } |
| |
| if (state > TLS_CONN_ST_HANDSHAKE |
| && TLS_CONN_ST_HANDSHAKE== fctx->cc->state) { |
| rv = filter_do_handshake(fctx); |
| if (APR_SUCCESS != rv) goto cleanup; |
| rv = tls_core_conn_post_handshake(fctx->c); |
| if (APR_SUCCESS != rv) goto cleanup; |
| fctx->cc->state = TLS_CONN_ST_TRAFFIC; |
| } |
| |
| if (state < fctx->cc->state) { |
| rv = APR_ECONNABORTED; |
| } |
| |
| cleanup: |
| if (APR_SUCCESS != rv) { |
| filter_abort(fctx); /* does change the state itself */ |
| } |
| return rv; |
| } |
| |
| /** |
| * The connection filter converting TLS encrypted network data into plain, unencrpyted |
| * traffic data to be processed by filters above it in the filter chain. |
| * |
| * Unfortunately, Apache's filter infrastructure places a heavy implementation |
| * complexity on its input filters for the various use cases its HTTP/1.x parser |
| * (mainly) finds convenient: |
| * |
| * <bb> the bucket brigade to place the data into. |
| * <mode> one of |
| * - AP_MODE_READBYTES: just add up to <readbytes> data into <bb> |
| * - AP_MODE_GETLINE: make a best effort to get data up to and including a CRLF. |
| * it can be less, but not more t than that. |
| * - AP_MODE_EATCRLF: never used, we puke on it. |
| * - AP_MODE_SPECULATIVE: read data without consuming it. |
| * - AP_MODE_EXHAUSTIVE: never used, we puke on it. |
| * - AP_MODE_INIT: called once on a connection. needs to pass down the filter |
| * chain, giving every filter the change to "INIT". |
| * <block> do blocking or non-blocking reads |
| * <readbytes> max amount of data to add to <bb>, seems to be 0 for GETLINE |
| */ |
| static apr_status_t filter_conn_input( |
| ap_filter_t *f, apr_bucket_brigade *bb, ap_input_mode_t mode, |
| apr_read_type_e block, apr_off_t readbytes) |
| { |
| tls_filter_ctx_t *fctx = f->ctx; |
| apr_status_t rv = APR_SUCCESS; |
| apr_off_t passed = 0, nlen; |
| rustls_result rr = RUSTLS_RESULT_OK; |
| apr_size_t in_buf_len; |
| char *in_buf = NULL; |
| |
| fctx->fin_block = block; |
| if (f->c->aborted) { |
| rv = filter_abort(fctx); goto cleanup; |
| } |
| |
| ap_log_error(APLOG_MARK, APLOG_TRACE2, 0, fctx->cc->server, |
| "tls_filter_conn_input, server=%s, mode=%d, block=%d, readbytes=%ld", |
| fctx->cc->server->server_hostname, mode, block, (long)readbytes); |
| |
| rv = progress_tls_atleast_to(fctx, TLS_CONN_ST_TRAFFIC); |
| if (APR_SUCCESS != rv) goto cleanup; /* this also leaves on APR_EAGAIN */ |
| |
| if (!fctx->cc->rustls_connection) { |
| return ap_get_brigade(f->next, bb, mode, block, readbytes); |
| } |
| |
| #if AP_MODULE_MAGIC_AT_LEAST(20200420, 1) |
| ap_filter_reinstate_brigade(f, fctx->fin_plain_bb, NULL); |
| #endif |
| |
| if (AP_MODE_INIT == mode) { |
| /* INIT is used to trigger the handshake, it does not return any traffic data. */ |
| goto cleanup; |
| } |
| |
| /* If we have nothing buffered, try getting more input. |
| * a) ask rustls_connection for decrypted data, if it has any. |
| * Note that only full records can be decrypted. We might have |
| * written TLS data to the session, but that does not mean it |
| * can give unencryted data out again. |
| * b) read TLS bytes from the network and feed them to the rustls session. |
| * c) go back to a) if b) added data. |
| */ |
| while (APR_BRIGADE_EMPTY(fctx->fin_plain_bb)) { |
| apr_size_t rlen = 0; |
| apr_bucket *b; |
| |
| if (fctx->fin_bytes_in_rustls > 0) { |
| in_buf_len = APR_BUCKET_BUFF_SIZE; |
| in_buf = ap_calloc(in_buf_len, sizeof(char)); |
| rr = rustls_connection_read(fctx->cc->rustls_connection, |
| (unsigned char*)in_buf, in_buf_len, &rlen); |
| if (rr == RUSTLS_RESULT_PLAINTEXT_EMPTY) { |
| rr = RUSTLS_RESULT_OK; |
| rlen = 0; |
| } |
| if (rr != RUSTLS_RESULT_OK) goto cleanup; |
| ap_log_cerror(APLOG_MARK, APLOG_TRACE2, rv, fctx->c, |
| "tls_filter_conn_input: got %ld plain bytes from rustls", (long)rlen); |
| if (rlen > 0) { |
| b = apr_bucket_heap_create(in_buf, rlen, free, fctx->c->bucket_alloc); |
| APR_BRIGADE_INSERT_TAIL(fctx->fin_plain_bb, b); |
| } |
| else { |
| free(in_buf); |
| } |
| in_buf = NULL; |
| } |
| if (rlen == 0) { |
| /* that did not produce anything either. try getting more |
| * TLS data from the network into the rustls session. */ |
| fctx->fin_bytes_in_rustls = 0; |
| rv = read_tls_to_rustls(fctx, fctx->fin_max_in_rustls, block, 0); |
| if (APR_SUCCESS != rv) goto cleanup; /* this also leave on APR_EAGAIN */ |
| } |
| } |
| |
| if (AP_MODE_GETLINE == mode) { |
| if (readbytes <= 0) readbytes = HUGE_STRING_LEN; |
| rv = tls_util_brigade_split_line(bb, fctx->fin_plain_bb, block, readbytes, &nlen); |
| if (APR_SUCCESS != rv) goto cleanup; |
| passed += nlen; |
| } |
| else if (AP_MODE_READBYTES == mode) { |
| ap_assert(readbytes > 0); |
| rv = tls_util_brigade_transfer(bb, fctx->fin_plain_bb, readbytes, &nlen); |
| if (APR_SUCCESS != rv) goto cleanup; |
| passed += nlen; |
| } |
| else if (AP_MODE_SPECULATIVE == mode) { |
| ap_assert(readbytes > 0); |
| rv = tls_util_brigade_copy(bb, fctx->fin_plain_bb, readbytes, &nlen); |
| if (APR_SUCCESS != rv) goto cleanup; |
| passed += nlen; |
| } |
| else if (AP_MODE_EXHAUSTIVE == mode) { |
| /* return all we have */ |
| APR_BRIGADE_CONCAT(bb, fctx->fin_plain_bb); |
| } |
| else { |
| /* We do support any other mode */ |
| rv = APR_ENOTIMPL; goto cleanup; |
| } |
| |
| fout_pass_all_to_net(fctx, 0); |
| |
| cleanup: |
| if (NULL != in_buf) free(in_buf); |
| |
| if (APLOGctrace3(fctx->c)) { |
| tls_util_bb_log(fctx->c, APLOG_TRACE3, "tls_input, fctx->fin_plain_bb", fctx->fin_plain_bb); |
| tls_util_bb_log(fctx->c, APLOG_TRACE3, "tls_input, bb", bb); |
| } |
| if (rr != RUSTLS_RESULT_OK) { |
| const char *err_descr = ""; |
| |
| rv = tls_core_error(fctx->c, rr, &err_descr); |
| ap_log_cerror(APLOG_MARK, APLOG_DEBUG, rv, fctx->c, APLOGNO(10355) |
| "tls_filter_conn_input: [%d] %s", (int)rr, err_descr); |
| } |
| else if (APR_STATUS_IS_EAGAIN(rv)) { |
| ap_log_cerror(APLOG_MARK, APLOG_TRACE4, rv, fctx->c, |
| "tls_filter_conn_input: no data available"); |
| } |
| else if (APR_SUCCESS != rv) { |
| ap_log_cerror(APLOG_MARK, APLOG_DEBUG, rv, fctx->c, APLOGNO(10356) |
| "tls_filter_conn_input"); |
| } |
| else { |
| ap_log_cerror(APLOG_MARK, APLOG_TRACE2, rv, fctx->c, |
| "tls_filter_conn_input: passed %ld bytes", (long)passed); |
| } |
| |
| #if AP_MODULE_MAGIC_AT_LEAST(20200420, 1) |
| if (APR_SUCCESS == rv || APR_STATUS_IS_EAGAIN(rv)) { |
| ap_filter_setaside_brigade(f, fctx->fin_plain_bb); |
| } |
| #endif |
| return rv; |
| } |
| |
| static rustls_io_result tls_write_callback( |
| void *userdata, const unsigned char *buf, size_t n, size_t *out_n) |
| { |
| tls_filter_ctx_t *fctx = userdata; |
| apr_status_t rv; |
| |
| if ((apr_off_t)n + fctx->fout_bytes_in_tls_bb >= (apr_off_t)fctx->fout_auto_flush_size) { |
| apr_bucket *b = apr_bucket_transient_create((const char*)buf, n, fctx->fout_tls_bb->bucket_alloc); |
| APR_BRIGADE_INSERT_TAIL(fctx->fout_tls_bb, b); |
| fctx->fout_bytes_in_tls_bb += (apr_off_t)n; |
| rv = fout_pass_tls_to_net(fctx); |
| *out_n = n; |
| } |
| else { |
| rv = apr_brigade_write(fctx->fout_tls_bb, NULL, NULL, (const char*)buf, n); |
| if (APR_SUCCESS != rv) goto cleanup; |
| fctx->fout_bytes_in_tls_bb += (apr_off_t)n; |
| *out_n = n; |
| } |
| cleanup: |
| ap_log_error(APLOG_MARK, APLOG_TRACE5, rv, fctx->cc->server, |
| "tls_write_callback: %ld bytes", (long)n); |
| return APR_TO_OS_ERROR(rv); |
| } |
| |
| static rustls_io_result tls_write_vectored_callback( |
| void *userdata, const rustls_iovec *riov, size_t count, size_t *out_n) |
| { |
| tls_filter_ctx_t *fctx = userdata; |
| const struct iovec *iov = (const struct iovec*)riov; |
| apr_status_t rv; |
| size_t i, n = 0; |
| apr_bucket *b; |
| |
| for (i = 0; i < count; ++i, ++iov) { |
| b = apr_bucket_transient_create((const char*)iov->iov_base, iov->iov_len, fctx->fout_tls_bb->bucket_alloc); |
| APR_BRIGADE_INSERT_TAIL(fctx->fout_tls_bb, b); |
| n += iov->iov_len; |
| } |
| fctx->fout_bytes_in_tls_bb += (apr_off_t)n; |
| rv = fout_pass_tls_to_net(fctx); |
| *out_n = n; |
| ap_log_error(APLOG_MARK, APLOG_TRACE5, rv, fctx->cc->server, |
| "tls_write_vectored_callback: %ld bytes in %d slices", (long)n, (int)count); |
| return APR_TO_OS_ERROR(rv); |
| } |
| |
| #define TLS_WRITE_VECTORED 1 |
| /** |
| * Read TLS encrypted data from <fctx->cc->rustls_connection> and pass it down |
| * Apache's filter chain to the network. |
| * |
| * For now, we always FLUSH the data, since that is what we need during handshakes. |
| */ |
| static apr_status_t fout_pass_rustls_to_tls(tls_filter_ctx_t *fctx) |
| { |
| apr_status_t rv = APR_SUCCESS; |
| |
| if (rustls_connection_wants_write(fctx->cc->rustls_connection)) { |
| size_t dlen; |
| int os_err; |
| |
| if (TLS_WRITE_VECTORED) { |
| do { |
| os_err = rustls_connection_write_tls_vectored( |
| fctx->cc->rustls_connection, tls_write_vectored_callback, fctx, &dlen); |
| if (os_err) { |
| rv = APR_FROM_OS_ERROR(os_err); |
| goto cleanup; |
| } |
| } |
| while (rustls_connection_wants_write(fctx->cc->rustls_connection)); |
| } |
| else { |
| do { |
| os_err = rustls_connection_write_tls( |
| fctx->cc->rustls_connection, tls_write_callback, fctx, &dlen); |
| if (os_err) { |
| rv = APR_FROM_OS_ERROR(os_err); |
| goto cleanup; |
| } |
| } |
| while (rustls_connection_wants_write(fctx->cc->rustls_connection)); |
| ap_log_cerror(APLOG_MARK, APLOG_TRACE3, rv, fctx->c, |
| "fout_pass_rustls_to_tls, %ld bytes ready for network", (long)fctx->fout_bytes_in_tls_bb); |
| fctx->fout_bytes_in_rustls = 0; |
| } |
| } |
| cleanup: |
| return rv; |
| } |
| |
| static apr_status_t fout_pass_buf_to_rustls( |
| tls_filter_ctx_t *fctx, const char *buf, apr_size_t len) |
| { |
| apr_status_t rv = APR_SUCCESS; |
| rustls_result rr = RUSTLS_RESULT_OK; |
| apr_size_t written; |
| |
| while (len) { |
| /* check if we will exceed the limit of data in rustls. |
| * rustls does not guarantuee that it will accept all data, so we |
| * iterate and flush when needed. */ |
| if (fctx->fout_bytes_in_rustls + (apr_off_t)len > (apr_off_t)fctx->fout_max_in_rustls) { |
| rv = fout_pass_rustls_to_tls(fctx); |
| if (APR_SUCCESS != rv) goto cleanup; |
| } |
| |
| rr = rustls_connection_write(fctx->cc->rustls_connection, |
| (const unsigned char*)buf, len, &written); |
| if (rr != RUSTLS_RESULT_OK) goto cleanup; |
| ap_assert(written <= len); |
| fctx->fout_bytes_in_rustls += (apr_off_t)written; |
| buf += written; |
| len -= written; |
| if (written == 0) { |
| rv = APR_EAGAIN; |
| ap_log_cerror(APLOG_MARK, APLOG_ERR, 0, fctx->c, APLOGNO(10357) |
| "fout_pass_buf_to_rustls: not read by rustls at all"); |
| goto cleanup; |
| } |
| } |
| cleanup: |
| if (rr != RUSTLS_RESULT_OK) { |
| const char *err_descr = ""; |
| rv = tls_core_error(fctx->c, rr, &err_descr); |
| ap_log_cerror(APLOG_MARK, APLOG_DEBUG, rv, fctx->c, APLOGNO(10358) |
| "fout_pass_buf_to_tls to rustls: [%d] %s", (int)rr, err_descr); |
| } |
| return rv; |
| } |
| |
| static apr_status_t fout_pass_all_to_tls(tls_filter_ctx_t *fctx) |
| { |
| apr_status_t rv = APR_SUCCESS; |
| |
| if (fctx->fout_buf_plain_len) { |
| rv = fout_pass_buf_to_rustls(fctx, fctx->fout_buf_plain, fctx->fout_buf_plain_len); |
| ap_log_cerror(APLOG_MARK, APLOG_TRACE2, rv, fctx->c, |
| "fout_pass_all_to_tls: %ld plain bytes written to rustls", |
| (long)fctx->fout_buf_plain_len); |
| if (APR_SUCCESS != rv) goto cleanup; |
| fctx->fout_buf_plain_len = 0; |
| } |
| |
| rv = fout_pass_rustls_to_tls(fctx); |
| cleanup: |
| return rv; |
| } |
| |
| static apr_status_t fout_pass_all_to_net(tls_filter_ctx_t *fctx, int flush) |
| { |
| apr_status_t rv; |
| |
| rv = fout_pass_all_to_tls(fctx); |
| if (APR_SUCCESS != rv) goto cleanup; |
| if (flush) { |
| apr_bucket *b = apr_bucket_flush_create(fctx->fout_tls_bb->bucket_alloc); |
| APR_BRIGADE_INSERT_TAIL(fctx->fout_tls_bb, b); |
| } |
| rv = fout_pass_tls_to_net(fctx); |
| cleanup: |
| return rv; |
| } |
| |
| static apr_status_t fout_add_bucket_to_plain(tls_filter_ctx_t *fctx, apr_bucket *b) |
| { |
| const char *data; |
| apr_size_t dlen, buf_remain; |
| apr_status_t rv = APR_SUCCESS; |
| |
| ap_assert((apr_size_t)-1 != b->length); |
| if (b->length == 0) { |
| apr_bucket_delete(b); |
| goto cleanup; |
| } |
| |
| buf_remain = fctx->fout_buf_plain_size - fctx->fout_buf_plain_len; |
| if (buf_remain == 0) { |
| rv = fout_pass_all_to_tls(fctx); |
| if (APR_SUCCESS != rv) goto cleanup; |
| buf_remain = fctx->fout_buf_plain_size - fctx->fout_buf_plain_len; |
| ap_assert(buf_remain > 0); |
| } |
| if (b->length > buf_remain) { |
| apr_bucket_split(b, buf_remain); |
| } |
| rv = apr_bucket_read(b, &data, &dlen, APR_BLOCK_READ); |
| if (APR_SUCCESS != rv) goto cleanup; |
| /*if (dlen > TLS_PREF_PLAIN_CHUNK_SIZE)*/ |
| ap_assert(dlen <= buf_remain); |
| memcpy(fctx->fout_buf_plain + fctx->fout_buf_plain_len, data, dlen); |
| fctx->fout_buf_plain_len += dlen; |
| apr_bucket_delete(b); |
| cleanup: |
| return rv; |
| } |
| |
| static apr_status_t fout_add_bucket_to_tls(tls_filter_ctx_t *fctx, apr_bucket *b) |
| { |
| apr_status_t rv; |
| |
| rv = fout_pass_all_to_tls(fctx); |
| if (APR_SUCCESS != rv) goto cleanup; |
| APR_BUCKET_REMOVE(b); |
| APR_BRIGADE_INSERT_TAIL(fctx->fout_tls_bb, b); |
| if (AP_BUCKET_IS_EOC(b)) { |
| rustls_connection_send_close_notify(fctx->cc->rustls_connection); |
| fctx->cc->state = TLS_CONN_ST_NOTIFIED; |
| rv = fout_pass_rustls_to_tls(fctx); |
| if (APR_SUCCESS != rv) goto cleanup; |
| } |
| cleanup: |
| return rv; |
| } |
| |
| static apr_status_t fout_append_plain(tls_filter_ctx_t *fctx, apr_bucket *b) |
| { |
| const char *data; |
| apr_size_t dlen, buf_remain; |
| rustls_result rr = RUSTLS_RESULT_OK; |
| apr_status_t rv = APR_SUCCESS; |
| const char *lbuf = NULL; |
| int flush = 0; |
| |
| if (b) { |
| /* if our plain buffer is full, now is a good time to flush it. */ |
| buf_remain = fctx->fout_buf_plain_size - fctx->fout_buf_plain_len; |
| if (buf_remain == 0) { |
| rv = fout_pass_all_to_tls(fctx); |
| if (APR_SUCCESS != rv) goto cleanup; |
| buf_remain = fctx->fout_buf_plain_size - fctx->fout_buf_plain_len; |
| ap_assert(buf_remain > 0); |
| } |
| |
| /* Resolve any indeterminate bucket to a "real" one by reading it. */ |
| if ((apr_size_t)-1 == b->length) { |
| rv = apr_bucket_read(b, &data, &dlen, APR_BLOCK_READ); |
| if (APR_STATUS_IS_EOF(rv)) { |
| apr_bucket_delete(b); |
| goto maybe_flush; |
| } |
| else if (APR_SUCCESS != rv) goto cleanup; |
| } |
| /* Now `b` is the bucket that we need to append and consume */ |
| if (APR_BUCKET_IS_METADATA(b)) { |
| /* outgoing buckets: |
| * [PLAINDATA META PLAINDATA META META] |
| * need to become: |
| * [TLSDATA META TLSDATA META META] |
| * because we need to send the meta buckets down the |
| * network filters. */ |
| rv = fout_add_bucket_to_tls(fctx, b); |
| flush = 1; |
| } |
| else if (b->length == 0) { |
| apr_bucket_delete(b); |
| } |
| else if (b->length < 1024 || fctx->fout_buf_plain_len > 0) { |
| /* we want to buffer small chunks to create larger TLS records and |
| * not leak security relevant information. So, we buffer small |
| * chunks and add (parts of) later, larger chunks if the plain |
| * buffer contains data. */ |
| rv = fout_add_bucket_to_plain(fctx, b); |
| if (APR_SUCCESS != rv) goto cleanup; |
| } |
| else { |
| /* we have a large chunk and our plain buffer is empty, write it |
| * directly into rustls. */ |
| #define TLS_FILE_CHUNK_SIZE 4 * TLS_PREF_PLAIN_CHUNK_SIZE |
| if (b->length > TLS_FILE_CHUNK_SIZE) { |
| apr_bucket_split(b, TLS_FILE_CHUNK_SIZE); |
| } |
| |
| if (APR_BUCKET_IS_FILE(b) |
| && (lbuf = malloc(b->length))) { |
| /* A file bucket is a most wonderous thing. Since the dawn of time, |
| * it has been subject to many optimizations for efficient handling |
| * of large data in the server: |
| * - unless one reads from it, it will just consist of a file handle |
| * and the offset+length information. |
| * - a apr_bucket_read() will transform itself to a bucket holding |
| * some 8000 bytes of data (APR_BUCKET_BUFF_SIZE), plus a following |
| * bucket that continues to hold the file handle and updated offsets/length |
| * information. |
| * Using standard bucket brigade handling, one would send 8000 bytes |
| * chunks to the network and that is fine for many occasions. |
| * - to have improved performance, the http: network handler takes |
| * the file handle directly and uses sendfile() when the OS supports it. |
| * - But there is not sendfile() for TLS (netflix did some experiments). |
| * So. |
| * rustls will try to collect max length traffic data into ont TLS |
| * message, but it can only work with what we gave it. If we give it buffers |
| * that fit what it wants to assemble already, its work is much easier. |
| * |
| * We can read file buckets in large chunks than APR_BUCKET_BUFF_SIZE, |
| * with a bit of knowledge about how they work. |
| */ |
| apr_bucket_file *f = (apr_bucket_file *)b->data; |
| apr_file_t *fd = f->fd; |
| apr_off_t offset = b->start; |
| |
| dlen = b->length; |
| rv = apr_file_seek(fd, APR_SET, &offset); |
| if (APR_SUCCESS != rv) goto cleanup; |
| rv = apr_file_read(fd, (void*)lbuf, &dlen); |
| if (APR_SUCCESS != rv && !APR_STATUS_IS_EOF(rv)) goto cleanup; |
| rv = fout_pass_buf_to_rustls(fctx, lbuf, dlen); |
| if (APR_SUCCESS != rv) goto cleanup; |
| apr_bucket_delete(b); |
| } |
| else { |
| rv = apr_bucket_read(b, &data, &dlen, APR_BLOCK_READ); |
| if (APR_SUCCESS != rv) goto cleanup; |
| rv = fout_pass_buf_to_rustls(fctx, data, dlen); |
| if (APR_SUCCESS != rv) goto cleanup; |
| apr_bucket_delete(b); |
| } |
| } |
| } |
| |
| maybe_flush: |
| if (flush) { |
| rv = fout_pass_all_to_net(fctx, 1); |
| if (APR_SUCCESS != rv) goto cleanup; |
| } |
| |
| cleanup: |
| if (lbuf) free((void*)lbuf); |
| if (rr != RUSTLS_RESULT_OK) { |
| const char *err_descr = ""; |
| rv = tls_core_error(fctx->c, rr, &err_descr); |
| ap_log_cerror(APLOG_MARK, APLOG_DEBUG, rv, fctx->c, APLOGNO(10359) |
| "write_bucket_to_rustls: [%d] %s", (int)rr, err_descr); |
| } |
| return rv; |
| } |
| |
| /** |
| * The connection filter converting plain, unencrypted traffic data into TLS |
| * encrypted bytes and send the down the Apache filter chain out to the network. |
| * |
| * <bb> the data to send, including "meta data" such as FLUSH indicators |
| * to force filters to write any data set aside (an apache term for |
| * 'buffering'). |
| * The buckets in <bb> need to be completely consumed, e.g. <bb> will be |
| * empty on a successful return. but unless FLUSHed, filters may hold |
| * buckets back internally, for various reasons. However they always |
| * need to be processed in the order they arrive. |
| */ |
| static apr_status_t filter_conn_output( |
| ap_filter_t *f, apr_bucket_brigade *bb) |
| { |
| tls_filter_ctx_t *fctx = f->ctx; |
| apr_status_t rv = APR_SUCCESS; |
| rustls_result rr = RUSTLS_RESULT_OK; |
| |
| if (f->c->aborted) { |
| ap_log_cerror(APLOG_MARK, APLOG_TRACE4, 0, fctx->c, |
| "tls_filter_conn_output: aborted conn"); |
| apr_brigade_cleanup(bb); |
| rv = APR_ECONNABORTED; goto cleanup; |
| } |
| |
| rv = progress_tls_atleast_to(fctx, TLS_CONN_ST_TRAFFIC); |
| if (APR_SUCCESS != rv) goto cleanup; /* this also leaves on APR_EAGAIN */ |
| |
| if (fctx->cc->state == TLS_CONN_ST_DONE) { |
| /* have done everything, just pass through */ |
| ap_log_cerror(APLOG_MARK, APLOG_TRACE4, 0, fctx->c, |
| "tls_filter_conn_output: tls session is already done"); |
| rv = ap_pass_brigade(f->next, bb); |
| goto cleanup; |
| } |
| |
| ap_log_error(APLOG_MARK, APLOG_TRACE2, 0, fctx->cc->server, |
| "tls_filter_conn_output, server=%s", fctx->cc->server->server_hostname); |
| if (APLOGctrace5(fctx->c)) { |
| tls_util_bb_log(fctx->c, APLOG_TRACE5, "filter_conn_output", bb); |
| } |
| |
| while (!APR_BRIGADE_EMPTY(bb)) { |
| rv = fout_append_plain(fctx, APR_BRIGADE_FIRST(bb)); |
| if (APR_SUCCESS != rv) goto cleanup; |
| } |
| |
| if (APLOGctrace5(fctx->c)) { |
| tls_util_bb_log(fctx->c, APLOG_TRACE5, "filter_conn_output, processed plain", bb); |
| tls_util_bb_log(fctx->c, APLOG_TRACE5, "filter_conn_output, tls", fctx->fout_tls_bb); |
| } |
| |
| cleanup: |
| if (rr != RUSTLS_RESULT_OK) { |
| const char *err_descr = ""; |
| rv = tls_core_error(fctx->c, rr, &err_descr); |
| ap_log_cerror(APLOG_MARK, APLOG_DEBUG, rv, fctx->c, APLOGNO(10360) |
| "tls_filter_conn_output: [%d] %s", (int)rr, err_descr); |
| } |
| else { |
| ap_log_cerror(APLOG_MARK, APLOG_TRACE2, rv, fctx->c, |
| "tls_filter_conn_output: done"); |
| } |
| return rv; |
| } |
| |
| int tls_filter_pre_conn_init(conn_rec *c) |
| { |
| tls_conf_conn_t *cc; |
| tls_filter_ctx_t *fctx; |
| |
| if (OK != tls_core_pre_conn_init(c)) { |
| return DECLINED; |
| } |
| |
| ap_log_error(APLOG_MARK, APLOG_TRACE2, 0, c->base_server, |
| "tls_filter_pre_conn_init on %s", c->base_server->server_hostname); |
| |
| cc = tls_conf_conn_get(c); |
| ap_assert(cc); |
| |
| fctx = apr_pcalloc(c->pool, sizeof(*fctx)); |
| fctx->c = c; |
| fctx->cc = cc; |
| cc->filter_ctx = fctx; |
| |
| /* a bit tricky: registering out filters returns the ap_filter_t* |
| * that it created for it. The ->next field points always |
| * to the filter "below" our filter. That will be other registered |
| * filters and last, but not least, the network filter on the socket. |
| * |
| * Therefore, wenn we need to read/write TLS data during handshake, we can |
| * pass the data to/call on ->next- Since ->next can change during the setup of |
| * a connections (other modules register also sth.), we keep the ap_filter_t* |
| * returned here, since httpd core will update the ->next whenever someone |
| * adds a filter or removes one. This can potentially happen all the time. |
| */ |
| fctx->fin_ctx = ap_add_input_filter(TLS_FILTER_RAW, fctx, NULL, c); |
| fctx->fin_tls_bb = apr_brigade_create(c->pool, c->bucket_alloc); |
| fctx->fin_tls_buffer_bb = NULL; |
| fctx->fin_plain_bb = apr_brigade_create(c->pool, c->bucket_alloc); |
| fctx->fout_ctx = ap_add_output_filter(TLS_FILTER_RAW, fctx, NULL, c); |
| fctx->fout_tls_bb = apr_brigade_create(c->pool, c->bucket_alloc); |
| fctx->fout_buf_plain_size = APR_BUCKET_BUFF_SIZE; |
| fctx->fout_buf_plain = apr_pcalloc(c->pool, fctx->fout_buf_plain_size); |
| fctx->fout_buf_plain_len = 0; |
| |
| /* Let the filters have 2 max-length TLS Messages in the rustls buffers. |
| * The effects we would like to achieve here are: |
| * 1. pass data out, so that every bucket becomes its own TLS message. |
| * This hides, if possible, the length of response parts. |
| * If we give rustls enough plain data, it will use the max TLS message |
| * size and things are more hidden. But we can only write what the application |
| * or protocol gives us. |
| * 2. max length records result in less overhead for all layers involved. |
| * 3. a TLS message from the client can only be decrypted when it has |
| * completely arrived. If we provide rustls with enough data (if the |
| * network has it for us), it should always be able to decrypt at least |
| * one TLS message and we have plain bytes to forward to the protocol |
| * handler. |
| */ |
| fctx->fin_max_in_rustls = 4 * TLS_REC_MAX_SIZE; |
| fctx->fout_max_in_rustls = 4 * TLS_PREF_PLAIN_CHUNK_SIZE; |
| fctx->fout_auto_flush_size = 2 * TLS_REC_MAX_SIZE; |
| |
| return OK; |
| } |
| |
| void tls_filter_conn_init(conn_rec *c) |
| { |
| tls_conf_conn_t *cc = tls_conf_conn_get(c); |
| |
| if (cc && cc->filter_ctx && !cc->outgoing) { |
| /* We are one in a row of hooks that - possibly - want to process this |
| * connection, the (HTTP) protocol handlers among them. |
| * |
| * For incoming connections, we need to select the protocol to use NOW, |
| * so that the later protocol handlers do the right thing. |
| * Send an INIT down the input filter chain to trigger the TLS handshake, |
| * which will select a protocol via ALPN. */ |
| apr_bucket_brigade* temp; |
| |
| ap_log_error(APLOG_MARK, APLOG_TRACE2, 0, c->base_server, |
| "tls_filter_conn_init on %s, triggering handshake", c->base_server->server_hostname); |
| temp = apr_brigade_create(c->pool, c->bucket_alloc); |
| ap_get_brigade(c->input_filters, temp, AP_MODE_INIT, APR_BLOCK_READ, 0); |
| apr_brigade_destroy(temp); |
| } |
| } |
| |
| void tls_filter_register( |
| apr_pool_t *pool) |
| { |
| (void)pool; |
| ap_register_input_filter(TLS_FILTER_RAW, filter_conn_input, NULL, AP_FTYPE_CONNECTION + 5); |
| ap_register_output_filter(TLS_FILTER_RAW, filter_conn_output, NULL, AP_FTYPE_CONNECTION + 5); |
| } |
