Commit c2853382 authored by Matt Caswell's avatar Matt Caswell
Browse files

More record layer conversions to use SSLfatal() 



Reviewed-by: default avatarRich Salz <rsalz@openssl.org>
(Merged from https://github.com/openssl/openssl/pull/4841)
parent 99dd3740

ssl/d1_lib.c

+6 −2
Original line number Diff line number Diff line
@@ -378,7 +378,8 @@ int dtls1_check_timeout_num(SSL *s) 


    if (s->d1->timeout.num_alerts > DTLS1_TMO_ALERT_COUNT) {

        /* fail the connection, enough alerts have been sent */

        SSLerr(SSL_F_DTLS1_CHECK_TIMEOUT_NUM, SSL_R_READ_TIMEOUT_EXPIRED);

        SSLfatal(s, SSL_AD_NO_ALERT, SSL_F_DTLS1_CHECK_TIMEOUT_NUM,

                 SSL_R_READ_TIMEOUT_EXPIRED);

        return -1;

    }
@@ -397,8 +398,10 @@ int dtls1_handle_timeout(SSL *s) 
    else

        dtls1_double_timeout(s);



    if (dtls1_check_timeout_num(s) < 0)

    if (dtls1_check_timeout_num(s) < 0) {

        /* SSLfatal() already called */

        return -1;

    }



    s->d1->timeout.read_timeouts++;

    if (s->d1->timeout.read_timeouts > DTLS1_TMO_READ_COUNT) {
@@ -406,6 +409,7 @@ int dtls1_handle_timeout(SSL *s) 
    }



    dtls1_start_timer(s);

    /* Calls SSLfatal() if required */

    return dtls1_retransmit_buffered_messages(s);

}

ssl/record/rec_layer_d1.c

+59 −48
Original line number Diff line number Diff line
@@ -148,7 +148,8 @@ int dtls1_buffer_record(SSL *s, record_pqueue *queue, unsigned char *priority) 
    if (rdata == NULL || item == NULL) {

        OPENSSL_free(rdata);

        pitem_free(item);

        SSLerr(SSL_F_DTLS1_BUFFER_RECORD, ERR_R_INTERNAL_ERROR);

        SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_DTLS1_BUFFER_RECORD,

                 ERR_R_INTERNAL_ERROR);

        return -1;

    }
@@ -175,7 +176,7 @@ int dtls1_buffer_record(SSL *s, record_pqueue *queue, unsigned char *priority) 
    memset(&s->rlayer.rrec, 0, sizeof(s->rlayer.rrec));



    if (!ssl3_setup_buffers(s)) {

        SSLerr(SSL_F_DTLS1_BUFFER_RECORD, ERR_R_INTERNAL_ERROR);

        /* SSLfatal() already called */

        OPENSSL_free(rdata->rbuf.buf);

        OPENSSL_free(rdata);

        pitem_free(item);
@@ -184,7 +185,8 @@ int dtls1_buffer_record(SSL *s, record_pqueue *queue, unsigned char *priority) 


    /* insert should not fail, since duplicates are dropped */

    if (pqueue_insert(queue->q, item) == NULL) {

        SSLerr(SSL_F_DTLS1_BUFFER_RECORD, ERR_R_INTERNAL_ERROR);

        SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_DTLS1_BUFFER_RECORD,

                 ERR_R_INTERNAL_ERROR);

        OPENSSL_free(rdata->rbuf.buf);

        OPENSSL_free(rdata);

        pitem_free(item);
@@ -258,7 +260,8 @@ int dtls1_process_buffered_records(SSL *s) 
                 * current record is from a different epoch. But that cannot

                 * be the case because we already checked the epoch above

                 */

                 SSLerr(SSL_F_DTLS1_PROCESS_BUFFERED_RECORDS,

                 SSLfatal(s, SSL_AD_INTERNAL_ERROR,

                          SSL_F_DTLS1_PROCESS_BUFFERED_RECORDS,

                          ERR_R_INTERNAL_ERROR);

                 return 0;

            }
@@ -277,6 +280,10 @@ int dtls1_process_buffered_records(SSL *s) 
            }



            if (!replayok || !dtls1_process_record(s, bitmap)) {

                if (ossl_statem_in_error(s)) {

                    /* dtls1_process_record called SSLfatal() */

                    return -1;

                }

                /* dump this record */

                rr->length = 0;

                RECORD_LAYER_reset_packet_length(&s->rlayer);
@@ -284,10 +291,12 @@ int dtls1_process_buffered_records(SSL *s) 
            }



            if (dtls1_buffer_record(s, &(s->rlayer.d->processed_rcds),

                    SSL3_RECORD_get_seq_num(s->rlayer.rrec)) < 0)

                    SSL3_RECORD_get_seq_num(s->rlayer.rrec)) < 0) {

                /* SSLfatal() already called */

                return 0;

            }

        }

    }



    /*

     * sync epoch numbers once all the unprocessed records have been
@@ -331,16 +340,18 @@ int dtls1_process_buffered_records(SSL *s) 
int dtls1_read_bytes(SSL *s, int type, int *recvd_type, unsigned char *buf,

                     size_t len, int peek, size_t *readbytes)

{

    int al, i, j, iret;

    int i, j, iret;

    size_t n;

    SSL3_RECORD *rr;

    void (*cb) (const SSL *ssl, int type2, int val) = NULL;



    if (!SSL3_BUFFER_is_initialised(&s->rlayer.rbuf)) {

        /* Not initialized yet */

        if (!ssl3_setup_buffers(s))

        if (!ssl3_setup_buffers(s)) {

            /* SSLfatal() already called */

            return -1;

        }

    }



    if ((type && (type != SSL3_RT_APPLICATION_DATA) &&

         (type != SSL3_RT_HANDSHAKE)) ||
@@ -353,13 +364,12 @@ int dtls1_read_bytes(SSL *s, int type, int *recvd_type, unsigned char *buf, 
    {

        /* type == SSL3_RT_APPLICATION_DATA */

        i = s->handshake_func(s);

        /* SSLfatal() already called if appropriate */

        if (i < 0)

            return i;

        if (i == 0) {

            SSLerr(SSL_F_DTLS1_READ_BYTES, SSL_R_SSL_HANDSHAKE_FAILURE);

        if (i == 0)

            return -1;

    }

    }



 start:

    s->rwstate = SSL_NOTHING;
@@ -410,7 +420,10 @@ int dtls1_read_bytes(SSL *s, int type, int *recvd_type, unsigned char *buf, 
        iret = dtls1_get_record(s);

        if (iret <= 0) {

            iret = dtls1_read_failed(s, iret);

            /* anything other than a timeout is an error */

            /*

             * Anything other than a timeout is an error. SSLfatal() already

             * called if appropriate.

             */

            if (iret <= 0)

                return iret;

            else
@@ -438,7 +451,7 @@ int dtls1_read_bytes(SSL *s, int type, int *recvd_type, unsigned char *buf, 
         */

        if (dtls1_buffer_record(s, &(s->rlayer.d->buffered_app_data),

                                SSL3_RECORD_get_seq_num(rr)) < 0) {

            SSLerr(SSL_F_DTLS1_READ_BYTES, ERR_R_INTERNAL_ERROR);

            /* SSLfatal() already called */

            return -1;

        }

        SSL3_RECORD_set_length(rr, 0);
@@ -469,9 +482,9 @@ int dtls1_read_bytes(SSL *s, int type, int *recvd_type, unsigned char *buf, 
         */

        if (SSL_in_init(s) && (type == SSL3_RT_APPLICATION_DATA) &&

            (s->enc_read_ctx == NULL)) {

            al = SSL_AD_UNEXPECTED_MESSAGE;

            SSLerr(SSL_F_DTLS1_READ_BYTES, SSL_R_APP_DATA_IN_HANDSHAKE);

            goto f_err;

            SSLfatal(s, SSL_AD_UNEXPECTED_MESSAGE, SSL_F_DTLS1_READ_BYTES,

                     SSL_R_APP_DATA_IN_HANDSHAKE);

            return -1;

        }



        if (recvd_type != NULL)
@@ -526,9 +539,9 @@ int dtls1_read_bytes(SSL *s, int type, int *recvd_type, unsigned char *buf, 
                || !PACKET_get_1(&alert, &alert_level)

                || !PACKET_get_1(&alert, &alert_descr)

                || PACKET_remaining(&alert) != 0) {

            al = SSL_AD_UNEXPECTED_MESSAGE;

            SSLerr(SSL_F_DTLS1_READ_BYTES, SSL_R_INVALID_ALERT);

            goto f_err;

            SSLfatal(s, SSL_AD_UNEXPECTED_MESSAGE, SSL_F_DTLS1_READ_BYTES,

                     SSL_R_INVALID_ALERT);

            return -1;

        }



        if (s->msg_callback)
@@ -550,9 +563,9 @@ int dtls1_read_bytes(SSL *s, int type, int *recvd_type, unsigned char *buf, 


            s->rlayer.alert_count++;

            if (s->rlayer.alert_count == MAX_WARN_ALERT_COUNT) {

                al = SSL_AD_UNEXPECTED_MESSAGE;

                SSLerr(SSL_F_DTLS1_READ_BYTES, SSL_R_TOO_MANY_WARN_ALERTS);

                goto f_err;

                SSLfatal(s, SSL_AD_UNEXPECTED_MESSAGE, SSL_F_DTLS1_READ_BYTES,

                         SSL_R_TOO_MANY_WARN_ALERTS);

                return -1;

            }



            if (alert_descr == SSL_AD_CLOSE_NOTIFY) {
@@ -579,16 +592,17 @@ int dtls1_read_bytes(SSL *s, int type, int *recvd_type, unsigned char *buf, 


            s->rwstate = SSL_NOTHING;

            s->s3->fatal_alert = alert_descr;

            SSLerr(SSL_F_DTLS1_READ_BYTES, SSL_AD_REASON_OFFSET + alert_descr);

            BIO_snprintf(tmp, sizeof(tmp), "%d", alert_descr);

            SSLfatal(s, SSL_AD_NO_ALERT, SSL_F_DTLS1_READ_BYTES,

                     SSL_AD_REASON_OFFSET + alert_descr);

            BIO_snprintf(tmp, sizeof tmp, "%d", alert_descr);

            ERR_add_error_data(2, "SSL alert number ", tmp);

            s->shutdown |= SSL_RECEIVED_SHUTDOWN;

            SSL_CTX_remove_session(s->session_ctx, s->session);

            return 0;

        } else {

            al = SSL_AD_ILLEGAL_PARAMETER;

            SSLerr(SSL_F_DTLS1_READ_BYTES, SSL_R_UNKNOWN_ALERT_TYPE);

            goto f_err;

            SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_F_DTLS1_READ_BYTES,

                     SSL_R_UNKNOWN_ALERT_TYPE);

            return -1;

        }



        goto start;
@@ -634,8 +648,10 @@ int dtls1_read_bytes(SSL *s, int type, int *recvd_type, unsigned char *buf, 
         * here, then retransmit our CCS and FINISHED.

         */

        if (msg_hdr.type == SSL3_MT_FINISHED) {

            if (dtls1_check_timeout_num(s) < 0)

            if (dtls1_check_timeout_num(s) < 0) {

                /* SSLfatal) already called */

                return -1;

            }



            if (dtls1_retransmit_buffered_messages(s) <= 0) {

                /* Fail if we encountered a fatal error */
@@ -653,21 +669,20 @@ int dtls1_read_bytes(SSL *s, int type, int *recvd_type, unsigned char *buf, 
         * finished

         */

        if (!ossl_assert(SSL_is_init_finished(s))) {

            al = SSL_AD_INTERNAL_ERROR;

            SSLerr(SSL_F_DTLS1_READ_BYTES, ERR_R_INTERNAL_ERROR);

            goto f_err;

            SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_DTLS1_READ_BYTES,

                     ERR_R_INTERNAL_ERROR);

            return -1;

        }



        /* We found handshake data, so we're going back into init */

        ossl_statem_set_in_init(s, 1);



        i = s->handshake_func(s);

        /* SSLfatal() called if appropriate */

        if (i < 0)

            return i;

        if (i == 0) {

            SSLerr(SSL_F_DTLS1_READ_BYTES, SSL_R_SSL_HANDSHAKE_FAILURE);

        if (i == 0)

            return -1;

        }



        if (!(s->mode & SSL_MODE_AUTO_RETRY)) {

            if (SSL3_BUFFER_get_left(&s->rlayer.rbuf) == 0) {
@@ -691,9 +706,9 @@ int dtls1_read_bytes(SSL *s, int type, int *recvd_type, unsigned char *buf, 


    switch (SSL3_RECORD_get_type(rr)) {

    default:

        al = SSL_AD_UNEXPECTED_MESSAGE;

        SSLerr(SSL_F_DTLS1_READ_BYTES, SSL_R_UNEXPECTED_RECORD);

        goto f_err;

        SSLfatal(s, SSL_AD_UNEXPECTED_MESSAGE, SSL_F_DTLS1_READ_BYTES,

                 SSL_R_UNEXPECTED_RECORD);

        return -1;

    case SSL3_RT_CHANGE_CIPHER_SPEC:

    case SSL3_RT_ALERT:

    case SSL3_RT_HANDSHAKE:
@@ -702,9 +717,9 @@ int dtls1_read_bytes(SSL *s, int type, int *recvd_type, unsigned char *buf, 
         * SSL3_RT_HANDSHAKE when ossl_statem_get_in_handshake(s) is true, but

         * that should not happen when type != rr->type

         */

        al = SSL_AD_UNEXPECTED_MESSAGE;

        SSLerr(SSL_F_DTLS1_READ_BYTES, ERR_R_INTERNAL_ERROR);

        goto f_err;

        SSLfatal(s, SSL_AD_UNEXPECTED_MESSAGE, SSL_F_DTLS1_READ_BYTES,

                 ERR_R_INTERNAL_ERROR);

        return -1;

    case SSL3_RT_APPLICATION_DATA:

        /*

         * At this point, we were expecting handshake data, but have
@@ -719,16 +734,12 @@ int dtls1_read_bytes(SSL *s, int type, int *recvd_type, unsigned char *buf, 
            s->s3->in_read_app_data = 2;

            return -1;

        } else {

            al = SSL_AD_UNEXPECTED_MESSAGE;

            SSLerr(SSL_F_DTLS1_READ_BYTES, SSL_R_UNEXPECTED_RECORD);

            goto f_err;

            SSLfatal(s, SSL_AD_UNEXPECTED_MESSAGE, SSL_F_DTLS1_READ_BYTES,

                     SSL_R_UNEXPECTED_RECORD);

            return -1;

        }

    }

    /* not reached */



 f_err:

    ssl3_send_alert(s, SSL3_AL_FATAL, al);

    return -1;

}



/*
@@ -940,7 +951,7 @@ int do_dtls1_write(SSL *s, int type, const unsigned char *buf, 
    s->rlayer.wpend_type = type;

    s->rlayer.wpend_ret = len;



    /* we now just need to write the buffer */

    /* we now just need to write the buffer. Calls SSLfatal() as required. */

    return ssl3_write_pending(s, type, buf, len, written);

 err:

    return -1;

ssl/record/rec_layer_s3.c

+74 −31
Original line number Diff line number Diff line
@@ -360,7 +360,8 @@ int ssl3_write_bytes(SSL *s, int type, const void *buf_, size_t len, 
     */

    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);

        SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_SSL3_WRITE_BYTES,

                 SSL_R_BAD_LENGTH);

        return -1;

    }
@@ -380,10 +381,10 @@ int ssl3_write_bytes(SSL *s, int type, const void *buf_, size_t len, 
    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);

        /* SSLfatal() already called */

        if (i < 0)

            return i;

        if (i == 0) {

            SSLerr(SSL_F_SSL3_WRITE_BYTES, SSL_R_SSL_HANDSHAKE_FAILURE);

            return -1;

        }

    }
@@ -393,6 +394,7 @@ int ssl3_write_bytes(SSL *s, int type, const void *buf_, size_t len, 
     * will happen with non blocking IO

     */

    if (wb->left != 0) {

        /* SSLfatal() already called if appropriate */

        i = ssl3_write_pending(s, type, &buf[tot], s->rlayer.wpend_tot,

                               &tmpwrit);

        if (i <= 0) {
@@ -437,7 +439,7 @@ int ssl3_write_bytes(SSL *s, int type, const void *buf_, size_t len, 
                packlen *= 4;



            if (!ssl3_setup_write_buffer(s, 1, packlen)) {

                SSLerr(SSL_F_SSL3_WRITE_BYTES, ERR_R_MALLOC_FAILURE);

                /* SSLfatal() already called */

                return -1;

            }

        } else if (tot == len) { /* done? */
@@ -458,6 +460,7 @@ int ssl3_write_bytes(SSL *s, int type, const void *buf_, size_t len, 
            if (s->s3->alert_dispatch) {

                i = s->method->ssl_dispatch_alert(s);

                if (i <= 0) {

                    /* SSLfatal() already called if appropriate */

                    s->rlayer.wnum = tot;

                    return i;

                }
@@ -513,6 +516,7 @@ int ssl3_write_bytes(SSL *s, int type, const void *buf_, size_t len, 


            i = ssl3_write_pending(s, type, &buf[tot], nw, &tmpwrit);

            if (i <= 0) {

                /* SSLfatal() already called if appropriate */

                if (i < 0 && (!s->wbio || !BIO_should_retry(s->wbio))) {

                    /* free jumbo buffer */

                    ssl3_release_write_buffer(s);
@@ -555,7 +559,8 @@ int ssl3_write_bytes(SSL *s, int type, const void *buf_, size_t len, 
         * We should have prevented this when we set max_pipelines so we

         * shouldn't get here

         */

        SSLerr(SSL_F_SSL3_WRITE_BYTES, ERR_R_INTERNAL_ERROR);

        SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_SSL3_WRITE_BYTES,

                 ERR_R_INTERNAL_ERROR);

        return -1;

    }

    if (maxpipes == 0
@@ -570,7 +575,8 @@ int ssl3_write_bytes(SSL *s, int type, const void *buf_, size_t len, 
         * We should have prevented this when we set/get the split and max send

         * fragments so we shouldn't get here

         */

        SSLerr(SSL_F_SSL3_WRITE_BYTES, ERR_R_INTERNAL_ERROR);

        SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_SSL3_WRITE_BYTES,

                 ERR_R_INTERNAL_ERROR);

        return -1;

    }
@@ -607,6 +613,7 @@ int ssl3_write_bytes(SSL *s, int type, const void *buf_, size_t len, 
        i = do_ssl3_write(s, type, &(buf[tot]), pipelens, numpipes, 0,

                          &tmpwrit);

        if (i <= 0) {

            /* SSLfatal() already called if appropriate */

            /* XXX should we ssl3_release_write_buffer if i<0? */

            s->rlayer.wnum = tot;

            return i;
@@ -658,20 +665,27 @@ int do_ssl3_write(SSL *s, int type, const unsigned char *buf, 
     * first check if there is a SSL3_BUFFER still being written out.  This

     * will happen with non blocking IO

     */

    if (RECORD_LAYER_write_pending(&s->rlayer))

    if (RECORD_LAYER_write_pending(&s->rlayer)) {

        /* Calls SSLfatal() as required */

        return ssl3_write_pending(s, type, buf, totlen, written);

    }



    /* If we have an alert to send, lets send it */

    if (s->s3->alert_dispatch) {

        i = s->method->ssl_dispatch_alert(s);

        if (i <= 0)

        if (i <= 0) {

            /* SSLfatal() already called if appropriate */

            return i;

        }

        /* if it went, fall through and send more stuff */

    }



    if (s->rlayer.numwpipes < numpipes)

        if (!ssl3_setup_write_buffer(s, numpipes, 0))

    if (s->rlayer.numwpipes < numpipes) {

        if (!ssl3_setup_write_buffer(s, numpipes, 0)) {

            /* SSLfatal() already called */

            return -1;

        }

    }



    if (totlen == 0 && !create_empty_fragment)

        return 0;
@@ -685,9 +699,12 @@ int do_ssl3_write(SSL *s, int type, const unsigned char *buf, 
    } else {

        /* TODO(siz_t): Convert me */

        mac_size = EVP_MD_CTX_size(s->write_hash);

        if (mac_size < 0)

        if (mac_size < 0) {

            SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_DO_SSL3_WRITE,

                     ERR_R_INTERNAL_ERROR);

            goto err;

        }

    }



    /*

     * 'create_empty_fragment' is true only when this function calls itself
@@ -709,13 +726,16 @@ int do_ssl3_write(SSL *s, int type, const unsigned char *buf, 
            int ret;



            ret = do_ssl3_write(s, type, buf, &tmppipelen, 1, 1, &prefix_len);

            if (ret <= 0)

            if (ret <= 0) {

                /* SSLfatal() already called if appropriate */

                goto err;

            }



            if (prefix_len >

                (SSL3_RT_HEADER_LENGTH + SSL3_RT_SEND_MAX_ENCRYPTED_OVERHEAD)) {

                /* insufficient space */

                SSLerr(SSL_F_DO_SSL3_WRITE, ERR_R_INTERNAL_ERROR);

                SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_DO_SSL3_WRITE,

                         ERR_R_INTERNAL_ERROR);

                goto err;

            }

        }
@@ -738,7 +758,8 @@ int do_ssl3_write(SSL *s, int type, const unsigned char *buf, 
        if (!WPACKET_init_static_len(&pkt[0], SSL3_BUFFER_get_buf(wb),

                                     SSL3_BUFFER_get_len(wb), 0)

                || !WPACKET_allocate_bytes(&pkt[0], align, NULL)) {

            SSLerr(SSL_F_DO_SSL3_WRITE, ERR_R_INTERNAL_ERROR);

            SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_DO_SSL3_WRITE,

                     ERR_R_INTERNAL_ERROR);

            goto err;

        }

        wpinited = 1;
@@ -749,7 +770,8 @@ int do_ssl3_write(SSL *s, int type, const unsigned char *buf, 
                                     SSL3_BUFFER_get_len(wb), 0)

                || !WPACKET_allocate_bytes(&pkt[0], SSL3_BUFFER_get_offset(wb)

                                                    + prefix_len, NULL)) {

            SSLerr(SSL_F_DO_SSL3_WRITE, ERR_R_INTERNAL_ERROR);

            SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_DO_SSL3_WRITE,

                     ERR_R_INTERNAL_ERROR);

            goto err;

        }

        wpinited = 1;
@@ -766,7 +788,8 @@ int do_ssl3_write(SSL *s, int type, const unsigned char *buf, 
            if (!WPACKET_init_static_len(thispkt, SSL3_BUFFER_get_buf(wb),

                                         SSL3_BUFFER_get_len(wb), 0)

                    || !WPACKET_allocate_bytes(thispkt, align, NULL)) {

                SSLerr(SSL_F_DO_SSL3_WRITE, ERR_R_INTERNAL_ERROR);

                SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_DO_SSL3_WRITE,

                         ERR_R_INTERNAL_ERROR);

                goto err;

            }

            wpinited++;
@@ -831,7 +854,8 @@ int do_ssl3_write(SSL *s, int type, const unsigned char *buf, 
                || (maxcomplen > 0

                    && !WPACKET_reserve_bytes(thispkt, maxcomplen,

                                              &compressdata))) {

            SSLerr(SSL_F_DO_SSL3_WRITE, ERR_R_INTERNAL_ERROR);

            SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_DO_SSL3_WRITE,

                     ERR_R_INTERNAL_ERROR);

            goto err;

        }
@@ -850,12 +874,14 @@ int do_ssl3_write(SSL *s, int type, const unsigned char *buf, 
        if (s->compress != NULL) {

            if (!ssl3_do_compress(s, thiswr)

                    || !WPACKET_allocate_bytes(thispkt, thiswr->length, NULL)) {

                SSLerr(SSL_F_DO_SSL3_WRITE, SSL_R_COMPRESSION_FAILURE);

                SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_DO_SSL3_WRITE,

                         SSL_R_COMPRESSION_FAILURE);

                goto err;

            }

        } else {

            if (!WPACKET_memcpy(thispkt, thiswr->input, thiswr->length)) {

                SSLerr(SSL_F_DO_SSL3_WRITE, ERR_R_INTERNAL_ERROR);

                SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_DO_SSL3_WRITE,

                         ERR_R_INTERNAL_ERROR);

                goto err;

            }

            SSL3_RECORD_reset_input(&wr[j]);
@@ -865,7 +891,8 @@ int do_ssl3_write(SSL *s, int type, const unsigned char *buf, 
            size_t rlen, max_send_fragment;



            if (!WPACKET_put_bytes_u8(thispkt, type)) {

                SSLerr(SSL_F_DO_SSL3_WRITE, ERR_R_INTERNAL_ERROR);

                SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_DO_SSL3_WRITE,

                         ERR_R_INTERNAL_ERROR);

                goto err;

            }

            SSL3_RECORD_add_length(thiswr, 1);
@@ -898,7 +925,8 @@ int do_ssl3_write(SSL *s, int type, const unsigned char *buf, 
                    if (padding > max_padding)

                        padding = max_padding;

                    if (!WPACKET_memset(thispkt, 0, padding)) {

                        SSLerr(SSL_F_DO_SSL3_WRITE, ERR_R_INTERNAL_ERROR);

                        SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_DO_SSL3_WRITE,

                                 ERR_R_INTERNAL_ERROR);

                        goto err;

                    }

                    SSL3_RECORD_add_length(thiswr, padding);
@@ -917,7 +945,8 @@ int do_ssl3_write(SSL *s, int type, const unsigned char *buf, 


            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);

                SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_DO_SSL3_WRITE,

                         ERR_R_INTERNAL_ERROR);

                goto err;

            }

        }
@@ -934,7 +963,8 @@ int do_ssl3_write(SSL *s, int type, const unsigned char *buf, 
                    * sub-packet

                    */

                || !WPACKET_get_length(thispkt, &len)) {

            SSLerr(SSL_F_DO_SSL3_WRITE, ERR_R_INTERNAL_ERROR);

            SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_DO_SSL3_WRITE,

                     ERR_R_INTERNAL_ERROR);

            goto err;

        }
@@ -952,12 +982,18 @@ int do_ssl3_write(SSL *s, int type, const unsigned char *buf, 
         * We haven't actually negotiated the version yet, but we're trying to

         * send early data - so we need to use the tls13enc function.

         */

        if (tls13_enc(s, wr, numpipes, 1) < 1)

        if (tls13_enc(s, wr, numpipes, 1) < 1) {

            SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_DO_SSL3_WRITE,

                     ERR_R_INTERNAL_ERROR);

            goto err;

        }

    } else {

        if (s->method->ssl3_enc->enc(s, wr, numpipes, 1) < 1)

        if (s->method->ssl3_enc->enc(s, wr, numpipes, 1) < 1) {

            SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_DO_SSL3_WRITE,

                     ERR_R_INTERNAL_ERROR);

            goto err;

        }

    }



    for (j = 0; j < numpipes; j++) {

        size_t origlen;
@@ -972,7 +1008,8 @@ int do_ssl3_write(SSL *s, int type, const unsigned char *buf, 
                || (thiswr->length > origlen

                    && !WPACKET_allocate_bytes(thispkt,

                                               thiswr->length - origlen, NULL))) {

            SSLerr(SSL_F_DO_SSL3_WRITE, ERR_R_INTERNAL_ERROR);

            SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_DO_SSL3_WRITE,

                     ERR_R_INTERNAL_ERROR);

            goto err;

        }

        if (SSL_WRITE_ETM(s) && mac_size != 0) {
@@ -980,7 +1017,8 @@ int do_ssl3_write(SSL *s, int type, const unsigned char *buf, 


            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);

                SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_DO_SSL3_WRITE,

                         ERR_R_INTERNAL_ERROR);

                goto err;

            }

            SSL3_RECORD_add_length(thiswr, mac_size);
@@ -988,7 +1026,8 @@ int do_ssl3_write(SSL *s, int type, const unsigned char *buf, 


        if (!WPACKET_get_length(thispkt, &len)

                || !WPACKET_close(thispkt)) {

            SSLerr(SSL_F_DO_SSL3_WRITE, ERR_R_INTERNAL_ERROR);

            SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_DO_SSL3_WRITE,

                     ERR_R_INTERNAL_ERROR);

            goto err;

        }
@@ -1008,7 +1047,8 @@ int do_ssl3_write(SSL *s, int type, const unsigned char *buf, 
        }



        if (!WPACKET_finish(thispkt)) {

            SSLerr(SSL_F_DO_SSL3_WRITE, ERR_R_INTERNAL_ERROR);

            SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_DO_SSL3_WRITE,

                     ERR_R_INTERNAL_ERROR);

            goto err;

        }
@@ -1027,7 +1067,8 @@ int do_ssl3_write(SSL *s, int type, const unsigned char *buf, 
             */

            if (j > 0) {

                /* We should never be pipelining an empty fragment!! */

                SSLerr(SSL_F_DO_SSL3_WRITE, ERR_R_INTERNAL_ERROR);

                SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_DO_SSL3_WRITE,

                         ERR_R_INTERNAL_ERROR);

                goto err;

            }

            *written = SSL3_RECORD_get_length(thiswr);
@@ -1072,7 +1113,8 @@ int ssl3_write_pending(SSL *s, int type, const unsigned char *buf, size_t len, 
        || ((s->rlayer.wpend_buf != buf) &&

            !(s->mode & SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER))

        || (s->rlayer.wpend_type != type)) {

        SSLerr(SSL_F_SSL3_WRITE_PENDING, SSL_R_BAD_WRITE_RETRY);

        SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_SSL3_WRITE_PENDING,

                 SSL_R_BAD_WRITE_RETRY);

        return -1;

    }
@@ -1094,7 +1136,8 @@ int ssl3_write_pending(SSL *s, int type, const unsigned char *buf, size_t len, 
            if (i >= 0)

                tmpwrit = i;

        } else {

            SSLerr(SSL_F_SSL3_WRITE_PENDING, SSL_R_BIO_NOT_SET);

            SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_SSL3_WRITE_PENDING,

                     SSL_R_BIO_NOT_SET);

            i = -1;

        }

        if (i > 0 && tmpwrit == SSL3_BUFFER_get_left(&wb[currbuf])) {

ssl/record/ssl3_record.c

+54 −47

File changed.

Preview size limit exceeded, changes collapsed.

ssl/statem/statem_dtls.c

+1 −1
Original line number Diff line number Diff line
@@ -944,7 +944,7 @@ int dtls1_read_failed(SSL *s, int code) 
        return 0;

    }



    if (!dtls1_is_timer_expired(s)) {

    if (!dtls1_is_timer_expired(s) || ossl_statem_in_error(s)) {

        /*

         * not a timeout, none of our business, let higher layers handle

         * this.  in fact it's probably an error