ssl/record/rec_layer_s3.c

   1 /*
   2  * Copyright 1995-2022 The OpenSSL Project Authors. All Rights Reserved.
   3  *
   4  * Licensed under the Apache License 2.0 (the "License").  You may not use
   5  * this file except in compliance with the License.  You can obtain a copy
   6  * in the file LICENSE in the source distribution or at
   7  * https://www.openssl.org/source/license.html
   8  */
   9
  10 #include <stdio.h>
  11 #include <limits.h>
  12 #include <errno.h>
  13 #include "../ssl_local.h"
  14 #include <openssl/evp.h>
  15 #include <openssl/buffer.h>
  16 #include <openssl/rand.h>
  17 #include <openssl/core_names.h>
  18 #include "record_local.h"
  19 #include "internal/packet.h"
  20
  21 void RECORD_LAYER_init(RECORD_LAYER *rl, SSL_CONNECTION *s)
  22 {
  23     rl->s = s;
  24 }
  25
  26 void RECORD_LAYER_clear(RECORD_LAYER *rl)
  27 {
  28     rl->wnum = 0;
  29     memset(rl->handshake_fragment, 0, sizeof(rl->handshake_fragment));
  30     rl->handshake_fragment_len = 0;
  31     rl->wpend_tot = 0;
  32     rl->wpend_type = 0;
  33     rl->wpend_ret = 0;
  34     rl->wpend_buf = NULL;
  35
  36     if (rl->rrlmethod != NULL)
  37         rl->rrlmethod->free(rl->rrl); /* Ignore return value */
  38     if (rl->wrlmethod != NULL)
  39         rl->wrlmethod->free(rl->wrl); /* Ignore return value */
  40     BIO_free(rl->rrlnext);
  41     rl->rrlmethod = NULL;
  42     rl->wrlmethod = NULL;
  43     rl->rrlnext = NULL;
  44     rl->rrl = NULL;
  45     rl->wrl = NULL;
  46
  47     if (rl->d)
  48         DTLS_RECORD_LAYER_clear(rl);
  49 }
  50
  51 /* Checks if we have unprocessed read ahead data pending */
  52 int RECORD_LAYER_read_pending(const RECORD_LAYER *rl)
  53 {
  54     return rl->rrlmethod->unprocessed_read_pending(rl->rrl);
  55 }
  56
  57 /* Checks if we have decrypted unread record data pending */
  58 int RECORD_LAYER_processed_read_pending(const RECORD_LAYER *rl)
  59 {
  60     return (rl->curr_rec < rl->num_recs)
  61            || rl->rrlmethod->processed_read_pending(rl->rrl);
  62 }
  63
  64 int RECORD_LAYER_write_pending(const RECORD_LAYER *rl)
  65 {
  66     return rl->wpend_tot > 0;
  67 }
  68
  69 static uint32_t ossl_get_max_early_data(SSL_CONNECTION *s)
  70 {
  71     uint32_t max_early_data;
  72     SSL_SESSION *sess = s->session;
  73
  74     /*
  75      * If we are a client then we always use the max_early_data from the
  76      * session/psksession. Otherwise we go with the lowest out of the max early
  77      * data set in the session and the configured max_early_data.
  78      */
  79     if (!s->server && sess->ext.max_early_data == 0) {
  80         if (!ossl_assert(s->psksession != NULL
  81                          && s->psksession->ext.max_early_data > 0)) {
  82             SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
  83             return 0;
  84         }
  85         sess = s->psksession;
  86     }
  87
  88     if (!s->server)
  89         max_early_data = sess->ext.max_early_data;
  90     else if (s->ext.early_data != SSL_EARLY_DATA_ACCEPTED)
  91         max_early_data = s->recv_max_early_data;
  92     else
  93         max_early_data = s->recv_max_early_data < sess->ext.max_early_data
  94                          ? s->recv_max_early_data : sess->ext.max_early_data;
  95
  96     return max_early_data;
  97 }
  98
  99 static int ossl_early_data_count_ok(SSL_CONNECTION *s, size_t length,
 100                                     size_t overhead, int send)
 101 {
 102     uint32_t max_early_data;
 103
 104     max_early_data = ossl_get_max_early_data(s);
 105
 106     if (max_early_data == 0) {
 107         SSLfatal(s, send ? SSL_AD_INTERNAL_ERROR : SSL_AD_UNEXPECTED_MESSAGE,
 108                  SSL_R_TOO_MUCH_EARLY_DATA);
 109         return 0;
 110     }
 111
 112     /* If we are dealing with ciphertext we need to allow for the overhead */
 113     max_early_data += overhead;
 114
 115     if (s->early_data_count + length > max_early_data) {
 116         SSLfatal(s, send ? SSL_AD_INTERNAL_ERROR : SSL_AD_UNEXPECTED_MESSAGE,
 117                  SSL_R_TOO_MUCH_EARLY_DATA);
 118         return 0;
 119     }
 120     s->early_data_count += length;
 121
 122     return 1;
 123 }
 124
 125 size_t ssl3_pending(const SSL *s)
 126 {
 127     size_t i, num = 0;
 128     const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
 129
 130     if (sc == NULL)
 131         return 0;
 132
 133     if (SSL_CONNECTION_IS_DTLS(sc)) {
 134         TLS_RECORD *rdata;
 135         pitem *item, *iter;
 136
 137         iter = pqueue_iterator(sc->rlayer.d->buffered_app_data.q);
 138         while ((item = pqueue_next(&iter)) != NULL) {
 139             rdata = item->data;
 140             num += rdata->length;
 141         }
 142     }
 143
 144     for (i = 0; i < sc->rlayer.num_recs; i++) {
 145         if (sc->rlayer.tlsrecs[i].type != SSL3_RT_APPLICATION_DATA)
 146             return num;
 147         num += sc->rlayer.tlsrecs[i].length;
 148     }
 149
 150     num += sc->rlayer.rrlmethod->app_data_pending(sc->rlayer.rrl);
 151
 152     return num;
 153 }
 154
 155 void SSL_CTX_set_default_read_buffer_len(SSL_CTX *ctx, size_t len)
 156 {
 157     ctx->default_read_buf_len = len;
 158 }
 159
 160 void SSL_set_default_read_buffer_len(SSL *s, size_t len)
 161 {
 162     SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(s);
 163
 164     if (sc == NULL)
 165         return;
 166     sc->rlayer.default_read_buf_len = len;
 167 }
 168
 169 const char *SSL_rstate_string_long(const SSL *s)
 170 {
 171     const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
 172     const char *lng;
 173
 174     if (sc == NULL)
 175         return NULL;
 176
 177     if (sc->rlayer.rrlmethod == NULL || sc->rlayer.rrl == NULL)
 178         return "unknown";
 179
 180     sc->rlayer.rrlmethod->get_state(sc->rlayer.rrl, NULL, &lng);
 181
 182     return lng;
 183 }
 184
 185 const char *SSL_rstate_string(const SSL *s)
 186 {
 187     const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
 188     const char *shrt;
 189
 190     if (sc == NULL)
 191         return NULL;
 192
 193     if (sc->rlayer.rrlmethod == NULL || sc->rlayer.rrl == NULL)
 194         return "unknown";
 195
 196     sc->rlayer.rrlmethod->get_state(sc->rlayer.rrl, &shrt, NULL);
 197
 198     return shrt;
 199 }
 200
 201 static int tls_write_check_pending(SSL_CONNECTION *s, int type,
 202                                    const unsigned char *buf, size_t len)
 203 {
 204     if (s->rlayer.wpend_tot == 0)
 205         return 0;
 206
 207     /* We have pending data, so do some sanity checks */
 208     if ((s->rlayer.wpend_tot > len)
 209         || (!(s->mode & SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER)
 210             && (s->rlayer.wpend_buf != buf))
 211         || (s->rlayer.wpend_type != type)) {
 212         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_BAD_WRITE_RETRY);
 213         return -1;
 214     }
 215     return 1;
 216 }
 217
 218 /*
 219  * Call this to write data in records of type 'type' It will return <= 0 if
 220  * not all data has been sent or non-blocking IO.
 221  */
 222 int ssl3_write_bytes(SSL *ssl, int type, const void *buf_, size_t len,
 223                      size_t *written)
 224 {
 225     const unsigned char *buf = buf_;
 226     size_t tot;
 227     size_t n, max_send_fragment, split_send_fragment, maxpipes;
 228     int i;
 229     SSL_CONNECTION *s = SSL_CONNECTION_FROM_SSL_ONLY(ssl);
 230     OSSL_RECORD_TEMPLATE tmpls[SSL_MAX_PIPELINES];
 231     unsigned int recversion;
 232
 233     if (s == NULL)
 234         return -1;
 235
 236     s->rwstate = SSL_NOTHING;
 237     tot = s->rlayer.wnum;
 238     /*
 239      * ensure that if we end up with a smaller value of data to write out
 240      * than the original len from a write which didn't complete for
 241      * non-blocking I/O and also somehow ended up avoiding the check for
 242      * this in tls_write_check_pending/SSL_R_BAD_WRITE_RETRY as it must never be
 243      * possible to end up with (len-tot) as a large number that will then
 244      * promptly send beyond the end of the users buffer ... so we trap and
 245      * report the error in a way the user will notice
 246      */
 247     if ((len < s->rlayer.wnum)
 248         || ((s->rlayer.wpend_tot != 0)
 249             && (len < (s->rlayer.wnum + s->rlayer.wpend_tot)))) {
 250         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_BAD_LENGTH);
 251         return -1;
 252     }
 253
 254     if (s->early_data_state == SSL_EARLY_DATA_WRITING
 255             && !ossl_early_data_count_ok(s, len, 0, 1)) {
 256         /* SSLfatal() already called */
 257         return -1;
 258     }
 259
 260     s->rlayer.wnum = 0;
 261
 262     /*
 263      * If we are supposed to be sending a KeyUpdate or NewSessionTicket then go
 264      * into init unless we have writes pending - in which case we should finish
 265      * doing that first.
 266      */
 267     if (s->rlayer.wpend_tot == 0 && (s->key_update != SSL_KEY_UPDATE_NONE
 268                                      || s->ext.extra_tickets_expected > 0))
 269         ossl_statem_set_in_init(s, 1);
 270
 271     /*
 272      * When writing early data on the server side we could be "in_init" in
 273      * between receiving the EoED and the CF - but we don't want to handle those
 274      * messages yet.
 275      */
 276     if (SSL_in_init(ssl) && !ossl_statem_get_in_handshake(s)
 277             && s->early_data_state != SSL_EARLY_DATA_UNAUTH_WRITING) {
 278         i = s->handshake_func(ssl);
 279         /* SSLfatal() already called */
 280         if (i < 0)
 281             return i;
 282         if (i == 0) {
 283             return -1;
 284         }
 285     }
 286
 287     i = tls_write_check_pending(s, type, buf, len);
 288     if (i < 0) {
 289         /* SSLfatal() already called */
 290         return i;
 291     } else if (i > 0) {
 292         /* Retry needed */
 293         i = HANDLE_RLAYER_WRITE_RETURN(s,
 294                 s->rlayer.wrlmethod->retry_write_records(s->rlayer.wrl));
 295         if (i <= 0)
 296             return i;
 297         tot += s->rlayer.wpend_tot;
 298         s->rlayer.wpend_tot = 0;
 299     } /* else no retry required */
 300
 301     if (tot == 0) {
 302         /*
 303          * We've not previously sent any data for this write so memorize
 304          * arguments so that we can detect bad write retries later
 305          */
 306         s->rlayer.wpend_tot = 0;
 307         s->rlayer.wpend_type = type;
 308         s->rlayer.wpend_buf = buf;
 309         s->rlayer.wpend_ret = len;
 310     }
 311
 312     if (tot == len) {           /* done? */
 313         *written = tot;
 314         return 1;
 315     }
 316
 317     /* If we have an alert to send, lets send it */
 318     if (s->s3.alert_dispatch) {
 319         i = ssl->method->ssl_dispatch_alert(ssl);
 320         if (i <= 0) {
 321             /* SSLfatal() already called if appropriate */
 322             return i;
 323         }
 324         /* if it went, fall through and send more stuff */
 325     }
 326
 327     n = (len - tot);
 328
 329     max_send_fragment = ssl_get_max_send_fragment(s);
 330     split_send_fragment = ssl_get_split_send_fragment(s);
 331
 332     if (max_send_fragment == 0
 333             || split_send_fragment == 0
 334             || split_send_fragment > max_send_fragment) {
 335         /*
 336          * We should have prevented this when we set/get the split and max send
 337          * fragments so we shouldn't get here
 338          */
 339         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
 340         return -1;
 341     }
 342
 343     /*
 344      * Some servers hang if initial client hello is larger than 256 bytes
 345      * and record version number > TLS 1.0
 346      */
 347     recversion = (s->version == TLS1_3_VERSION) ? TLS1_2_VERSION : s->version;
 348     if (SSL_get_state(ssl) == TLS_ST_CW_CLNT_HELLO
 349             && !s->renegotiate
 350             && TLS1_get_version(ssl) > TLS1_VERSION
 351             && s->hello_retry_request == SSL_HRR_NONE)
 352         recversion = TLS1_VERSION;
 353
 354     for (;;) {
 355         size_t tmppipelen, remain;
 356         size_t j, lensofar = 0;
 357
 358         /*
 359         * Ask the record layer how it would like to split the amount of data
 360         * that we have, and how many of those records it would like in one go.
 361         */
 362         maxpipes = s->rlayer.wrlmethod->get_max_records(s->rlayer.wrl, type, n,
 363                                                         max_send_fragment,
 364                                                         &split_send_fragment);
 365         /*
 366         * If max_pipelines is 0 then this means "undefined" and we default to
 367         * whatever the record layer wants to do. Otherwise we use the smallest
 368         * value from the number requested by the record layer, and max number
 369         * configured by the user.
 370         */
 371         if (s->max_pipelines > 0 && maxpipes > s->max_pipelines)
 372             maxpipes = s->max_pipelines;
 373
 374         if (maxpipes > SSL_MAX_PIPELINES)
 375             maxpipes = SSL_MAX_PIPELINES;
 376
 377         if (split_send_fragment > max_send_fragment) {
 378             SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
 379             return -1;
 380         }
 381
 382         if (n / maxpipes >= split_send_fragment) {
 383             /*
 384              * We have enough data to completely fill all available
 385              * pipelines
 386              */
 387             for (j = 0; j < maxpipes; j++) {
 388                 tmpls[j].type = type;
 389                 tmpls[j].version = recversion;
 390                 tmpls[j].buf = &(buf[tot]) + (j * split_send_fragment);
 391                 tmpls[j].buflen = split_send_fragment;
 392             }
 393             /* Remember how much data we are going to be sending */
 394             s->rlayer.wpend_tot = maxpipes * split_send_fragment;
 395         } else {
 396             /* We can partially fill all available pipelines */
 397             tmppipelen = n / maxpipes;
 398             remain = n % maxpipes;
 399             /*
 400              * If there is a remainder we add an extra byte to the first few
 401              * pipelines
 402              */
 403             if (remain > 0)
 404                 tmppipelen++;
 405             for (j = 0; j < maxpipes; j++) {
 406                 tmpls[j].type = type;
 407                 tmpls[j].version = recversion;
 408                 tmpls[j].buf = &(buf[tot]) + lensofar;
 409                 tmpls[j].buflen = tmppipelen;
 410                 lensofar += tmppipelen;
 411                 if (j + 1 == remain)
 412                     tmppipelen--;
 413             }
 414             /* Remember how much data we are going to be sending */
 415             s->rlayer.wpend_tot = n;
 416         }
 417
 418         i = HANDLE_RLAYER_WRITE_RETURN(s,
 419             s->rlayer.wrlmethod->write_records(s->rlayer.wrl, tmpls, maxpipes));
 420         if (i <= 0) {
 421             /* SSLfatal() already called if appropriate */
 422             s->rlayer.wnum = tot;
 423             return i;
 424         }
 425
 426         if (s->rlayer.wpend_tot == n
 427                 || (type == SSL3_RT_APPLICATION_DATA
 428                     && (s->mode & SSL_MODE_ENABLE_PARTIAL_WRITE) != 0)) {
 429             *written = tot + s->rlayer.wpend_tot;
 430             s->rlayer.wpend_tot = 0;
 431             return 1;
 432         }
 433
 434         n -= s->rlayer.wpend_tot;
 435         tot += s->rlayer.wpend_tot;
 436     }
 437 }
 438
 439 int ossl_tls_handle_rlayer_return(SSL_CONNECTION *s, int writing, int ret,
 440                                   char *file, int line)
 441 {
 442     SSL *ssl = SSL_CONNECTION_GET_SSL(s);
 443
 444     if (ret == OSSL_RECORD_RETURN_RETRY) {
 445         s->rwstate = writing ? SSL_WRITING : SSL_READING;
 446         ret = -1;
 447     } else {
 448         s->rwstate = SSL_NOTHING;
 449         if (ret == OSSL_RECORD_RETURN_EOF) {
 450             if (writing) {
 451                 /*
 452                  * This shouldn't happen with a writing operation. We treat it
 453                  * as fatal.
 454                  */
 455                 ERR_new();
 456                 ERR_set_debug(file, line, 0);
 457                 ossl_statem_fatal(s, SSL_AD_INTERNAL_ERROR,
 458                                   ERR_R_INTERNAL_ERROR, NULL);
 459                 ret = OSSL_RECORD_RETURN_FATAL;
 460             } else if ((s->options & SSL_OP_IGNORE_UNEXPECTED_EOF) != 0) {
 461                 SSL_set_shutdown(ssl, SSL_RECEIVED_SHUTDOWN);
 462                 s->s3.warn_alert = SSL_AD_CLOSE_NOTIFY;
 463             } else {
 464                 ERR_new();
 465                 ERR_set_debug(file, line, 0);
 466                 ossl_statem_fatal(s, SSL_AD_DECODE_ERROR,
 467                                   SSL_R_UNEXPECTED_EOF_WHILE_READING, NULL);
 468             }
 469         } else if (ret == OSSL_RECORD_RETURN_FATAL) {
 470             int al = s->rlayer.rrlmethod->get_alert_code(s->rlayer.rrl);
 471
 472             if (al != SSL_AD_NO_ALERT) {
 473                 ERR_new();
 474                 ERR_set_debug(file, line, 0);
 475                 ossl_statem_fatal(s, al, SSL_R_RECORD_LAYER_FAILURE, NULL);
 476             }
 477             /*
 478              * else some failure but there is no alert code. We don't log an
 479              * error for this. The record layer should have logged an error
 480              * already or, if not, its due to some sys call error which will be
 481              * reported via SSL_ERROR_SYSCALL and errno.
 482              */
 483         }
 484         /*
 485          * The record layer distinguishes the cases of EOF, non-fatal
 486          * err and retry. Upper layers do not.
 487          * If we got a retry or success then *ret is already correct,
 488          * otherwise we need to convert the return value.
 489          */
 490         if (ret == OSSL_RECORD_RETURN_NON_FATAL_ERR || ret == OSSL_RECORD_RETURN_EOF)
 491             ret = 0;
 492         else if (ret < OSSL_RECORD_RETURN_NON_FATAL_ERR)
 493             ret = -1;
 494     }
 495
 496     return ret;
 497 }
 498
 499 void ssl_release_record(SSL_CONNECTION *s, TLS_RECORD *rr)
 500 {
 501     if (rr->rechandle != NULL) {
 502         /* The record layer allocated the buffers for this record */
 503         s->rlayer.rrlmethod->release_record(s->rlayer.rrl, rr->rechandle);
 504     } else {
 505         /* We allocated the buffers for this record (only happens with DTLS) */
 506         OPENSSL_free(rr->data);
 507     }
 508     s->rlayer.curr_rec++;
 509 }
 510
 511 /*-
 512  * Return up to 'len' payload bytes received in 'type' records.
 513  * 'type' is one of the following:
 514  *
 515  *   -  SSL3_RT_HANDSHAKE (when ssl3_get_message calls us)
 516  *   -  SSL3_RT_APPLICATION_DATA (when ssl3_read calls us)
 517  *   -  0 (during a shutdown, no data has to be returned)
 518  *
 519  * If we don't have stored data to work from, read a SSL/TLS record first
 520  * (possibly multiple records if we still don't have anything to return).
 521  *
 522  * This function must handle any surprises the peer may have for us, such as
 523  * Alert records (e.g. close_notify) or renegotiation requests. ChangeCipherSpec
 524  * messages are treated as if they were handshake messages *if* the |recvd_type|
 525  * argument is non NULL.
 526  * Also if record payloads contain fragments too small to process, we store
 527  * them until there is enough for the respective protocol (the record protocol
 528  * may use arbitrary fragmentation and even interleaving):
 529  *     Change cipher spec protocol
 530  *             just 1 byte needed, no need for keeping anything stored
 531  *     Alert protocol
 532  *             2 bytes needed (AlertLevel, AlertDescription)
 533  *     Handshake protocol
 534  *             4 bytes needed (HandshakeType, uint24 length) -- we just have
 535  *             to detect unexpected Client Hello and Hello Request messages
 536  *             here, anything else is handled by higher layers
 537  *     Application data protocol
 538  *             none of our business
 539  */
 540 int ssl3_read_bytes(SSL *ssl, int type, int *recvd_type, unsigned char *buf,
 541                     size_t len, int peek, size_t *readbytes)
 542 {
 543     int i, j, ret;
 544     size_t n, curr_rec, totalbytes;
 545     TLS_RECORD *rr;
 546     void (*cb) (const SSL *ssl, int type2, int val) = NULL;
 547     int is_tls13;
 548     SSL_CONNECTION *s = SSL_CONNECTION_FROM_SSL_ONLY(ssl);
 549
 550     is_tls13 = SSL_CONNECTION_IS_TLS13(s);
 551
 552     if ((type != 0
 553             && (type != SSL3_RT_APPLICATION_DATA)
 554             && (type != SSL3_RT_HANDSHAKE))
 555         || (peek && (type != SSL3_RT_APPLICATION_DATA))) {
 556         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
 557         return -1;
 558     }
 559
 560     if ((type == SSL3_RT_HANDSHAKE) && (s->rlayer.handshake_fragment_len > 0))
 561         /* (partially) satisfy request from storage */
 562     {
 563         unsigned char *src = s->rlayer.handshake_fragment;
 564         unsigned char *dst = buf;
 565         unsigned int k;
 566
 567         /* peek == 0 */
 568         n = 0;
 569         while ((len > 0) && (s->rlayer.handshake_fragment_len > 0)) {
 570             *dst++ = *src++;
 571             len--;
 572             s->rlayer.handshake_fragment_len--;
 573             n++;
 574         }
 575         /* move any remaining fragment bytes: */
 576         for (k = 0; k < s->rlayer.handshake_fragment_len; k++)
 577             s->rlayer.handshake_fragment[k] = *src++;
 578
 579         if (recvd_type != NULL)
 580             *recvd_type = SSL3_RT_HANDSHAKE;
 581
 582         *readbytes = n;
 583         return 1;
 584     }
 585
 586     /*
 587      * Now s->rlayer.handshake_fragment_len == 0 if type == SSL3_RT_HANDSHAKE.
 588      */
 589
 590     if (!ossl_statem_get_in_handshake(s) && SSL_in_init(ssl)) {
 591         /* type == SSL3_RT_APPLICATION_DATA */
 592         i = s->handshake_func(ssl);
 593         /* SSLfatal() already called */
 594         if (i < 0)
 595             return i;
 596         if (i == 0)
 597             return -1;
 598     }
 599  start:
 600     s->rwstate = SSL_NOTHING;
 601
 602     /*-
 603      * For each record 'i' up to |num_recs]
 604      * rr[i].type     - is the type of record
 605      * rr[i].data,    - data
 606      * rr[i].off,     - offset into 'data' for next read
 607      * rr[i].length,  - number of bytes.
 608      */
 609     /* get new records if necessary */
 610     if (s->rlayer.curr_rec >= s->rlayer.num_recs) {
 611         s->rlayer.curr_rec = s->rlayer.num_recs = 0;
 612         do {
 613             rr = &s->rlayer.tlsrecs[s->rlayer.num_recs];
 614
 615             ret = HANDLE_RLAYER_READ_RETURN(s,
 616                     s->rlayer.rrlmethod->read_record(s->rlayer.rrl,
 617                                                      &rr->rechandle,
 618                                                      &rr->version, &rr->type,
 619                                                      &rr->data, &rr->length,
 620                                                      NULL, NULL));
 621             if (ret <= 0) {
 622                 /* SSLfatal() already called if appropriate */
 623                 return ret;
 624             }
 625             rr->off = 0;
 626             s->rlayer.num_recs++;
 627         } while (s->rlayer.rrlmethod->processed_read_pending(s->rlayer.rrl)
 628                  && s->rlayer.num_recs < SSL_MAX_PIPELINES);
 629     }
 630     rr = &s->rlayer.tlsrecs[s->rlayer.curr_rec];
 631
 632     if (s->rlayer.handshake_fragment_len > 0
 633             && rr->type != SSL3_RT_HANDSHAKE
 634             && SSL_CONNECTION_IS_TLS13(s)) {
 635         SSLfatal(s, SSL_AD_UNEXPECTED_MESSAGE,
 636                  SSL_R_MIXED_HANDSHAKE_AND_NON_HANDSHAKE_DATA);
 637         return -1;
 638     }
 639
 640     /*
 641      * Reset the count of consecutive warning alerts if we've got a non-empty
 642      * record that isn't an alert.
 643      */
 644     if (rr->type != SSL3_RT_ALERT && rr->length != 0)
 645         s->rlayer.alert_count = 0;
 646
 647     /* we now have a packet which can be read and processed */
 648
 649     if (s->s3.change_cipher_spec /* set when we receive ChangeCipherSpec,
 650                                   * reset by ssl3_get_finished */
 651         && (rr->type != SSL3_RT_HANDSHAKE)) {
 652         SSLfatal(s, SSL_AD_UNEXPECTED_MESSAGE,
 653                  SSL_R_DATA_BETWEEN_CCS_AND_FINISHED);
 654         return -1;
 655     }
 656
 657     /*
 658      * If the other end has shut down, throw anything we read away (even in
 659      * 'peek' mode)
 660      */
 661     if (s->shutdown & SSL_RECEIVED_SHUTDOWN) {
 662         s->rlayer.curr_rec++;
 663         s->rwstate = SSL_NOTHING;
 664         return 0;
 665     }
 666
 667     if (type == rr->type
 668         || (rr->type == SSL3_RT_CHANGE_CIPHER_SPEC
 669             && type == SSL3_RT_HANDSHAKE && recvd_type != NULL
 670             && !is_tls13)) {
 671         /*
 672          * SSL3_RT_APPLICATION_DATA or
 673          * SSL3_RT_HANDSHAKE or
 674          * SSL3_RT_CHANGE_CIPHER_SPEC
 675          */
 676         /*
 677          * make sure that we are not getting application data when we are
 678          * doing a handshake for the first time
 679          */
 680         if (SSL_in_init(ssl) && type == SSL3_RT_APPLICATION_DATA
 681                 && SSL_IS_FIRST_HANDSHAKE(s)) {
 682             SSLfatal(s, SSL_AD_UNEXPECTED_MESSAGE, SSL_R_APP_DATA_IN_HANDSHAKE);
 683             return -1;
 684         }
 685
 686         if (type == SSL3_RT_HANDSHAKE
 687             && rr->type == SSL3_RT_CHANGE_CIPHER_SPEC
 688             && s->rlayer.handshake_fragment_len > 0) {
 689             SSLfatal(s, SSL_AD_UNEXPECTED_MESSAGE, SSL_R_CCS_RECEIVED_EARLY);
 690             return -1;
 691         }
 692
 693         if (recvd_type != NULL)
 694             *recvd_type = rr->type;
 695
 696         if (len == 0) {
 697             /*
 698              * Skip a zero length record. This ensures multiple calls to
 699              * SSL_read() with a zero length buffer will eventually cause
 700              * SSL_pending() to report data as being available.
 701              */
 702             if (rr->length == 0)
 703                 ssl_release_record(s, rr);
 704
 705             return 0;
 706         }
 707
 708         totalbytes = 0;
 709         curr_rec = s->rlayer.curr_rec;
 710         do {
 711             if (len - totalbytes > rr->length)
 712                 n = rr->length;
 713             else
 714                 n = len - totalbytes;
 715
 716             memcpy(buf, &(rr->data[rr->off]), n);
 717             buf += n;
 718             if (peek) {
 719                 /* Mark any zero length record as consumed CVE-2016-6305 */
 720                 if (rr->length == 0)
 721                     ssl_release_record(s, rr);
 722             } else {
 723                 if (s->options & SSL_OP_CLEANSE_PLAINTEXT)
 724                     OPENSSL_cleanse(&(rr->data[rr->off]), n);
 725                 rr->length -= n;
 726                 rr->off += n;
 727                 if (rr->length == 0)
 728                     ssl_release_record(s, rr);
 729             }
 730             if (rr->length == 0
 731                 || (peek && n == rr->length)) {
 732                 rr++;
 733                 curr_rec++;
 734             }
 735             totalbytes += n;
 736         } while (type == SSL3_RT_APPLICATION_DATA
 737                     && curr_rec < s->rlayer.num_recs
 738                     && totalbytes < len);
 739         if (totalbytes == 0) {
 740             /* We must have read empty records. Get more data */
 741             goto start;
 742         }
 743         *readbytes = totalbytes;
 744         return 1;
 745     }
 746
 747     /*
 748      * If we get here, then type != rr->type; if we have a handshake message,
 749      * then it was unexpected (Hello Request or Client Hello) or invalid (we
 750      * were actually expecting a CCS).
 751      */
 752
 753     /*
 754      * Lets just double check that we've not got an SSLv2 record
 755      */
 756     if (rr->version == SSL2_VERSION) {
 757         /*
 758          * Should never happen. ssl3_get_record() should only give us an SSLv2
 759          * record back if this is the first packet and we are looking for an
 760          * initial ClientHello. Therefore |type| should always be equal to
 761          * |rr->type|. If not then something has gone horribly wrong
 762          */
 763         SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
 764         return -1;
 765     }
 766
 767     if (ssl->method->version == TLS_ANY_VERSION
 768         && (s->server || rr->type != SSL3_RT_ALERT)) {
 769         /*
 770          * If we've got this far and still haven't decided on what version
 771          * we're using then this must be a client side alert we're dealing
 772          * with. We shouldn't be receiving anything other than a ClientHello
 773          * if we are a server.
 774          */
 775         s->version = rr->version;
 776         SSLfatal(s, SSL_AD_UNEXPECTED_MESSAGE, SSL_R_UNEXPECTED_MESSAGE);
 777         return -1;
 778     }
 779
 780     /*-
 781      * s->rlayer.handshake_fragment_len == 4  iff  rr->type == SSL3_RT_HANDSHAKE;
 782      * (Possibly rr is 'empty' now, i.e. rr->length may be 0.)
 783      */
 784
 785     if (rr->type == SSL3_RT_ALERT) {
 786         unsigned int alert_level, alert_descr;
 787         unsigned char *alert_bytes = rr->data
 788                                      + rr->off;
 789         PACKET alert;
 790
 791         if (!PACKET_buf_init(&alert, alert_bytes, rr->length)
 792                 || !PACKET_get_1(&alert, &alert_level)
 793                 || !PACKET_get_1(&alert, &alert_descr)
 794                 || PACKET_remaining(&alert) != 0) {
 795             SSLfatal(s, SSL_AD_UNEXPECTED_MESSAGE, SSL_R_INVALID_ALERT);
 796             return -1;
 797         }
 798
 799         if (s->msg_callback)
 800             s->msg_callback(0, s->version, SSL3_RT_ALERT, alert_bytes, 2, ssl,
 801                             s->msg_callback_arg);
 802
 803         if (s->info_callback != NULL)
 804             cb = s->info_callback;
 805         else if (ssl->ctx->info_callback != NULL)
 806             cb = ssl->ctx->info_callback;
 807
 808         if (cb != NULL) {
 809             j = (alert_level << 8) | alert_descr;
 810             cb(ssl, SSL_CB_READ_ALERT, j);
 811         }
 812
 813         if ((!is_tls13 && alert_level == SSL3_AL_WARNING)
 814                 || (is_tls13 && alert_descr == SSL_AD_USER_CANCELLED)) {
 815             s->s3.warn_alert = alert_descr;
 816             ssl_release_record(s, rr);
 817
 818             s->rlayer.alert_count++;
 819             if (s->rlayer.alert_count == MAX_WARN_ALERT_COUNT) {
 820                 SSLfatal(s, SSL_AD_UNEXPECTED_MESSAGE,
 821                          SSL_R_TOO_MANY_WARN_ALERTS);
 822                 return -1;
 823             }
 824         }
 825
 826         /*
 827          * Apart from close_notify the only other warning alert in TLSv1.3
 828          * is user_cancelled - which we just ignore.
 829          */
 830         if (is_tls13 && alert_descr == SSL_AD_USER_CANCELLED) {
 831             goto start;
 832         } else if (alert_descr == SSL_AD_CLOSE_NOTIFY
 833                 && (is_tls13 || alert_level == SSL3_AL_WARNING)) {
 834             s->shutdown |= SSL_RECEIVED_SHUTDOWN;
 835             return 0;
 836         } else if (alert_level == SSL3_AL_FATAL || is_tls13) {
 837             s->rwstate = SSL_NOTHING;
 838             s->s3.fatal_alert = alert_descr;
 839             SSLfatal_data(s, SSL_AD_NO_ALERT,
 840                           SSL_AD_REASON_OFFSET + alert_descr,
 841                           "SSL alert number %d", alert_descr);
 842             s->shutdown |= SSL_RECEIVED_SHUTDOWN;
 843             ssl_release_record(s, rr);
 844             SSL_CTX_remove_session(s->session_ctx, s->session);
 845             return 0;
 846         } else if (alert_descr == SSL_AD_NO_RENEGOTIATION) {
 847             /*
 848              * This is a warning but we receive it if we requested
 849              * renegotiation and the peer denied it. Terminate with a fatal
 850              * alert because if application tried to renegotiate it
 851              * presumably had a good reason and expects it to succeed. In
 852              * future we might have a renegotiation where we don't care if
 853              * the peer refused it where we carry on.
 854              */
 855             SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_R_NO_RENEGOTIATION);
 856             return -1;
 857         } else if (alert_level == SSL3_AL_WARNING) {
 858             /* We ignore any other warning alert in TLSv1.2 and below */
 859             goto start;
 860         }
 861
 862         SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_R_UNKNOWN_ALERT_TYPE);
 863         return -1;
 864     }
 865
 866     if ((s->shutdown & SSL_SENT_SHUTDOWN) != 0) {
 867         if (rr->type == SSL3_RT_HANDSHAKE) {
 868             BIO *rbio;
 869
 870             /*
 871              * We ignore any handshake messages sent to us unless they are
 872              * TLSv1.3 in which case we want to process them. For all other
 873              * handshake messages we can't do anything reasonable with them
 874              * because we are unable to write any response due to having already
 875              * sent close_notify.
 876              */
 877             if (!SSL_CONNECTION_IS_TLS13(s)) {
 878                 ssl_release_record(s, rr);
 879
 880                 if ((s->mode & SSL_MODE_AUTO_RETRY) != 0)
 881                     goto start;
 882
 883                 s->rwstate = SSL_READING;
 884                 rbio = SSL_get_rbio(ssl);
 885                 BIO_clear_retry_flags(rbio);
 886                 BIO_set_retry_read(rbio);
 887                 return -1;
 888             }
 889         } else {
 890             /*
 891              * The peer is continuing to send application data, but we have
 892              * already sent close_notify. If this was expected we should have
 893              * been called via SSL_read() and this would have been handled
 894              * above.
 895              * No alert sent because we already sent close_notify
 896              */
 897             ssl_release_record(s, rr);
 898             SSLfatal(s, SSL_AD_NO_ALERT,
 899                      SSL_R_APPLICATION_DATA_AFTER_CLOSE_NOTIFY);
 900             return -1;
 901         }
 902     }
 903
 904     /*
 905      * For handshake data we have 'fragment' storage, so fill that so that we
 906      * can process the header at a fixed place. This is done after the
 907      * "SHUTDOWN" code above to avoid filling the fragment storage with data
 908      * that we're just going to discard.
 909      */
 910     if (rr->type == SSL3_RT_HANDSHAKE) {
 911         size_t dest_maxlen = sizeof(s->rlayer.handshake_fragment);
 912         unsigned char *dest = s->rlayer.handshake_fragment;
 913         size_t *dest_len = &s->rlayer.handshake_fragment_len;
 914
 915         n = dest_maxlen - *dest_len; /* available space in 'dest' */
 916         if (rr->length < n)
 917             n = rr->length; /* available bytes */
 918
 919         /* now move 'n' bytes: */
 920         memcpy(dest + *dest_len, rr->data + rr->off, n);
 921         rr->off += n;
 922         rr->length -= n;
 923         *dest_len += n;
 924         if (rr->length == 0)
 925             ssl_release_record(s, rr);
 926
 927         if (*dest_len < dest_maxlen)
 928             goto start;     /* fragment was too small */
 929     }
 930
 931     if (rr->type == SSL3_RT_CHANGE_CIPHER_SPEC) {
 932         SSLfatal(s, SSL_AD_UNEXPECTED_MESSAGE, SSL_R_CCS_RECEIVED_EARLY);
 933         return -1;
 934     }
 935
 936     /*
 937      * Unexpected handshake message (ClientHello, NewSessionTicket (TLS1.3) or
 938      * protocol violation)
 939      */
 940     if ((s->rlayer.handshake_fragment_len >= 4)
 941             && !ossl_statem_get_in_handshake(s)) {
 942         int ined = (s->early_data_state == SSL_EARLY_DATA_READING);
 943
 944         /* We found handshake data, so we're going back into init */
 945         ossl_statem_set_in_init(s, 1);
 946
 947         i = s->handshake_func(ssl);
 948         /* SSLfatal() already called if appropriate */
 949         if (i < 0)
 950             return i;
 951         if (i == 0) {
 952             return -1;
 953         }
 954
 955         /*
 956          * If we were actually trying to read early data and we found a
 957          * handshake message, then we don't want to continue to try and read
 958          * the application data any more. It won't be "early" now.
 959          */
 960         if (ined)
 961             return -1;
 962
 963         if (!(s->mode & SSL_MODE_AUTO_RETRY)) {
 964             if (!RECORD_LAYER_read_pending(&s->rlayer)) {
 965                 BIO *bio;
 966                 /*
 967                  * In the case where we try to read application data, but we
 968                  * trigger an SSL handshake, we return -1 with the retry
 969                  * option set.  Otherwise renegotiation may cause nasty
 970                  * problems in the blocking world
 971                  */
 972                 s->rwstate = SSL_READING;
 973                 bio = SSL_get_rbio(ssl);
 974                 BIO_clear_retry_flags(bio);
 975                 BIO_set_retry_read(bio);
 976                 return -1;
 977             }
 978         }
 979         goto start;
 980     }
 981
 982     switch (rr->type) {
 983     default:
 984         /*
 985          * TLS 1.0 and 1.1 say you SHOULD ignore unrecognised record types, but
 986          * TLS 1.2 says you MUST send an unexpected message alert. We use the
 987          * TLS 1.2 behaviour for all protocol versions to prevent issues where
 988          * no progress is being made and the peer continually sends unrecognised
 989          * record types, using up resources processing them.
 990          */
 991         SSLfatal(s, SSL_AD_UNEXPECTED_MESSAGE, SSL_R_UNEXPECTED_RECORD);
 992         return -1;
 993     case SSL3_RT_CHANGE_CIPHER_SPEC:
 994     case SSL3_RT_ALERT:
 995     case SSL3_RT_HANDSHAKE:
 996         /*
 997          * we already handled all of these, with the possible exception of
 998          * SSL3_RT_HANDSHAKE when ossl_statem_get_in_handshake(s) is true, but
 999          * that should not happen when type != rr->type
1000          */
1001         SSLfatal(s, SSL_AD_UNEXPECTED_MESSAGE, ERR_R_INTERNAL_ERROR);
1002         return -1;
1003     case SSL3_RT_APPLICATION_DATA:
1004         /*
1005          * At this point, we were expecting handshake data, but have
1006          * application data.  If the library was running inside ssl3_read()
1007          * (i.e. in_read_app_data is set) and it makes sense to read
1008          * application data at this point (session renegotiation not yet
1009          * started), we will indulge it.
1010          */
1011         if (ossl_statem_app_data_allowed(s)) {
1012             s->s3.in_read_app_data = 2;
1013             return -1;
1014         } else if (ossl_statem_skip_early_data(s)) {
1015             /*
1016              * This can happen after a client sends a CH followed by early_data,
1017              * but the server responds with a HelloRetryRequest. The server
1018              * reads the next record from the client expecting to find a
1019              * plaintext ClientHello but gets a record which appears to be
1020              * application data. The trial decrypt "works" because null
1021              * decryption was applied. We just skip it and move on to the next
1022              * record.
1023              */
1024             if (!ossl_early_data_count_ok(s, rr->length,
1025                                           EARLY_DATA_CIPHERTEXT_OVERHEAD, 0)) {
1026                 /* SSLfatal() already called */
1027                 return -1;
1028             }
1029             ssl_release_record(s, rr);
1030             goto start;
1031         } else {
1032             SSLfatal(s, SSL_AD_UNEXPECTED_MESSAGE, SSL_R_UNEXPECTED_RECORD);
1033             return -1;
1034         }
1035     }
1036 }
1037
1038 /*
1039  * Returns true if the current rrec was sent in SSLv2 backwards compatible
1040  * format and false otherwise.
1041  */
1042 int RECORD_LAYER_is_sslv2_record(RECORD_LAYER *rl)
1043 {
1044     if (SSL_CONNECTION_IS_DTLS(rl->s))
1045         return 0;
1046     return rl->tlsrecs[0].version == SSL2_VERSION;
1047 }
1048
1049 static OSSL_FUNC_rlayer_msg_callback_fn rlayer_msg_callback_wrapper;
1050 static void rlayer_msg_callback_wrapper(int write_p, int version,
1051                                         int content_type, const void *buf,
1052                                         size_t len, void *cbarg)
1053 {
1054     SSL_CONNECTION *s = cbarg;
1055     SSL *ssl = SSL_CONNECTION_GET_SSL(s);
1056
1057     if (s->msg_callback != NULL)
1058         s->msg_callback(write_p, version, content_type, buf, len, ssl,
1059                         s->msg_callback_arg);
1060 }
1061
1062 static OSSL_FUNC_rlayer_security_fn rlayer_security_wrapper;
1063 static int rlayer_security_wrapper(void *cbarg, int op, int bits, int nid,
1064                                    void *other)
1065 {
1066     SSL_CONNECTION *s = cbarg;
1067
1068     return ssl_security(s, op, bits, nid, other);
1069 }
1070
1071 static OSSL_FUNC_rlayer_padding_fn rlayer_padding_wrapper;
1072 static size_t rlayer_padding_wrapper(void *cbarg, int type, size_t len)
1073 {
1074     SSL_CONNECTION *s = cbarg;
1075     SSL *ssl = SSL_CONNECTION_GET_SSL(s);
1076
1077     return s->rlayer.record_padding_cb(ssl, type, len,
1078                                        s->rlayer.record_padding_arg);
1079 }
1080
1081 static const OSSL_DISPATCH rlayer_dispatch[] = {
1082     { OSSL_FUNC_RLAYER_SKIP_EARLY_DATA, (void (*)(void))ossl_statem_skip_early_data },
1083     { OSSL_FUNC_RLAYER_MSG_CALLBACK, (void (*)(void))rlayer_msg_callback_wrapper },
1084     { OSSL_FUNC_RLAYER_SECURITY, (void (*)(void))rlayer_security_wrapper },
1085     { OSSL_FUNC_RLAYER_PADDING, (void (*)(void))rlayer_padding_wrapper },
1086     { 0, NULL }
1087 };
1088
1089 static const OSSL_RECORD_METHOD *ssl_select_next_record_layer(SSL_CONNECTION *s,
1090                                                               int direction,
1091                                                               int level)
1092 {
1093
1094     if (level == OSSL_RECORD_PROTECTION_LEVEL_NONE) {
1095         if (SSL_CONNECTION_IS_DTLS(s))
1096             return &ossl_dtls_record_method;
1097
1098         return &ossl_tls_record_method;
1099     }
1100
1101 #ifndef OPENSSL_NO_KTLS
1102     /* KTLS does not support renegotiation */
1103     if (level == OSSL_RECORD_PROTECTION_LEVEL_APPLICATION
1104             && (s->options & SSL_OP_ENABLE_KTLS) != 0
1105             && (SSL_CONNECTION_IS_TLS13(s) || SSL_IS_FIRST_HANDSHAKE(s)))
1106         return &ossl_ktls_record_method;
1107 #endif
1108
1109     /* Default to the current OSSL_RECORD_METHOD */
1110     return direction == OSSL_RECORD_DIRECTION_READ ? s->rlayer.rrlmethod
1111                                                    : s->rlayer.wrlmethod;
1112 }
1113
1114 static int ssl_post_record_layer_select(SSL_CONNECTION *s, int direction)
1115 {
1116     const OSSL_RECORD_METHOD *thismethod;
1117     OSSL_RECORD_LAYER *thisrl;
1118
1119     if (direction == OSSL_RECORD_DIRECTION_READ) {
1120         thismethod = s->rlayer.rrlmethod;
1121         thisrl = s->rlayer.rrl;
1122     } else {
1123         thismethod = s->rlayer.wrlmethod;
1124         thisrl = s->rlayer.wrl;
1125     }
1126
1127 #ifndef OPENSSL_NO_KTLS
1128     {
1129         SSL *ssl = SSL_CONNECTION_GET_SSL(s);
1130
1131         if (s->rlayer.rrlmethod == &ossl_ktls_record_method) {
1132             /* KTLS does not support renegotiation so disallow it */
1133             SSL_set_options(ssl, SSL_OP_NO_RENEGOTIATION);
1134         }
1135     }
1136 #endif
1137     if (SSL_IS_FIRST_HANDSHAKE(s) && thismethod->set_first_handshake != NULL)
1138         thismethod->set_first_handshake(thisrl, 1);
1139
1140     if (s->max_pipelines != 0 && thismethod->set_max_pipelines != NULL)
1141         thismethod->set_max_pipelines(thisrl, s->max_pipelines);
1142
1143     return 1;
1144 }
1145
1146 int ssl_set_new_record_layer(SSL_CONNECTION *s, int version,
1147                              int direction, int level,
1148                              unsigned char *key, size_t keylen,
1149                              unsigned char *iv,  size_t ivlen,
1150                              unsigned char *mackey, size_t mackeylen,
1151                              const EVP_CIPHER *ciph, size_t taglen,
1152                              int mactype, const EVP_MD *md,
1153                              const SSL_COMP *comp)
1154 {
1155     OSSL_PARAM options[5], *opts = options;
1156     OSSL_PARAM settings[6], *set =  settings;
1157     const OSSL_RECORD_METHOD **thismethod;
1158     OSSL_RECORD_LAYER **thisrl, *newrl = NULL;
1159     BIO *thisbio;
1160     SSL_CTX *sctx = SSL_CONNECTION_GET_CTX(s);
1161     const OSSL_RECORD_METHOD *meth;
1162     int use_etm, stream_mac = 0, tlstree = 0;
1163     unsigned int maxfrag = (direction == OSSL_RECORD_DIRECTION_WRITE)
1164                            ? ssl_get_max_send_fragment(s)
1165                            : SSL3_RT_MAX_PLAIN_LENGTH;
1166     int use_early_data = 0;
1167     uint32_t max_early_data;
1168     COMP_METHOD *compm = (comp == NULL) ? NULL : comp->method;
1169
1170     meth = ssl_select_next_record_layer(s, direction, level);
1171
1172     if (direction == OSSL_RECORD_DIRECTION_READ) {
1173         thismethod = &s->rlayer.rrlmethod;
1174         thisrl = &s->rlayer.rrl;
1175         thisbio = s->rbio;
1176     } else {
1177         thismethod = &s->rlayer.wrlmethod;
1178         thisrl = &s->rlayer.wrl;
1179         thisbio = s->wbio;
1180     }
1181
1182     if (meth == NULL)
1183         meth = *thismethod;
1184
1185     if (!ossl_assert(meth != NULL)) {
1186         ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR);
1187         return 0;
1188     }
1189
1190     /* Parameters that *may* be supported by a record layer if passed */
1191     *opts++ = OSSL_PARAM_construct_uint64(OSSL_LIBSSL_RECORD_LAYER_PARAM_OPTIONS,
1192                                           &s->options);
1193     *opts++ = OSSL_PARAM_construct_uint32(OSSL_LIBSSL_RECORD_LAYER_PARAM_MODE,
1194                                           &s->mode);
1195     if (direction == OSSL_RECORD_DIRECTION_READ) {
1196         *opts++ = OSSL_PARAM_construct_size_t(OSSL_LIBSSL_RECORD_LAYER_READ_BUFFER_LEN,
1197                                               &s->rlayer.default_read_buf_len);
1198         *opts++ = OSSL_PARAM_construct_int(OSSL_LIBSSL_RECORD_LAYER_PARAM_READ_AHEAD,
1199                                            &s->rlayer.read_ahead);
1200     } else {
1201         *opts++ = OSSL_PARAM_construct_size_t(OSSL_LIBSSL_RECORD_LAYER_PARAM_BLOCK_PADDING,
1202                                               &s->rlayer.block_padding);
1203     }
1204     *opts = OSSL_PARAM_construct_end();
1205
1206     /* Parameters that *must* be supported by a record layer if passed */
1207     if (direction == OSSL_RECORD_DIRECTION_READ) {
1208         use_etm = SSL_READ_ETM(s) ? 1 : 0;
1209         if ((s->mac_flags & SSL_MAC_FLAG_READ_MAC_STREAM) != 0)
1210             stream_mac = 1;
1211
1212         if ((s->mac_flags & SSL_MAC_FLAG_READ_MAC_TLSTREE) != 0)
1213             tlstree = 1;
1214     } else {
1215         use_etm = SSL_WRITE_ETM(s) ? 1 : 0;
1216         if ((s->mac_flags & SSL_MAC_FLAG_WRITE_MAC_STREAM) != 0)
1217             stream_mac = 1;
1218
1219         if ((s->mac_flags & SSL_MAC_FLAG_WRITE_MAC_TLSTREE) != 0)
1220             tlstree = 1;
1221     }
1222
1223     if (use_etm)
1224         *set++ = OSSL_PARAM_construct_int(OSSL_LIBSSL_RECORD_LAYER_PARAM_USE_ETM,
1225                                           &use_etm);
1226
1227     if (stream_mac)
1228         *set++ = OSSL_PARAM_construct_int(OSSL_LIBSSL_RECORD_LAYER_PARAM_STREAM_MAC,
1229                                           &stream_mac);
1230
1231     if (tlstree)
1232         *set++ = OSSL_PARAM_construct_int(OSSL_LIBSSL_RECORD_LAYER_PARAM_TLSTREE,
1233                                           &tlstree);
1234
1235     /*
1236      * We only need to do this for the read side. The write side should already
1237      * have the correct value due to the ssl_get_max_send_fragment() call above
1238      */
1239     if (direction == OSSL_RECORD_DIRECTION_READ
1240             && s->session != NULL
1241             && USE_MAX_FRAGMENT_LENGTH_EXT(s->session))
1242         maxfrag = GET_MAX_FRAGMENT_LENGTH(s->session);
1243
1244
1245     if (maxfrag != SSL3_RT_MAX_PLAIN_LENGTH)
1246         *set++ = OSSL_PARAM_construct_uint(OSSL_LIBSSL_RECORD_LAYER_PARAM_MAX_FRAG_LEN,
1247                                            &maxfrag);
1248
1249     /*
1250      * The record layer must check the amount of early data sent or received
1251      * using the early keys. A server also needs to worry about rejected early
1252      * data that might arrive when the handshake keys are in force.
1253      */
1254     if (s->server && direction == OSSL_RECORD_DIRECTION_READ) {
1255         use_early_data = (level == OSSL_RECORD_PROTECTION_LEVEL_EARLY
1256                           || level == OSSL_RECORD_PROTECTION_LEVEL_HANDSHAKE);
1257     } else if (!s->server && direction == OSSL_RECORD_DIRECTION_WRITE) {
1258         use_early_data = (level == OSSL_RECORD_PROTECTION_LEVEL_EARLY);
1259     }
1260     if (use_early_data) {
1261         max_early_data = ossl_get_max_early_data(s);
1262
1263         if (max_early_data != 0)
1264             *set++ = OSSL_PARAM_construct_uint32(OSSL_LIBSSL_RECORD_LAYER_PARAM_MAX_EARLY_DATA,
1265                                                  &max_early_data);
1266     }
1267
1268     *set = OSSL_PARAM_construct_end();
1269
1270     for (;;) {
1271         int rlret;
1272         BIO *prev = NULL;
1273         BIO *next = NULL;
1274         unsigned int epoch = 0;
1275         OSSL_DISPATCH rlayer_dispatch_tmp[OSSL_NELEM(rlayer_dispatch)];
1276         size_t i, j;
1277
1278         if (direction == OSSL_RECORD_DIRECTION_READ) {
1279             prev = s->rlayer.rrlnext;
1280             if (SSL_CONNECTION_IS_DTLS(s)
1281                     && level != OSSL_RECORD_PROTECTION_LEVEL_NONE)
1282                 epoch =  DTLS_RECORD_LAYER_get_r_epoch(&s->rlayer) + 1; /* new epoch */
1283
1284             if (SSL_CONNECTION_IS_DTLS(s))
1285                 next = BIO_new(BIO_s_dgram_mem());
1286             else
1287                 next = BIO_new(BIO_s_mem());
1288
1289             if (next == NULL) {
1290                 BIO_free(prev);
1291                 SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
1292                 return 0;
1293             }
1294             s->rlayer.rrlnext = next;
1295         } else {
1296             if (SSL_CONNECTION_IS_DTLS(s)
1297                     && level != OSSL_RECORD_PROTECTION_LEVEL_NONE)
1298                 epoch =  DTLS_RECORD_LAYER_get_w_epoch(&s->rlayer) + 1; /* new epoch */
1299         }
1300
1301         /*
1302          * Create a copy of the dispatch array, missing out wrappers for
1303          * callbacks that we don't need.
1304          */
1305         for (i = 0, j = 0; i < OSSL_NELEM(rlayer_dispatch); i++) {
1306             switch (rlayer_dispatch[i].function_id) {
1307             case OSSL_FUNC_RLAYER_MSG_CALLBACK:
1308                 if (s->msg_callback == NULL)
1309                     continue;
1310                 break;
1311             case OSSL_FUNC_RLAYER_PADDING:
1312                 if (s->rlayer.record_padding_cb == NULL)
1313                     continue;
1314                 break;
1315             default:
1316                 break;
1317             }
1318             rlayer_dispatch_tmp[j++] = rlayer_dispatch[i];
1319         }
1320
1321         rlret = meth->new_record_layer(sctx->libctx, sctx->propq, version,
1322                                        s->server, direction, level, epoch,
1323                                        key, keylen, iv, ivlen, mackey,
1324                                        mackeylen, ciph, taglen, mactype, md,
1325                                        compm, prev, thisbio, next, NULL, NULL,
1326                                        settings, options, rlayer_dispatch_tmp,
1327                                        s, &newrl);
1328         BIO_free(prev);
1329         switch (rlret) {
1330         case OSSL_RECORD_RETURN_FATAL:
1331             SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_RECORD_LAYER_FAILURE);
1332             return 0;
1333
1334         case OSSL_RECORD_RETURN_NON_FATAL_ERR:
1335             if (*thismethod != meth && *thismethod != NULL) {
1336                 /*
1337                  * We tried a new record layer method, but it didn't work out,
1338                  * so we fallback to the original method and try again
1339                  */
1340                 meth = *thismethod;
1341                 continue;
1342             }
1343             SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_R_NO_SUITABLE_RECORD_LAYER);
1344             return 0;
1345
1346         case OSSL_RECORD_RETURN_SUCCESS:
1347             break;
1348
1349         default:
1350             /* Should not happen */
1351             SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
1352             return 0;
1353         }
1354         break;
1355     }
1356
1357     /*
1358      * Free the old record layer if we have one except in the case of DTLS when
1359      * writing and there are still buffered sent messages in our queue. In that
1360      * case the record layer is still referenced by those buffered messages for
1361      * potential retransmit. Only when those buffered messages get freed do we
1362      * free the record layer object (see dtls1_hm_fragment_free)
1363      */
1364     if (!SSL_CONNECTION_IS_DTLS(s)
1365             || direction == OSSL_RECORD_DIRECTION_READ
1366             || pqueue_peek(s->d1->sent_messages) == NULL) {
1367         if (*thismethod != NULL && !(*thismethod)->free(*thisrl)) {
1368             SSLfatal(s, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
1369             return 0;
1370         }
1371     }
1372
1373     *thisrl = newrl;
1374     *thismethod = meth;
1375
1376     return ssl_post_record_layer_select(s, direction);
1377 }
1378
1379 int ssl_set_record_protocol_version(SSL_CONNECTION *s, int vers)
1380 {
1381     if (!ossl_assert(s->rlayer.rrlmethod != NULL)
1382             || !ossl_assert(s->rlayer.wrlmethod != NULL))
1383         return 0;
1384     s->rlayer.rrlmethod->set_protocol_version(s->rlayer.rrl, s->version);
1385     s->rlayer.wrlmethod->set_protocol_version(s->rlayer.wrl, s->version);
1386
1387     return 1;
1388 }