ssl/record/methods/dtls_meth.c

   1 /*
   2  * Copyright 2018-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 "../../ssl_local.h"
  11 #include "../record_local.h"
  12 #include "recmethod_local.h"
  13
  14 /* mod 128 saturating subtract of two 64-bit values in big-endian order */
  15 static int satsub64be(const unsigned char *v1, const unsigned char *v2)
  16 {
  17     int64_t ret;
  18     uint64_t l1, l2;
  19
  20     n2l8(v1, l1);
  21     n2l8(v2, l2);
  22
  23     ret = l1 - l2;
  24
  25     /* We do not permit wrap-around */
  26     if (l1 > l2 && ret < 0)
  27         return 128;
  28     else if (l2 > l1 && ret > 0)
  29         return -128;
  30
  31     if (ret > 128)
  32         return 128;
  33     else if (ret < -128)
  34         return -128;
  35     else
  36         return (int)ret;
  37 }
  38
  39 static int dtls_record_replay_check(OSSL_RECORD_LAYER *rl, DTLS_BITMAP *bitmap)
  40 {
  41     int cmp;
  42     unsigned int shift;
  43     const unsigned char *seq = rl->sequence;
  44
  45     cmp = satsub64be(seq, bitmap->max_seq_num);
  46     if (cmp > 0) {
  47         SSL3_RECORD_set_seq_num(&rl->rrec[0], seq);
  48         return 1;               /* this record in new */
  49     }
  50     shift = -cmp;
  51     if (shift >= sizeof(bitmap->map) * 8)
  52         return 0;               /* stale, outside the window */
  53     else if (bitmap->map & ((uint64_t)1 << shift))
  54         return 0;               /* record previously received */
  55
  56     SSL3_RECORD_set_seq_num(&rl->rrec[0], seq);
  57     return 1;
  58 }
  59
  60 static void dtls_record_bitmap_update(OSSL_RECORD_LAYER *rl,
  61                                       DTLS_BITMAP *bitmap)
  62 {
  63     int cmp;
  64     unsigned int shift;
  65     const unsigned char *seq = rl->sequence;
  66
  67     cmp = satsub64be(seq, bitmap->max_seq_num);
  68     if (cmp > 0) {
  69         shift = cmp;
  70         if (shift < sizeof(bitmap->map) * 8)
  71             bitmap->map <<= shift, bitmap->map |= 1UL;
  72         else
  73             bitmap->map = 1UL;
  74         memcpy(bitmap->max_seq_num, seq, SEQ_NUM_SIZE);
  75     } else {
  76         shift = -cmp;
  77         if (shift < sizeof(bitmap->map) * 8)
  78             bitmap->map |= (uint64_t)1 << shift;
  79     }
  80 }
  81
  82 static DTLS_BITMAP *dtls_get_bitmap(OSSL_RECORD_LAYER *rl, SSL3_RECORD *rr,
  83                                     unsigned int *is_next_epoch)
  84 {
  85     *is_next_epoch = 0;
  86
  87     /* In current epoch, accept HM, CCS, DATA, & ALERT */
  88     if (rr->epoch == rl->epoch)
  89         return &rl->bitmap;
  90
  91     /*
  92      * Only HM and ALERT messages can be from the next epoch and only if we
  93      * have already processed all of the unprocessed records from the last
  94      * epoch
  95      */
  96     else if (rr->epoch == (unsigned long)(rl->epoch + 1)
  97              && rl->unprocessed_rcds.epoch != rl->epoch
  98              && (rr->type == SSL3_RT_HANDSHAKE || rr->type == SSL3_RT_ALERT)) {
  99         *is_next_epoch = 1;
 100         return &rl->next_bitmap;
 101     }
 102
 103     return NULL;
 104 }
 105
 106 static void dtls_set_in_init(OSSL_RECORD_LAYER *rl, int in_init)
 107 {
 108     rl->in_init = in_init;
 109 }
 110
 111 static int dtls_process_record(OSSL_RECORD_LAYER *rl, DTLS_BITMAP *bitmap)
 112 {
 113     int i;
 114     int enc_err;
 115     SSL3_RECORD *rr;
 116     int imac_size;
 117     size_t mac_size = 0;
 118     unsigned char md[EVP_MAX_MD_SIZE];
 119     SSL_MAC_BUF macbuf = { NULL, 0 };
 120     int ret = 0;
 121
 122     rr = &rl->rrec[0];
 123
 124     /*
 125      * At this point, rl->packet_length == DTLS1_RT_HEADER_LENGTH + rr->length,
 126      * and we have that many bytes in rl->packet
 127      */
 128     rr->input = &(rl->packet[DTLS1_RT_HEADER_LENGTH]);
 129
 130     /*
 131      * ok, we can now read from 'rl->packet' data into 'rr'. rr->input
 132      * points at rr->length bytes, which need to be copied into rr->data by
 133      * either the decryption or by the decompression. When the data is 'copied'
 134      * into the rr->data buffer, rr->input will be pointed at the new buffer
 135      */
 136
 137     /*
 138      * We now have - encrypted [ MAC [ compressed [ plain ] ] ] rr->length
 139      * bytes of encrypted compressed stuff.
 140      */
 141
 142     /* check is not needed I believe */
 143     if (rr->length > SSL3_RT_MAX_ENCRYPTED_LENGTH) {
 144         RLAYERfatal(rl, SSL_AD_RECORD_OVERFLOW, SSL_R_ENCRYPTED_LENGTH_TOO_LONG);
 145         return 0;
 146     }
 147
 148     /* decrypt in place in 'rr->input' */
 149     rr->data = rr->input;
 150     rr->orig_len = rr->length;
 151
 152     if (rl->md_ctx != NULL) {
 153         const EVP_MD *tmpmd = EVP_MD_CTX_get0_md(rl->md_ctx);
 154
 155         if (tmpmd != NULL) {
 156             imac_size = EVP_MD_get_size(tmpmd);
 157             if (!ossl_assert(imac_size >= 0 && imac_size <= EVP_MAX_MD_SIZE)) {
 158                 RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_EVP_LIB);
 159                 return 0;
 160             }
 161             mac_size = (size_t)imac_size;
 162         }
 163     }
 164
 165     if (rl->use_etm && rl->md_ctx != NULL) {
 166         unsigned char *mac;
 167
 168         if (rr->orig_len < mac_size) {
 169             RLAYERfatal(rl, SSL_AD_DECODE_ERROR, SSL_R_LENGTH_TOO_SHORT);
 170             return 0;
 171         }
 172         rr->length -= mac_size;
 173         mac = rr->data + rr->length;
 174         i = rl->funcs->mac(rl, rr, md, 0 /* not send */);
 175         if (i == 0 || CRYPTO_memcmp(md, mac, (size_t)mac_size) != 0) {
 176             RLAYERfatal(rl, SSL_AD_BAD_RECORD_MAC,
 177                         SSL_R_DECRYPTION_FAILED_OR_BAD_RECORD_MAC);
 178             return 0;
 179         }
 180         /*
 181          * We've handled the mac now - there is no MAC inside the encrypted
 182          * record
 183          */
 184         mac_size = 0;
 185     }
 186
 187     /*
 188      * Set a mark around the packet decryption attempt.  This is DTLS, so
 189      * bad packets are just ignored, and we don't want to leave stray
 190      * errors in the queue from processing bogus junk that we ignored.
 191      */
 192     ERR_set_mark();
 193     enc_err = rl->funcs->cipher(rl, rr, 1, 0, &macbuf, mac_size);
 194
 195     /*-
 196      * enc_err is:
 197      *    0: if the record is publicly invalid, or an internal error, or AEAD
 198      *       decryption failed, or ETM decryption failed.
 199      *    1: Success or MTE decryption failed (MAC will be randomised)
 200      */
 201     if (enc_err == 0) {
 202         ERR_pop_to_mark();
 203         if (rl->alert != SSL_AD_NO_ALERT) {
 204             /* RLAYERfatal() already called */
 205             goto end;
 206         }
 207         /* For DTLS we simply ignore bad packets. */
 208         rr->length = 0;
 209         rl->packet_length = 0;
 210         goto end;
 211     }
 212     ERR_clear_last_mark();
 213     OSSL_TRACE_BEGIN(TLS) {
 214         BIO_printf(trc_out, "dec %zd\n", rr->length);
 215         BIO_dump_indent(trc_out, rr->data, rr->length, 4);
 216     } OSSL_TRACE_END(TLS);
 217
 218     /* r->length is now the compressed data plus mac */
 219     if (!rl->use_etm
 220             && (rl->enc_ctx != NULL)
 221             && (EVP_MD_CTX_get0_md(rl->md_ctx) != NULL)) {
 222         /* rl->md_ctx != NULL => mac_size != -1 */
 223
 224         i = rl->funcs->mac(rl, rr, md, 0 /* not send */);
 225         if (i == 0 || macbuf.mac == NULL
 226             || CRYPTO_memcmp(md, macbuf.mac, mac_size) != 0)
 227             enc_err = 0;
 228         if (rr->length > SSL3_RT_MAX_COMPRESSED_LENGTH + mac_size)
 229             enc_err = 0;
 230     }
 231
 232     if (enc_err == 0) {
 233         /* decryption failed, silently discard message */
 234         rr->length = 0;
 235         rl->packet_length = 0;
 236         goto end;
 237     }
 238
 239     /* r->length is now just compressed */
 240     if (rl->compctx != NULL) {
 241         if (rr->length > SSL3_RT_MAX_COMPRESSED_LENGTH) {
 242             RLAYERfatal(rl, SSL_AD_RECORD_OVERFLOW,
 243                         SSL_R_COMPRESSED_LENGTH_TOO_LONG);
 244             goto end;
 245         }
 246         if (!tls_do_uncompress(rl, rr)) {
 247             RLAYERfatal(rl, SSL_AD_DECOMPRESSION_FAILURE, SSL_R_BAD_DECOMPRESSION);
 248             goto end;
 249         }
 250     }
 251
 252     /*
 253      * Check if the received packet overflows the current Max Fragment
 254      * Length setting.
 255      */
 256     if (rr->length > rl->max_frag_len) {
 257         RLAYERfatal(rl, SSL_AD_RECORD_OVERFLOW, SSL_R_DATA_LENGTH_TOO_LONG);
 258         goto end;
 259     }
 260
 261     rr->off = 0;
 262     /*-
 263      * So at this point the following is true
 264      * ssl->s3.rrec.type   is the type of record
 265      * ssl->s3.rrec.length == number of bytes in record
 266      * ssl->s3.rrec.off    == offset to first valid byte
 267      * ssl->s3.rrec.data   == where to take bytes from, increment
 268      *                        after use :-).
 269      */
 270
 271     /* we have pulled in a full packet so zero things */
 272     rl->packet_length = 0;
 273
 274     /* Mark receipt of record. */
 275     dtls_record_bitmap_update(rl, bitmap);
 276
 277     ret = 1;
 278  end:
 279     if (macbuf.alloced)
 280         OPENSSL_free(macbuf.mac);
 281     return ret;
 282 }
 283
 284 static int dtls_rlayer_buffer_record(OSSL_RECORD_LAYER *rl, record_pqueue *queue,
 285                                      unsigned char *priority)
 286 {
 287     DTLS_RLAYER_RECORD_DATA *rdata;
 288     pitem *item;
 289
 290     /* Limit the size of the queue to prevent DOS attacks */
 291     if (pqueue_size(queue->q) >= 100)
 292         return 0;
 293
 294     rdata = OPENSSL_malloc(sizeof(*rdata));
 295     item = pitem_new(priority, rdata);
 296     if (rdata == NULL || item == NULL) {
 297         OPENSSL_free(rdata);
 298         pitem_free(item);
 299         RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
 300         return -1;
 301     }
 302
 303     rdata->packet = rl->packet;
 304     rdata->packet_length = rl->packet_length;
 305     memcpy(&(rdata->rbuf), &rl->rbuf, sizeof(SSL3_BUFFER));
 306     memcpy(&(rdata->rrec), &rl->rrec[0], sizeof(SSL3_RECORD));
 307
 308     item->data = rdata;
 309
 310     rl->packet = NULL;
 311     rl->packet_length = 0;
 312     memset(&rl->rbuf, 0, sizeof(SSL3_BUFFER));
 313     memset(&rl->rrec[0], 0, sizeof(rl->rrec[0]));
 314
 315     if (!tls_setup_read_buffer(rl)) {
 316         /* RLAYERfatal() already called */
 317         OPENSSL_free(rdata->rbuf.buf);
 318         OPENSSL_free(rdata);
 319         pitem_free(item);
 320         return -1;
 321     }
 322
 323     if (pqueue_insert(queue->q, item) == NULL) {
 324         /* Must be a duplicate so ignore it */
 325         OPENSSL_free(rdata->rbuf.buf);
 326         OPENSSL_free(rdata);
 327         pitem_free(item);
 328     }
 329
 330     return 1;
 331 }
 332
 333 /* copy buffered record into OSSL_RECORD_LAYER structure */
 334 static int dtls_copy_rlayer_record(OSSL_RECORD_LAYER *rl, pitem *item)
 335 {
 336     DTLS_RLAYER_RECORD_DATA *rdata;
 337
 338     rdata = (DTLS_RLAYER_RECORD_DATA *)item->data;
 339
 340     SSL3_BUFFER_release(&rl->rbuf);
 341
 342     rl->packet = rdata->packet;
 343     rl->packet_length = rdata->packet_length;
 344     memcpy(&rl->rbuf, &(rdata->rbuf), sizeof(SSL3_BUFFER));
 345     memcpy(&rl->rrec[0], &(rdata->rrec), sizeof(SSL3_RECORD));
 346
 347     /* Set proper sequence number for mac calculation */
 348     memcpy(&(rl->sequence[2]), &(rdata->packet[5]), 6);
 349
 350     return 1;
 351 }
 352
 353 static int dtls_retrieve_rlayer_buffered_record(OSSL_RECORD_LAYER *rl,
 354                                                 record_pqueue *queue)
 355 {
 356     pitem *item;
 357
 358     item = pqueue_pop(queue->q);
 359     if (item) {
 360         dtls_copy_rlayer_record(rl, item);
 361
 362         OPENSSL_free(item->data);
 363         pitem_free(item);
 364
 365         return 1;
 366     }
 367
 368     return 0;
 369 }
 370
 371 /*-
 372  * Call this to get a new input record.
 373  * It will return <= 0 if more data is needed, normally due to an error
 374  * or non-blocking IO.
 375  * When it finishes, one packet has been decoded and can be found in
 376  * ssl->s3.rrec.type    - is the type of record
 377  * ssl->s3.rrec.data    - data
 378  * ssl->s3.rrec.length  - number of bytes
 379  */
 380 int dtls_get_more_records(OSSL_RECORD_LAYER *rl)
 381 {
 382     int ssl_major, ssl_minor;
 383     int rret;
 384     size_t more, n;
 385     SSL3_RECORD *rr;
 386     unsigned char *p = NULL;
 387     unsigned short version;
 388     DTLS_BITMAP *bitmap;
 389     unsigned int is_next_epoch;
 390
 391     rl->num_recs = 0;
 392     rl->curr_rec = 0;
 393     rl->num_released = 0;
 394
 395     rr = rl->rrec;
 396
 397     if (rl->rbuf.buf == NULL) {
 398         if (!tls_setup_read_buffer(rl)) {
 399             /* RLAYERfatal() already called */
 400             return OSSL_RECORD_RETURN_FATAL;
 401         }
 402     }
 403
 404  again:
 405     /* if we're renegotiating, then there may be buffered records */
 406     if (dtls_retrieve_rlayer_buffered_record(rl, &rl->processed_rcds)) {
 407         rl->num_recs = 1;
 408         return OSSL_RECORD_RETURN_SUCCESS;
 409     }
 410
 411     /* get something from the wire */
 412
 413     /* check if we have the header */
 414     if ((rl->rstate != SSL_ST_READ_BODY) ||
 415         (rl->packet_length < DTLS1_RT_HEADER_LENGTH)) {
 416         rret = rl->funcs->read_n(rl, DTLS1_RT_HEADER_LENGTH,
 417                                  SSL3_BUFFER_get_len(&rl->rbuf), 0, 1, &n);
 418         /* read timeout is handled by dtls1_read_bytes */
 419         if (rret < OSSL_RECORD_RETURN_SUCCESS) {
 420             /* RLAYERfatal() already called if appropriate */
 421             return rret;         /* error or non-blocking */
 422         }
 423
 424         /* this packet contained a partial record, dump it */
 425         if (rl->packet_length != DTLS1_RT_HEADER_LENGTH) {
 426             rl->packet_length = 0;
 427             goto again;
 428         }
 429
 430         rl->rstate = SSL_ST_READ_BODY;
 431
 432         p = rl->packet;
 433
 434         if (rl->msg_callback != NULL)
 435             rl->msg_callback(0, 0, SSL3_RT_HEADER, p, DTLS1_RT_HEADER_LENGTH,
 436                             rl->cbarg);
 437
 438         /* Pull apart the header into the DTLS1_RECORD */
 439         rr->type = *(p++);
 440         ssl_major = *(p++);
 441         ssl_minor = *(p++);
 442         version = (ssl_major << 8) | ssl_minor;
 443
 444         /* sequence number is 64 bits, with top 2 bytes = epoch */
 445         n2s(p, rr->epoch);
 446
 447         memcpy(&(rl->sequence[2]), p, 6);
 448         p += 6;
 449
 450         n2s(p, rr->length);
 451
 452         /*
 453          * Lets check the version. We tolerate alerts that don't have the exact
 454          * version number (e.g. because of protocol version errors)
 455          */
 456         if (!rl->is_first_record && rr->type != SSL3_RT_ALERT) {
 457             if (version != rl->version) {
 458                 /* unexpected version, silently discard */
 459                 rr->length = 0;
 460                 rl->packet_length = 0;
 461                 goto again;
 462             }
 463         }
 464
 465         if (ssl_major !=
 466                 (rl->version == DTLS_ANY_VERSION ? DTLS1_VERSION_MAJOR
 467                                                  : rl->version >> 8)) {
 468             /* wrong version, silently discard record */
 469             rr->length = 0;
 470             rl->packet_length = 0;
 471             goto again;
 472         }
 473
 474         if (rr->length > SSL3_RT_MAX_ENCRYPTED_LENGTH) {
 475             /* record too long, silently discard it */
 476             rr->length = 0;
 477             rl->packet_length = 0;
 478             goto again;
 479         }
 480
 481         /*
 482          * If received packet overflows maximum possible fragment length then
 483          * silently discard it
 484          */
 485         if (rr->length > rl->max_frag_len + SSL3_RT_MAX_ENCRYPTED_OVERHEAD) {
 486             /* record too long, silently discard it */
 487             rr->length = 0;
 488             rl->packet_length = 0;
 489             goto again;
 490         }
 491
 492         /* now rl->rstate == SSL_ST_READ_BODY */
 493     }
 494
 495     /* rl->rstate == SSL_ST_READ_BODY, get and decode the data */
 496
 497     if (rr->length > rl->packet_length - DTLS1_RT_HEADER_LENGTH) {
 498         /* now rl->packet_length == DTLS1_RT_HEADER_LENGTH */
 499         more = rr->length;
 500         rret = rl->funcs->read_n(rl, more, more, 1, 1, &n);
 501         /* this packet contained a partial record, dump it */
 502         if (rret < OSSL_RECORD_RETURN_SUCCESS || n != more) {
 503             if (rl->alert != SSL_AD_NO_ALERT) {
 504                 /* read_n() called RLAYERfatal() */
 505                 return OSSL_RECORD_RETURN_FATAL;
 506             }
 507             rr->length = 0;
 508             rl->packet_length = 0;
 509             goto again;
 510         }
 511
 512         /*
 513          * now n == rr->length,
 514          * and rl->packet_length ==  DTLS1_RT_HEADER_LENGTH + rr->length
 515          */
 516     }
 517     /* set state for later operations */
 518     rl->rstate = SSL_ST_READ_HEADER;
 519
 520     /* match epochs.  NULL means the packet is dropped on the floor */
 521     bitmap = dtls_get_bitmap(rl, rr, &is_next_epoch);
 522     if (bitmap == NULL) {
 523         rr->length = 0;
 524         rl->packet_length = 0; /* dump this record */
 525         goto again;             /* get another record */
 526     }
 527 #ifndef OPENSSL_NO_SCTP
 528     /* Only do replay check if no SCTP bio */
 529     if (!BIO_dgram_is_sctp(rl->bio)) {
 530 #endif
 531         /* Check whether this is a repeat, or aged record. */
 532         if (!dtls_record_replay_check(rl, bitmap)) {
 533             rr->length = 0;
 534             rl->packet_length = 0; /* dump this record */
 535             goto again;         /* get another record */
 536         }
 537 #ifndef OPENSSL_NO_SCTP
 538     }
 539 #endif
 540
 541     /* just read a 0 length packet */
 542     if (rr->length == 0)
 543         goto again;
 544
 545     /*
 546      * If this record is from the next epoch (either HM or ALERT), and a
 547      * handshake is currently in progress, buffer it since it cannot be
 548      * processed at this time.
 549      */
 550     if (is_next_epoch) {
 551         if (rl->in_init) {
 552             if (dtls_rlayer_buffer_record(rl, &(rl->unprocessed_rcds),
 553                                           rr->seq_num) < 0) {
 554                 /* RLAYERfatal() already called */
 555                 return OSSL_RECORD_RETURN_FATAL;
 556             }
 557         }
 558         rr->length = 0;
 559         rl->packet_length = 0;
 560         goto again;
 561     }
 562
 563     if (!dtls_process_record(rl, bitmap)) {
 564         if (rl->alert != SSL_AD_NO_ALERT) {
 565             /* dtls_process_record() called RLAYERfatal */
 566             return OSSL_RECORD_RETURN_FATAL;
 567         }
 568         rr->length = 0;
 569         rl->packet_length = 0; /* dump this record */
 570         goto again;             /* get another record */
 571     }
 572
 573     rl->num_recs = 1;
 574     return OSSL_RECORD_RETURN_SUCCESS;
 575 }
 576
 577 static int dtls_free(OSSL_RECORD_LAYER *rl)
 578 {
 579     SSL3_BUFFER *rbuf;
 580     size_t left, written;
 581     pitem *item;
 582     DTLS_RLAYER_RECORD_DATA *rdata;
 583     int ret = 1;
 584
 585     rbuf = &rl->rbuf;
 586
 587     left = rbuf->left;
 588     if (left > 0) {
 589         /*
 590          * This record layer is closing but we still have data left in our
 591          * buffer. It must be destined for the next epoch - so push it there.
 592          */
 593         ret = BIO_write_ex(rl->next, rbuf->buf + rbuf->offset, left, &written);
 594         rbuf->left = 0;
 595     }
 596
 597     if (rl->unprocessed_rcds.q != NULL) {
 598         while ((item = pqueue_pop(rl->unprocessed_rcds.q)) != NULL) {
 599             rdata = (DTLS_RLAYER_RECORD_DATA *)item->data;
 600             /* Push to the next record layer */
 601             ret &= BIO_write_ex(rl->next, rdata->packet, rdata->packet_length,
 602                                 &written);
 603             OPENSSL_free(rdata->rbuf.buf);
 604             OPENSSL_free(item->data);
 605             pitem_free(item);
 606         }
 607         pqueue_free(rl->unprocessed_rcds.q);
 608     }
 609
 610     if (rl->processed_rcds.q != NULL) {
 611         while ((item = pqueue_pop(rl->processed_rcds.q)) != NULL) {
 612             rdata = (DTLS_RLAYER_RECORD_DATA *)item->data;
 613             OPENSSL_free(rdata->rbuf.buf);
 614             OPENSSL_free(item->data);
 615             pitem_free(item);
 616         }
 617         pqueue_free(rl->processed_rcds.q);
 618     }
 619
 620     return tls_free(rl) && ret;
 621 }
 622
 623 static int
 624 dtls_new_record_layer(OSSL_LIB_CTX *libctx, const char *propq, int vers,
 625                       int role, int direction, int level, uint16_t epoch,
 626                       unsigned char *key, size_t keylen, unsigned char *iv,
 627                       size_t ivlen, unsigned char *mackey, size_t mackeylen,
 628                       const EVP_CIPHER *ciph, size_t taglen,
 629                       int mactype,
 630                       const EVP_MD *md, COMP_METHOD *comp, BIO *prev,
 631                       BIO *transport, BIO *next, BIO_ADDR *local, BIO_ADDR *peer,
 632                       const OSSL_PARAM *settings, const OSSL_PARAM *options,
 633                       const OSSL_DISPATCH *fns, void *cbarg,
 634                       OSSL_RECORD_LAYER **retrl)
 635 {
 636     int ret;
 637
 638     ret = tls_int_new_record_layer(libctx, propq, vers, role, direction, level,
 639                                    key, keylen, iv, ivlen, mackey, mackeylen,
 640                                    ciph, taglen, mactype, md, comp, prev,
 641                                    transport, next, local, peer, settings,
 642                                    options, fns, cbarg, retrl);
 643
 644     if (ret != OSSL_RECORD_RETURN_SUCCESS)
 645         return ret;
 646
 647     (*retrl)->unprocessed_rcds.q = pqueue_new();
 648     (*retrl)->processed_rcds.q = pqueue_new();
 649     if ((*retrl)->unprocessed_rcds.q == NULL
 650             || (*retrl)->processed_rcds.q == NULL) {
 651         dtls_free(*retrl);
 652         *retrl = NULL;
 653         ERR_raise(ERR_LIB_SSL, ERR_R_SSL_LIB);
 654         return OSSL_RECORD_RETURN_FATAL;
 655     }
 656
 657     (*retrl)->unprocessed_rcds.epoch = epoch + 1;
 658     (*retrl)->processed_rcds.epoch = epoch;
 659
 660     (*retrl)->isdtls = 1;
 661     (*retrl)->epoch = epoch;
 662     (*retrl)->in_init = 1;
 663
 664     switch (vers) {
 665     case DTLS_ANY_VERSION:
 666         (*retrl)->funcs = &dtls_any_funcs;
 667         break;
 668     case DTLS1_2_VERSION:
 669     case DTLS1_VERSION:
 670     case DTLS1_BAD_VER:
 671         (*retrl)->funcs = &dtls_1_funcs;
 672         break;
 673     default:
 674         /* Should not happen */
 675         ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR);
 676         ret = OSSL_RECORD_RETURN_FATAL;
 677         goto err;
 678     }
 679
 680     ret = (*retrl)->funcs->set_crypto_state(*retrl, level, key, keylen, iv,
 681                                             ivlen, mackey, mackeylen, ciph,
 682                                             taglen, mactype, md, comp);
 683
 684  err:
 685     if (ret != OSSL_RECORD_RETURN_SUCCESS) {
 686         OPENSSL_free(*retrl);
 687         *retrl = NULL;
 688     }
 689     return ret;
 690 }
 691
 692 /*
 693  * TODO(RECLAYER): Temporary copy of the old ssl3_write_pending() function now
 694  * replaced by tls_retry_write_records(). Needs to be removed when the DTLS code
 695  * is converted
 696  */
 697 /* if SSL3_BUFFER_get_left() != 0, we need to call this
 698  *
 699  * Return values are as per SSL_write()
 700  */
 701 static int ssl3_write_pending(OSSL_RECORD_LAYER *rl, int type,
 702                               const unsigned char *buf, size_t len,
 703                               size_t *written)
 704 {
 705     int i;
 706     /* TODO(RECLAYER): Remove me */
 707     SSL_CONNECTION *s = (SSL_CONNECTION *)rl->cbarg;
 708     SSL3_BUFFER *wb = rl->wbuf;
 709     size_t currbuf = 0;
 710     size_t tmpwrit = 0;
 711
 712     if ((s->rlayer.wpend_tot > len)
 713         || (!(s->mode & SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER)
 714             && (s->rlayer.wpend_buf != buf))
 715         || (s->rlayer.wpend_type != type)) {
 716         RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, SSL_R_BAD_WRITE_RETRY);
 717         return OSSL_RECORD_RETURN_FATAL;
 718     }
 719
 720     for (;;) {
 721         clear_sys_error();
 722         if (s->wbio != NULL) {
 723             s->rwstate = SSL_WRITING;
 724
 725             i = BIO_write(s->wbio, (char *)
 726                           &(SSL3_BUFFER_get_buf(&wb[currbuf])
 727                             [SSL3_BUFFER_get_offset(&wb[currbuf])]),
 728                           (unsigned int)SSL3_BUFFER_get_left(&wb[currbuf]));
 729             if (i >= 0)
 730                 tmpwrit = i;
 731         } else {
 732             RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, SSL_R_BIO_NOT_SET);
 733             i = -1;
 734         }
 735
 736         /*
 737          * When an empty fragment is sent on a connection using KTLS,
 738          * it is sent as a write of zero bytes.  If this zero byte
 739          * write succeeds, i will be 0 rather than a non-zero value.
 740          * Treat i == 0 as success rather than an error for zero byte
 741          * writes to permit this case.
 742          */
 743         if (i >= 0 && tmpwrit == SSL3_BUFFER_get_left(&wb[currbuf])) {
 744             SSL3_BUFFER_set_left(&wb[currbuf], 0);
 745             SSL3_BUFFER_add_offset(&wb[currbuf], tmpwrit);
 746             s->rwstate = SSL_NOTHING;
 747             *written = s->rlayer.wpend_ret;
 748             return OSSL_RECORD_RETURN_SUCCESS;
 749         } else if (i <= 0) {
 750             if (SSL_CONNECTION_IS_DTLS(s)) {
 751                 /*
 752                  * For DTLS, just drop it. That's kind of the whole point in
 753                  * using a datagram service
 754                  */
 755                 SSL3_BUFFER_set_left(&wb[currbuf], 0);
 756             }
 757
 758             if (BIO_should_retry(s->wbio))
 759                 return OSSL_RECORD_RETURN_RETRY;
 760
 761             return OSSL_RECORD_RETURN_FATAL;
 762         }
 763         SSL3_BUFFER_add_offset(&wb[currbuf], tmpwrit);
 764         SSL3_BUFFER_sub_left(&wb[currbuf], tmpwrit);
 765     }
 766 }
 767
 768 static int dtls_write_records(OSSL_RECORD_LAYER *rl,
 769                               OSSL_RECORD_TEMPLATE *templates,
 770                               size_t numtempl)
 771 {
 772     /* TODO(RECLAYER): Remove me */
 773     SSL_CONNECTION *sc = (SSL_CONNECTION *)rl->cbarg;
 774     unsigned char *p, *pseq;
 775     int mac_size, clear = 0;
 776     size_t written;
 777     int eivlen;
 778     SSL3_RECORD wr;
 779     SSL3_BUFFER *wb;
 780     SSL_SESSION *sess;
 781     SSL *s = SSL_CONNECTION_GET_SSL(sc);
 782
 783     sess = sc->session;
 784
 785     if ((sess == NULL)
 786             || (sc->enc_write_ctx == NULL)
 787             || (EVP_MD_CTX_get0_md(sc->write_hash) == NULL))
 788         clear = 1;
 789
 790     if (clear)
 791         mac_size = 0;
 792     else {
 793         mac_size = EVP_MD_CTX_get_size(sc->write_hash);
 794         if (mac_size < 0) {
 795             RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR,
 796                         SSL_R_EXCEEDS_MAX_FRAGMENT_SIZE);
 797             return OSSL_RECORD_RETURN_FATAL;
 798         }
 799     }
 800
 801     if (numtempl != 1) {
 802         /* Should not happen */
 803         RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
 804         return OSSL_RECORD_RETURN_FATAL;
 805     }
 806
 807     if (!rl->funcs->allocate_write_buffers(rl, templates, numtempl, NULL)) {
 808         /* RLAYERfatal() already called */
 809         return OSSL_RECORD_RETURN_FATAL;
 810     }
 811
 812     wb = rl->wbuf;
 813     p = SSL3_BUFFER_get_buf(wb);
 814
 815     /* write the header */
 816
 817     *(p++) = templates->type & 0xff;
 818     SSL3_RECORD_set_type(&wr, templates->type);
 819     *(p++) = templates->version >> 8;
 820     *(p++) = templates->version & 0xff;
 821
 822     /* field where we are to write out packet epoch, seq num and len */
 823     pseq = p;
 824     p += 10;
 825
 826     /* Explicit IV length, block ciphers appropriate version flag */
 827     if (sc->enc_write_ctx) {
 828         int mode = EVP_CIPHER_CTX_get_mode(sc->enc_write_ctx);
 829         if (mode == EVP_CIPH_CBC_MODE) {
 830             eivlen = EVP_CIPHER_CTX_get_iv_length(sc->enc_write_ctx);
 831             if (eivlen < 0) {
 832                 RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, SSL_R_LIBRARY_BUG);
 833                 return OSSL_RECORD_RETURN_FATAL;
 834             }
 835             if (eivlen <= 1)
 836                 eivlen = 0;
 837         }
 838         /* Need explicit part of IV for GCM mode */
 839         else if (mode == EVP_CIPH_GCM_MODE)
 840             eivlen = EVP_GCM_TLS_EXPLICIT_IV_LEN;
 841         else if (mode == EVP_CIPH_CCM_MODE)
 842             eivlen = EVP_CCM_TLS_EXPLICIT_IV_LEN;
 843         else
 844             eivlen = 0;
 845     } else
 846         eivlen = 0;
 847
 848     /* lets setup the record stuff. */
 849     SSL3_RECORD_set_data(&wr, p + eivlen); /* make room for IV in case of CBC */
 850     SSL3_RECORD_set_length(&wr, templates->buflen);
 851     SSL3_RECORD_set_input(&wr, (unsigned char *)templates->buf);
 852
 853     /*
 854      * we now 'read' from wr.input, wr.length bytes into wr.data
 855      */
 856
 857     /* first we compress */
 858     if (sc->compress != NULL) {
 859         if (!ssl3_do_compress(sc, &wr)) {
 860             RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, SSL_R_COMPRESSION_FAILURE);
 861             return OSSL_RECORD_RETURN_FATAL;
 862         }
 863     } else {
 864         memcpy(SSL3_RECORD_get_data(&wr), SSL3_RECORD_get_input(&wr),
 865                SSL3_RECORD_get_length(&wr));
 866         SSL3_RECORD_reset_input(&wr);
 867     }
 868
 869     /*
 870      * we should still have the output to wr.data and the input from
 871      * wr.input.  Length should be wr.length. wr.data still points in the
 872      * wb->buf
 873      */
 874
 875     if (!SSL_WRITE_ETM(sc) && mac_size != 0) {
 876         if (!s->method->ssl3_enc->mac(sc, &wr,
 877                                       &(p[SSL3_RECORD_get_length(&wr) + eivlen]),
 878                                       1)) {
 879             RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
 880             return OSSL_RECORD_RETURN_FATAL;
 881         }
 882         SSL3_RECORD_add_length(&wr, mac_size);
 883     }
 884
 885     /* this is true regardless of mac size */
 886     SSL3_RECORD_set_data(&wr, p);
 887     SSL3_RECORD_reset_input(&wr);
 888
 889     if (eivlen)
 890         SSL3_RECORD_add_length(&wr, eivlen);
 891
 892     if (s->method->ssl3_enc->enc(sc, &wr, 1, 1, NULL, mac_size) < 1) {
 893         if (!ossl_statem_in_error(sc)) {
 894             RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
 895         }
 896         return OSSL_RECORD_RETURN_FATAL;
 897     }
 898
 899     if (SSL_WRITE_ETM(sc) && mac_size != 0) {
 900         if (!s->method->ssl3_enc->mac(sc, &wr,
 901                                       &(p[SSL3_RECORD_get_length(&wr)]), 1)) {
 902             RLAYERfatal(rl, SSL_AD_INTERNAL_ERROR, ERR_R_INTERNAL_ERROR);
 903             return OSSL_RECORD_RETURN_FATAL;
 904         }
 905         SSL3_RECORD_add_length(&wr, mac_size);
 906     }
 907
 908     /* record length after mac and block padding */
 909
 910     /* there's only one epoch between handshake and app data */
 911
 912     s2n(sc->rlayer.d->w_epoch, pseq);
 913
 914     memcpy(pseq, &(sc->rlayer.write_sequence[2]), 6);
 915     pseq += 6;
 916     s2n(SSL3_RECORD_get_length(&wr), pseq);
 917
 918     if (sc->msg_callback)
 919         sc->msg_callback(1, 0, SSL3_RT_HEADER, pseq - DTLS1_RT_HEADER_LENGTH,
 920                          DTLS1_RT_HEADER_LENGTH, s, sc->msg_callback_arg);
 921
 922     /*
 923      * we should now have wr.data pointing to the encrypted data, which is
 924      * wr->length long
 925      */
 926     SSL3_RECORD_set_type(&wr, templates->type); /* not needed but helps for debugging */
 927     SSL3_RECORD_add_length(&wr, DTLS1_RT_HEADER_LENGTH);
 928
 929     ssl3_record_sequence_update(&(sc->rlayer.write_sequence[0]));
 930
 931     /* now let's set up wb */
 932     SSL3_BUFFER_set_left(wb, SSL3_RECORD_get_length(&wr));
 933     SSL3_BUFFER_set_offset(wb, 0);
 934
 935     /*
 936      * memorize arguments so that ssl3_write_pending can detect bad write
 937      * retries later
 938      */
 939     sc->rlayer.wpend_tot = templates->buflen;
 940     sc->rlayer.wpend_buf = templates->buf;
 941     sc->rlayer.wpend_type = templates->type;
 942     sc->rlayer.wpend_ret = templates->buflen;
 943
 944     /* we now just need to write the buffer. Calls SSLfatal() as required. */
 945     return ssl3_write_pending(rl, templates->type, templates->buf,
 946                               templates->buflen, &written);
 947 }
 948
 949 const OSSL_RECORD_METHOD ossl_dtls_record_method = {
 950     dtls_new_record_layer,
 951     dtls_free,
 952     tls_reset,
 953     tls_unprocessed_read_pending,
 954     tls_processed_read_pending,
 955     tls_app_data_pending,
 956     tls_write_pending,
 957     tls_get_max_record_len,
 958     tls_get_max_records,
 959     dtls_write_records,
 960     tls_retry_write_records,
 961     tls_read_record,
 962     tls_release_record,
 963     tls_get_alert_code,
 964     tls_set1_bio,
 965     tls_set_protocol_version,
 966     NULL,
 967     tls_set_first_handshake,
 968     tls_set_max_pipelines,
 969     dtls_set_in_init,
 970     tls_get_state,
 971     tls_set_options,
 972     tls_get_compression,
 973     tls_set_max_frag_len
 974 };