X-Git-Url: https://git.openssl.org/?p=openssl.git;a=blobdiff_plain;f=ssl%2Frecord%2Frec_layer_s3.c;h=dabb02cf1b021438f2810ed663b582ef6379934d;hp=8adb3cdd08e6cc3d8544c4f0a2af95f37d4d534f;hb=bd990e2535ca387def9a01218a813dc3fa547e3c;hpb=e60ce9c4513c432705c84b0efebf1421ee769eee diff --git a/ssl/record/rec_layer_s3.c b/ssl/record/rec_layer_s3.c index 8adb3cdd08..dabb02cf1b 100644 --- a/ssl/record/rec_layer_s3.c +++ b/ssl/record/rec_layer_s3.c @@ -8,6 +8,7 @@ */ #include +#include #include #include #define USE_SOCKETS @@ -16,10 +17,7 @@ #include #include #include "record_locl.h" - -#ifndef EVP_CIPH_FLAG_TLS1_1_MULTIBLOCK -# define EVP_CIPH_FLAG_TLS1_1_MULTIBLOCK 0 -#endif +#include "../packet_locl.h" #if defined(OPENSSL_SMALL_FOOTPRINT) || \ !( defined(AES_ASM) && ( \ @@ -39,8 +37,6 @@ void RECORD_LAYER_init(RECORD_LAYER *rl, SSL *s) void RECORD_LAYER_clear(RECORD_LAYER *rl) { - unsigned int pipes; - rl->rstate = SSL_ST_READ_HEADER; /* @@ -52,8 +48,6 @@ void RECORD_LAYER_clear(RECORD_LAYER *rl) rl->packet = NULL; rl->packet_length = 0; rl->wnum = 0; - memset(rl->alert_fragment, 0, sizeof(rl->alert_fragment)); - rl->alert_fragment_len = 0; memset(rl->handshake_fragment, 0, sizeof(rl->handshake_fragment)); rl->handshake_fragment_len = 0; rl->wpend_tot = 0; @@ -62,9 +56,7 @@ void RECORD_LAYER_clear(RECORD_LAYER *rl) rl->wpend_buf = NULL; SSL3_BUFFER_clear(&rl->rbuf); - for (pipes = 0; pipes < rl->numwpipes; pipes++) - SSL3_BUFFER_clear(&rl->wbuf[pipes]); - rl->numwpipes = 0; + ssl3_release_write_buffer(rl->s); rl->numrpipes = 0; SSL3_RECORD_clear(rl->rrec, SSL_MAX_PIPELINES); @@ -84,32 +76,28 @@ void RECORD_LAYER_release(RECORD_LAYER *rl) SSL3_RECORD_release(rl->rrec, SSL_MAX_PIPELINES); } +/* Checks if we have unprocessed read ahead data pending */ int RECORD_LAYER_read_pending(const RECORD_LAYER *rl) { return SSL3_BUFFER_get_left(&rl->rbuf) != 0; } -int RECORD_LAYER_write_pending(const RECORD_LAYER *rl) +/* Checks if we have decrypted unread record data pending */ +int RECORD_LAYER_processed_read_pending(const RECORD_LAYER *rl) { - return (rl->numwpipes > 0) - && SSL3_BUFFER_get_left(&rl->wbuf[rl->numwpipes - 1]) != 0; -} + size_t curr_rec = 0, num_recs = RECORD_LAYER_get_numrpipes(rl); + const SSL3_RECORD *rr = rl->rrec; -int RECORD_LAYER_set_data(RECORD_LAYER *rl, const unsigned char *buf, - size_t len) -{ - rl->packet_length = len; - if (len != 0) { - rl->rstate = SSL_ST_READ_HEADER; - if (!SSL3_BUFFER_is_initialised(&rl->rbuf)) - if (!ssl3_setup_read_buffer(rl->s)) - return 0; - } + while (curr_rec < num_recs && SSL3_RECORD_is_read(&rr[curr_rec])) + curr_rec++; - rl->packet = SSL3_BUFFER_get_buf(&rl->rbuf); - SSL3_BUFFER_set_data(&rl->rbuf, buf, len); + return curr_rec < num_recs; +} - return 1; +int RECORD_LAYER_write_pending(const RECORD_LAYER *rl) +{ + return (rl->numwpipes > 0) + && SSL3_BUFFER_get_left(&rl->wbuf[rl->numwpipes - 1]) != 0; } void RECORD_LAYER_reset_read_sequence(RECORD_LAYER *rl) @@ -367,14 +355,25 @@ int ssl3_write_bytes(SSL *s, int type, const void *buf_, size_t len, * promptly send beyond the end of the users buffer ... so we trap and * report the error in a way the user will notice */ - if (len < s->rlayer.wnum) { + if ((len < s->rlayer.wnum) + || ((wb->left != 0) && (len < (s->rlayer.wnum + s->rlayer.wpend_tot)))) { SSLerr(SSL_F_SSL3_WRITE_BYTES, SSL_R_BAD_LENGTH); return -1; } + if (s->early_data_state == SSL_EARLY_DATA_WRITING + && !early_data_count_ok(s, len, 0, NULL)) + return -1; + s->rlayer.wnum = 0; - if (SSL_in_init(s) && !ossl_statem_get_in_handshake(s)) { + /* + * When writing early data on the server side we could be "in_init" in + * between receiving the EoED and the CF - but we don't want to handle those + * messages yet. + */ + if (SSL_in_init(s) && !ossl_statem_get_in_handshake(s) + && s->early_data_state != SSL_EARLY_DATA_UNAUTH_WRITING) { i = s->handshake_func(s); if (i < 0) return i; @@ -408,7 +407,7 @@ int ssl3_write_bytes(SSL *s, int type, const void *buf_, size_t len, if (type == SSL3_RT_APPLICATION_DATA && len >= 4 * (max_send_fragment = s->max_send_fragment) && s->compress == NULL && s->msg_callback == NULL && - !SSL_USE_ETM(s) && SSL_USE_EXPLICIT_IV(s) && + !SSL_WRITE_ETM(s) && SSL_USE_EXPLICIT_IV(s) && EVP_CIPHER_flags(EVP_CIPHER_CTX_cipher(s->enc_write_ctx)) & EVP_CIPH_FLAG_TLS1_1_MULTIBLOCK) { unsigned char aad[13]; @@ -635,10 +634,12 @@ int do_ssl3_write(SSL *s, int type, const unsigned char *buf, { WPACKET pkt[SSL_MAX_PIPELINES]; SSL3_RECORD wr[SSL_MAX_PIPELINES]; + WPACKET *thispkt; + SSL3_RECORD *thiswr; unsigned char *recordstart; int i, mac_size, clear = 0; size_t prefix_len = 0; - int eivlen; + int eivlen = 0; size_t align = 0; SSL3_BUFFER *wb; SSL_SESSION *sess; @@ -737,7 +738,8 @@ int do_ssl3_write(SSL *s, int type, const unsigned char *buf, wpinited = 1; } else if (prefix_len) { wb = &s->rlayer.wbuf[0]; - if (!WPACKET_init_static_len(&pkt[0], SSL3_BUFFER_get_buf(wb), + if (!WPACKET_init_static_len(&pkt[0], + SSL3_BUFFER_get_buf(wb), SSL3_BUFFER_get_len(wb), 0) || !WPACKET_allocate_bytes(&pkt[0], SSL3_BUFFER_get_offset(wb) + prefix_len, NULL)) { @@ -747,15 +749,17 @@ int do_ssl3_write(SSL *s, int type, const unsigned char *buf, wpinited = 1; } else { for (j = 0; j < numpipes; j++) { + thispkt = &pkt[j]; + wb = &s->rlayer.wbuf[j]; -#if defined(SSL3_ALIGN_PAYLOAD) && SSL3_ALIGN_PAYLOAD!=0 +#if defined(SSL3_ALIGN_PAYLOAD) && SSL3_ALIGN_PAYLOAD != 0 align = (size_t)SSL3_BUFFER_get_buf(wb) + SSL3_RT_HEADER_LENGTH; align = SSL3_ALIGN_PAYLOAD - 1 - ((align - 1) % SSL3_ALIGN_PAYLOAD); #endif SSL3_BUFFER_set_offset(wb, align); - if (!WPACKET_init_static_len(&pkt[j], SSL3_BUFFER_get_buf(wb), + if (!WPACKET_init_static_len(thispkt, SSL3_BUFFER_get_buf(wb), SSL3_BUFFER_get_len(wb), 0) - || !WPACKET_allocate_bytes(&pkt[j], align, NULL)) { + || !WPACKET_allocate_bytes(thispkt, align, NULL)) { SSLerr(SSL_F_DO_SSL3_WRITE, ERR_R_INTERNAL_ERROR); goto err; } @@ -764,7 +768,7 @@ int do_ssl3_write(SSL *s, int type, const unsigned char *buf, } /* Explicit IV length, block ciphers appropriate version flag */ - if (s->enc_write_ctx && SSL_USE_EXPLICIT_IV(s)) { + if (s->enc_write_ctx && SSL_USE_EXPLICIT_IV(s) && !SSL_TREAT_AS_TLS13(s)) { int mode = EVP_CIPHER_CTX_mode(s->enc_write_ctx); if (mode == EVP_CIPH_CBC_MODE) { /* TODO(size_t): Convert me */ @@ -776,28 +780,27 @@ int do_ssl3_write(SSL *s, int type, const unsigned char *buf, eivlen = EVP_GCM_TLS_EXPLICIT_IV_LEN; } else if (mode == EVP_CIPH_CCM_MODE) { eivlen = EVP_CCM_TLS_EXPLICIT_IV_LEN; - } else { - eivlen = 0; } - } else { - eivlen = 0; } totlen = 0; /* Clear our SSL3_RECORD structures */ memset(wr, 0, sizeof wr); for (j = 0; j < numpipes; j++) { - unsigned int version = s->version; - unsigned char *compressdata; + unsigned int version = SSL_TREAT_AS_TLS13(s) ? TLS1_VERSION : s->version; + unsigned char *compressdata = NULL; size_t maxcomplen; unsigned int rectype; - SSL3_RECORD_set_type(&wr[j], type); + thispkt = &pkt[j]; + thiswr = &wr[j]; + + SSL3_RECORD_set_type(thiswr, type); /* * In TLSv1.3, once encrypting, we always use application data for the * record type */ - if (SSL_IS_TLS13(s) && s->enc_write_ctx != NULL) + if (SSL_TREAT_AS_TLS13(s) && s->enc_write_ctx != NULL) rectype = SSL3_RT_APPLICATION_DATA; else rectype = type; @@ -809,29 +812,32 @@ int do_ssl3_write(SSL *s, int type, const unsigned char *buf, && !s->renegotiate && TLS1_get_version(s) > TLS1_VERSION) version = TLS1_VERSION; - maxcomplen = pipelens[j] + (ssl_allow_compression(s) - ? SSL3_RT_MAX_COMPRESSED_OVERHEAD : 0); + maxcomplen = pipelens[j]; + if (s->compress != NULL) + maxcomplen += SSL3_RT_MAX_COMPRESSED_OVERHEAD; + /* write the header */ - if (!WPACKET_put_bytes_u8(&pkt[j], rectype) - || !WPACKET_put_bytes_u16(&pkt[j], version) - || !WPACKET_start_sub_packet_u16(&pkt[j]) + if (!WPACKET_put_bytes_u8(thispkt, rectype) + || !WPACKET_put_bytes_u16(thispkt, version) + || !WPACKET_start_sub_packet_u16(thispkt) || (eivlen > 0 - && !WPACKET_allocate_bytes(&pkt[j], eivlen, NULL)) + && !WPACKET_allocate_bytes(thispkt, eivlen, NULL)) || (maxcomplen > 0 - && !WPACKET_reserve_bytes(&pkt[j], maxcomplen, + && !WPACKET_reserve_bytes(thispkt, maxcomplen, &compressdata))) { SSLerr(SSL_F_DO_SSL3_WRITE, ERR_R_INTERNAL_ERROR); goto err; } /* lets setup the record stuff. */ - SSL3_RECORD_set_data(&wr[j], compressdata); - SSL3_RECORD_set_length(&wr[j], pipelens[j]); - SSL3_RECORD_set_input(&wr[j], (unsigned char *)&buf[totlen]); + SSL3_RECORD_set_data(thiswr, compressdata); + SSL3_RECORD_set_length(thiswr, pipelens[j]); + SSL3_RECORD_set_input(thiswr, (unsigned char *)&buf[totlen]); totlen += pipelens[j]; /* - * we now 'read' from wr->input, wr->length bytes into wr->data + * we now 'read' from thiswr->input, thiswr->length bytes into + * thiswr->data */ /* first we compress */ @@ -839,42 +845,74 @@ int do_ssl3_write(SSL *s, int type, const unsigned char *buf, /* * TODO(TLS1.3): Make sure we prevent compression!!! */ - if (!ssl3_do_compress(s, &wr[j]) - || !WPACKET_allocate_bytes(&pkt[j], wr[j].length, NULL)) { + if (!ssl3_do_compress(s, thiswr) + || !WPACKET_allocate_bytes(thispkt, thiswr->length, NULL)) { SSLerr(SSL_F_DO_SSL3_WRITE, SSL_R_COMPRESSION_FAILURE); goto err; } } else { - if (!WPACKET_memcpy(&pkt[j], wr[j].input, wr[j].length)) { + if (!WPACKET_memcpy(thispkt, thiswr->input, thiswr->length)) { SSLerr(SSL_F_DO_SSL3_WRITE, ERR_R_INTERNAL_ERROR); goto err; } SSL3_RECORD_reset_input(&wr[j]); } - if (SSL_IS_TLS13(s) && s->enc_write_ctx != NULL) { - if (!WPACKET_put_bytes_u8(&pkt[j], type)) { + if (SSL_TREAT_AS_TLS13(s) && s->enc_write_ctx != NULL) { + size_t rlen; + + if (!WPACKET_put_bytes_u8(thispkt, type)) { SSLerr(SSL_F_DO_SSL3_WRITE, ERR_R_INTERNAL_ERROR); goto err; } - SSL3_RECORD_add_length(&wr[j], 1); - /* - * TODO(TLS1.3): Padding goes here. Do we need an API to add this? - * For now, use no padding - */ + SSL3_RECORD_add_length(thiswr, 1); + + /* Add TLS1.3 padding */ + rlen = SSL3_RECORD_get_length(thiswr); + if (rlen < SSL3_RT_MAX_PLAIN_LENGTH) { + size_t padding = 0; + size_t max_padding = SSL3_RT_MAX_PLAIN_LENGTH - rlen; + if (s->record_padding_cb != NULL) { + padding = s->record_padding_cb(s, type, rlen, s->record_padding_arg); + } else if (s->block_padding > 0) { + size_t mask = s->block_padding - 1; + size_t remainder; + + /* optimize for power of 2 */ + if ((s->block_padding & mask) == 0) + remainder = rlen & mask; + else + remainder = rlen % s->block_padding; + /* don't want to add a block of padding if we don't have to */ + if (remainder == 0) + padding = 0; + else + padding = s->block_padding - remainder; + } + if (padding > 0) { + /* do not allow the record to exceed max plaintext length */ + if (padding > max_padding) + padding = max_padding; + if (!WPACKET_memset(thispkt, 0, padding)) { + SSLerr(SSL_F_DO_SSL3_WRITE, ERR_R_INTERNAL_ERROR); + goto err; + } + SSL3_RECORD_add_length(thiswr, padding); + } + } } /* - * we should still have the output to wr->data and the input from - * wr->input. Length should be wr->length. wr->data still points in the - * wb->buf + * we should still have the output to thiswr->data and the input from + * wr->input. Length should be thiswr->length. thiswr->data still points + * in the wb->buf */ - if (!SSL_USE_ETM(s) && mac_size != 0) { + if (!SSL_WRITE_ETM(s) && mac_size != 0) { unsigned char *mac; - if (!WPACKET_allocate_bytes(&pkt[j], mac_size, &mac) - || !s->method->ssl3_enc->mac(s, &wr[j], mac, 1)) { + if (!WPACKET_allocate_bytes(thispkt, mac_size, &mac) + || !s->method->ssl3_enc->mac(s, thiswr, mac, 1)) { SSLerr(SSL_F_DO_SSL3_WRITE, ERR_R_INTERNAL_ERROR); goto err; } @@ -885,78 +923,98 @@ int do_ssl3_write(SSL *s, int type, const unsigned char *buf, * This will be at most one cipher block or the tag length if using * AEAD. SSL_RT_MAX_CIPHER_BLOCK_SIZE covers either case. */ - if(!WPACKET_reserve_bytes(&pkt[j], SSL_RT_MAX_CIPHER_BLOCK_SIZE, + if(!WPACKET_reserve_bytes(thispkt, SSL_RT_MAX_CIPHER_BLOCK_SIZE, NULL) /* * We also need next the amount of bytes written to this * sub-packet */ - || !WPACKET_get_length(&pkt[j], &len)) { + || !WPACKET_get_length(thispkt, &len)) { SSLerr(SSL_F_DO_SSL3_WRITE, ERR_R_INTERNAL_ERROR); goto err; } /* Get a pointer to the start of this record excluding header */ - recordstart = WPACKET_get_curr(&pkt[j]) - len; + recordstart = WPACKET_get_curr(thispkt) - len; - SSL3_RECORD_set_data(&wr[j], recordstart); - SSL3_RECORD_reset_input(&wr[j]); - SSL3_RECORD_set_length(&wr[j], len); + SSL3_RECORD_set_data(thiswr, recordstart); + SSL3_RECORD_reset_input(thiswr); + SSL3_RECORD_set_length(thiswr, len); } - if (s->method->ssl3_enc->enc(s, wr, numpipes, 1) < 1) - goto err; + if (s->early_data_state == SSL_EARLY_DATA_WRITING + || s->early_data_state == SSL_EARLY_DATA_WRITE_RETRY) { + /* + * We haven't actually negotiated the version yet, but we're trying to + * send early data - so we need to use the the tls13enc function. + */ + if (tls13_enc(s, wr, numpipes, 1) < 1) + goto err; + } else { + if (s->method->ssl3_enc->enc(s, wr, numpipes, 1) < 1) + goto err; + } for (j = 0; j < numpipes; j++) { size_t origlen; + thispkt = &pkt[j]; + thiswr = &wr[j]; + /* Allocate bytes for the encryption overhead */ - if (!WPACKET_get_length(&pkt[j], &origlen) + if (!WPACKET_get_length(thispkt, &origlen) /* Encryption should never shrink the data! */ - || origlen > wr[j].length - || (wr[j].length > origlen - && !WPACKET_allocate_bytes(&pkt[j], - wr[j].length - origlen, NULL))) { + || origlen > thiswr->length + || (thiswr->length > origlen + && !WPACKET_allocate_bytes(thispkt, + thiswr->length - origlen, NULL))) { SSLerr(SSL_F_DO_SSL3_WRITE, ERR_R_INTERNAL_ERROR); goto err; } - if (SSL_USE_ETM(s) && mac_size != 0) { + if (SSL_WRITE_ETM(s) && mac_size != 0) { unsigned char *mac; - if (!WPACKET_allocate_bytes(&pkt[j], mac_size, &mac) - || !s->method->ssl3_enc->mac(s, &wr[j], mac, 1)) { + if (!WPACKET_allocate_bytes(thispkt, mac_size, &mac) + || !s->method->ssl3_enc->mac(s, thiswr, mac, 1)) { SSLerr(SSL_F_DO_SSL3_WRITE, ERR_R_INTERNAL_ERROR); goto err; } - SSL3_RECORD_add_length(&wr[j], mac_size); + SSL3_RECORD_add_length(thiswr, mac_size); } - if (!WPACKET_get_length(&pkt[j], &len) - || !WPACKET_close(&pkt[j])) { + if (!WPACKET_get_length(thispkt, &len) + || !WPACKET_close(thispkt)) { SSLerr(SSL_F_DO_SSL3_WRITE, ERR_R_INTERNAL_ERROR); goto err; } if (s->msg_callback) { - recordstart = WPACKET_get_curr(&pkt[j]) - len + recordstart = WPACKET_get_curr(thispkt) - len - SSL3_RT_HEADER_LENGTH; s->msg_callback(1, 0, SSL3_RT_HEADER, recordstart, SSL3_RT_HEADER_LENGTH, s, s->msg_callback_arg); + + if (SSL_TREAT_AS_TLS13(s) && s->enc_write_ctx != NULL) { + unsigned char ctype = type; + + s->msg_callback(1, s->version, SSL3_RT_INNER_CONTENT_TYPE, + &ctype, 1, s, s->msg_callback_arg); + } } - if (!WPACKET_finish(&pkt[j])) { + if (!WPACKET_finish(thispkt)) { SSLerr(SSL_F_DO_SSL3_WRITE, ERR_R_INTERNAL_ERROR); goto err; } /* - * we should now have wr->data pointing to the encrypted data, which is - * wr->length long + * we should now have thiswr->data pointing to the encrypted data, which + * is thiswr->length long */ - SSL3_RECORD_set_type(&wr[j], type); /* not needed but helps for + SSL3_RECORD_set_type(thiswr, type); /* not needed but helps for * debugging */ - SSL3_RECORD_add_length(&wr[j], SSL3_RT_HEADER_LENGTH); + SSL3_RECORD_add_length(thiswr, SSL3_RT_HEADER_LENGTH); if (create_empty_fragment) { /* @@ -968,13 +1026,13 @@ int do_ssl3_write(SSL *s, int type, const unsigned char *buf, SSLerr(SSL_F_DO_SSL3_WRITE, ERR_R_INTERNAL_ERROR); goto err; } - *written = SSL3_RECORD_get_length(wr); + *written = SSL3_RECORD_get_length(thiswr); return 1; } /* now let's set up wb */ SSL3_BUFFER_set_left(&s->rlayer.wbuf[j], - prefix_len + SSL3_RECORD_get_length(&wr[j])); + prefix_len + SSL3_RECORD_get_length(thiswr)); } /* @@ -1221,7 +1279,8 @@ int ssl3_read_bytes(SSL *s, int type, int *recvd_type, unsigned char *buf, if (type == SSL3_RECORD_get_type(rr) || (SSL3_RECORD_get_type(rr) == SSL3_RT_CHANGE_CIPHER_SPEC - && type == SSL3_RT_HANDSHAKE && recvd_type != NULL)) { + && type == SSL3_RT_HANDSHAKE && recvd_type != NULL + && !SSL_IS_TLS13(s))) { /* * SSL3_RT_APPLICATION_DATA or * SSL3_RT_HANDSHAKE or @@ -1342,10 +1401,6 @@ int ssl3_read_bytes(SSL *s, int type, int *recvd_type, unsigned char *buf, dest_maxlen = sizeof s->rlayer.handshake_fragment; dest = s->rlayer.handshake_fragment; dest_len = &s->rlayer.handshake_fragment_len; - } else if (SSL3_RECORD_get_type(rr) == SSL3_RT_ALERT) { - dest_maxlen = sizeof s->rlayer.alert_fragment; - dest = s->rlayer.alert_fragment; - dest_len = &s->rlayer.alert_fragment_len; } if (dest_maxlen > 0) { @@ -1354,84 +1409,24 @@ int ssl3_read_bytes(SSL *s, int type, int *recvd_type, unsigned char *buf, n = SSL3_RECORD_get_length(rr); /* available bytes */ /* now move 'n' bytes: */ - while (n-- > 0) { - dest[(*dest_len)++] = - SSL3_RECORD_get_data(rr)[SSL3_RECORD_get_off(rr)]; - SSL3_RECORD_add_off(rr, 1); - SSL3_RECORD_add_length(rr, -1); - } - - if (*dest_len < dest_maxlen) { + memcpy(dest + *dest_len, + SSL3_RECORD_get_data(rr) + SSL3_RECORD_get_off(rr), n); + SSL3_RECORD_add_off(rr, n); + SSL3_RECORD_add_length(rr, -n); + *dest_len += n; + if (SSL3_RECORD_get_length(rr) == 0) SSL3_RECORD_set_read(rr); + + if (*dest_len < dest_maxlen) goto start; /* fragment was too small */ - } } } /*- * s->rlayer.handshake_fragment_len == 4 iff rr->type == SSL3_RT_HANDSHAKE; - * s->rlayer.alert_fragment_len == 2 iff rr->type == SSL3_RT_ALERT. * (Possibly rr is 'empty' now, i.e. rr->length may be 0.) */ - /* If we are a client, check for an incoming 'Hello Request': */ - if ((!s->server) && - (s->rlayer.handshake_fragment_len >= 4) && - (s->rlayer.handshake_fragment[0] == SSL3_MT_HELLO_REQUEST) && - (s->session != NULL) && (s->session->cipher != NULL)) { - s->rlayer.handshake_fragment_len = 0; - - if ((s->rlayer.handshake_fragment[1] != 0) || - (s->rlayer.handshake_fragment[2] != 0) || - (s->rlayer.handshake_fragment[3] != 0)) { - al = SSL_AD_DECODE_ERROR; - SSLerr(SSL_F_SSL3_READ_BYTES, SSL_R_BAD_HELLO_REQUEST); - goto f_err; - } - - if (s->msg_callback) - s->msg_callback(0, s->version, SSL3_RT_HANDSHAKE, - s->rlayer.handshake_fragment, 4, s, - s->msg_callback_arg); - - if (SSL_is_init_finished(s) && - !(s->s3->flags & SSL3_FLAGS_NO_RENEGOTIATE_CIPHERS) && - !s->s3->renegotiate) { - ssl3_renegotiate(s); - if (ssl3_renegotiate_check(s)) { - i = s->handshake_func(s); - if (i < 0) - return i; - if (i == 0) { - SSLerr(SSL_F_SSL3_READ_BYTES, SSL_R_SSL_HANDSHAKE_FAILURE); - return -1; - } - - if (!(s->mode & SSL_MODE_AUTO_RETRY)) { - if (SSL3_BUFFER_get_left(rbuf) == 0) { - /* no read-ahead left? */ - BIO *bio; - /* - * In the case where we try to read application data, - * but we trigger an SSL handshake, we return -1 with - * the retry option set. Otherwise renegotiation may - * cause nasty problems in the blocking world - */ - s->rwstate = SSL_READING; - bio = SSL_get_rbio(s); - BIO_clear_retry_flags(bio); - BIO_set_retry_read(bio); - return -1; - } - } - } - } - /* - * we either finished a handshake or ignored the request, now try - * again to obtain the (application) data we were asked for - */ - goto start; - } /* * If we are a server and get a client hello when renegotiation isn't * allowed send back a no renegotiation alert and carry on. WARNING: @@ -1441,6 +1436,7 @@ int ssl3_read_bytes(SSL *s, int type, int *recvd_type, unsigned char *buf, SSL_is_init_finished(s) && !s->s3->send_connection_binding && (s->version > SSL3_VERSION) && + !SSL_IS_TLS13(s) && (s->rlayer.handshake_fragment_len >= 4) && (s->rlayer.handshake_fragment[0] == SSL3_MT_CLIENT_HELLO) && (s->session != NULL) && (s->session->cipher != NULL) && @@ -1450,15 +1446,23 @@ int ssl3_read_bytes(SSL *s, int type, int *recvd_type, unsigned char *buf, ssl3_send_alert(s, SSL3_AL_WARNING, SSL_AD_NO_RENEGOTIATION); goto start; } - if (s->rlayer.alert_fragment_len >= 2) { - int alert_level = s->rlayer.alert_fragment[0]; - int alert_descr = s->rlayer.alert_fragment[1]; - - s->rlayer.alert_fragment_len = 0; + if (SSL3_RECORD_get_type(rr) == SSL3_RT_ALERT) { + unsigned int alert_level, alert_descr; + unsigned char *alert_bytes = SSL3_RECORD_get_data(rr) + + SSL3_RECORD_get_off(rr); + PACKET alert; + + if (!PACKET_buf_init(&alert, alert_bytes, SSL3_RECORD_get_length(rr)) + || !PACKET_get_1(&alert, &alert_level) + || !PACKET_get_1(&alert, &alert_descr) + || PACKET_remaining(&alert) != 0) { + al = SSL_AD_UNEXPECTED_MESSAGE; + SSLerr(SSL_F_SSL3_READ_BYTES, SSL_R_INVALID_ALERT); + goto f_err; + } if (s->msg_callback) - s->msg_callback(0, s->version, SSL3_RT_ALERT, - s->rlayer.alert_fragment, 2, s, + s->msg_callback(0, s->version, SSL3_RT_ALERT, alert_bytes, 2, s, s->msg_callback_arg); if (s->info_callback != NULL) @@ -1486,6 +1490,15 @@ int ssl3_read_bytes(SSL *s, int type, int *recvd_type, unsigned char *buf, s->shutdown |= SSL_RECEIVED_SHUTDOWN; return 0; } + /* + * Apart from close_notify the only other warning alert in TLSv1.3 + * is user_cancelled - which we just ignore. + */ + if (SSL_IS_TLS13(s) && alert_descr != SSL_AD_USER_CANCELLED) { + al = SSL_AD_ILLEGAL_PARAMETER; + SSLerr(SSL_F_SSL3_READ_BYTES, SSL_R_UNKNOWN_ALERT_TYPE); + goto f_err; + } /* * This is a warning but we receive it if we requested * renegotiation and the peer denied it. Terminate with a fatal @@ -1494,15 +1507,11 @@ int ssl3_read_bytes(SSL *s, int type, int *recvd_type, unsigned char *buf, * future we might have a renegotiation where we don't care if * the peer refused it where we carry on. */ - else if (alert_descr == SSL_AD_NO_RENEGOTIATION) { + if (alert_descr == SSL_AD_NO_RENEGOTIATION) { al = SSL_AD_HANDSHAKE_FAILURE; SSLerr(SSL_F_SSL3_READ_BYTES, SSL_R_NO_RENEGOTIATION); goto f_err; } -#ifdef SSL_AD_MISSING_SRP_USERNAME - else if (alert_descr == SSL_AD_MISSING_SRP_USERNAME) - return (0); -#endif } else if (alert_level == SSL3_AL_FATAL) { char tmp[16]; @@ -1539,16 +1548,16 @@ int ssl3_read_bytes(SSL *s, int type, int *recvd_type, unsigned char *buf, } /* - * Unexpected handshake message (Client Hello, or protocol violation) + * Unexpected handshake message (ClientHello, NewSessionTicket (TLS1.3) or + * protocol violation) */ if ((s->rlayer.handshake_fragment_len >= 4) - && !ossl_statem_get_in_handshake(s)) { - if (SSL_is_init_finished(s) && - !(s->s3->flags & SSL3_FLAGS_NO_RENEGOTIATE_CIPHERS)) { - ossl_statem_set_in_init(s, 1); - s->renegotiate = 1; - s->new_session = 1; - } + && !ossl_statem_get_in_handshake(s)) { + int ined = (s->early_data_state == SSL_EARLY_DATA_READING); + + /* We found handshake data, so we're going back into init */ + ossl_statem_set_in_init(s, 1); + i = s->handshake_func(s); if (i < 0) return i; @@ -1557,6 +1566,14 @@ int ssl3_read_bytes(SSL *s, int type, int *recvd_type, unsigned char *buf, return -1; } + /* + * If we were actually trying to read early data and we found a + * handshake message, then we don't want to continue to try and read + * the application data any more. It won't be "early" now. + */ + if (ined) + return -1; + if (!(s->mode & SSL_MODE_AUTO_RETRY)) { if (SSL3_BUFFER_get_left(rbuf) == 0) { /* no read-ahead left? */ @@ -1611,6 +1628,21 @@ int ssl3_read_bytes(SSL *s, int type, int *recvd_type, unsigned char *buf, if (ossl_statem_app_data_allowed(s)) { s->s3->in_read_app_data = 2; return -1; + } else if (ossl_statem_skip_early_data(s)) { + /* + * This can happen after a client sends a CH followed by early_data, + * but the server responds with a HelloRetryRequest. The server + * reads the next record from the client expecting to find a + * plaintext ClientHello but gets a record which appears to be + * application data. The trial decrypt "works" because null + * decryption was applied. We just skip it and move on to the next + * record. + */ + if (!early_data_count_ok(s, rr->length, + EARLY_DATA_CIPHERTEXT_OVERHEAD, &al)) + goto f_err; + SSL3_RECORD_set_read(rr); + goto start; } else { al = SSL_AD_UNEXPECTED_MESSAGE; SSLerr(SSL_F_SSL3_READ_BYTES, SSL_R_UNEXPECTED_RECORD);