test/helpers/ssltestlib.c

   1 /*
   2  * Copyright 2016-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 <string.h>
  11
  12 #include "internal/nelem.h"
  13 #include "ssltestlib.h"
  14 #include "../testutil.h"
  15 #include "internal/e_os.h" /* for ossl_sleep() etc. */
  16
  17 #ifdef OPENSSL_SYS_UNIX
  18 # include <unistd.h>
  19 # ifndef OPENSSL_NO_KTLS
  20 #  include <netinet/in.h>
  21 #  include <netinet/in.h>
  22 #  include <arpa/inet.h>
  23 #  include <sys/socket.h>
  24 #  include <unistd.h>
  25 #  include <fcntl.h>
  26 # endif
  27 #endif
  28
  29 static int tls_dump_new(BIO *bi);
  30 static int tls_dump_free(BIO *a);
  31 static int tls_dump_read(BIO *b, char *out, int outl);
  32 static int tls_dump_write(BIO *b, const char *in, int inl);
  33 static long tls_dump_ctrl(BIO *b, int cmd, long num, void *ptr);
  34 static int tls_dump_gets(BIO *bp, char *buf, int size);
  35 static int tls_dump_puts(BIO *bp, const char *str);
  36
  37 /* Choose a sufficiently large type likely to be unused for this custom BIO */
  38 #define BIO_TYPE_TLS_DUMP_FILTER  (0x80 | BIO_TYPE_FILTER)
  39 #define BIO_TYPE_MEMPACKET_TEST    0x81
  40 #define BIO_TYPE_ALWAYS_RETRY      0x82
  41
  42 static BIO_METHOD *method_tls_dump = NULL;
  43 static BIO_METHOD *meth_mem = NULL;
  44 static BIO_METHOD *meth_always_retry = NULL;
  45
  46 /* Note: Not thread safe! */
  47 const BIO_METHOD *bio_f_tls_dump_filter(void)
  48 {
  49     if (method_tls_dump == NULL) {
  50         method_tls_dump = BIO_meth_new(BIO_TYPE_TLS_DUMP_FILTER,
  51                                         "TLS dump filter");
  52         if (method_tls_dump == NULL
  53             || !BIO_meth_set_write(method_tls_dump, tls_dump_write)
  54             || !BIO_meth_set_read(method_tls_dump, tls_dump_read)
  55             || !BIO_meth_set_puts(method_tls_dump, tls_dump_puts)
  56             || !BIO_meth_set_gets(method_tls_dump, tls_dump_gets)
  57             || !BIO_meth_set_ctrl(method_tls_dump, tls_dump_ctrl)
  58             || !BIO_meth_set_create(method_tls_dump, tls_dump_new)
  59             || !BIO_meth_set_destroy(method_tls_dump, tls_dump_free))
  60             return NULL;
  61     }
  62     return method_tls_dump;
  63 }
  64
  65 void bio_f_tls_dump_filter_free(void)
  66 {
  67     BIO_meth_free(method_tls_dump);
  68 }
  69
  70 static int tls_dump_new(BIO *bio)
  71 {
  72     BIO_set_init(bio, 1);
  73     return 1;
  74 }
  75
  76 static int tls_dump_free(BIO *bio)
  77 {
  78     BIO_set_init(bio, 0);
  79
  80     return 1;
  81 }
  82
  83 static void copy_flags(BIO *bio)
  84 {
  85     int flags;
  86     BIO *next = BIO_next(bio);
  87
  88     flags = BIO_test_flags(next, BIO_FLAGS_SHOULD_RETRY | BIO_FLAGS_RWS);
  89     BIO_clear_flags(bio, BIO_FLAGS_SHOULD_RETRY | BIO_FLAGS_RWS);
  90     BIO_set_flags(bio, flags);
  91 }
  92
  93 #define RECORD_CONTENT_TYPE     0
  94 #define RECORD_VERSION_HI       1
  95 #define RECORD_VERSION_LO       2
  96 #define RECORD_EPOCH_HI         3
  97 #define RECORD_EPOCH_LO         4
  98 #define RECORD_SEQUENCE_START   5
  99 #define RECORD_SEQUENCE_END     10
 100 #define RECORD_LEN_HI           11
 101 #define RECORD_LEN_LO           12
 102
 103 #define MSG_TYPE                0
 104 #define MSG_LEN_HI              1
 105 #define MSG_LEN_MID             2
 106 #define MSG_LEN_LO              3
 107 #define MSG_SEQ_HI              4
 108 #define MSG_SEQ_LO              5
 109 #define MSG_FRAG_OFF_HI         6
 110 #define MSG_FRAG_OFF_MID        7
 111 #define MSG_FRAG_OFF_LO         8
 112 #define MSG_FRAG_LEN_HI         9
 113 #define MSG_FRAG_LEN_MID        10
 114 #define MSG_FRAG_LEN_LO         11
 115
 116
 117 static void dump_data(const char *data, int len)
 118 {
 119     int rem, i, content, reclen, msglen, fragoff, fraglen, epoch;
 120     unsigned char *rec;
 121
 122     printf("---- START OF PACKET ----\n");
 123
 124     rem = len;
 125     rec = (unsigned char *)data;
 126
 127     while (rem > 0) {
 128         if (rem != len)
 129             printf("*\n");
 130         printf("*---- START OF RECORD ----\n");
 131         if (rem < DTLS1_RT_HEADER_LENGTH) {
 132             printf("*---- RECORD TRUNCATED ----\n");
 133             break;
 134         }
 135         content = rec[RECORD_CONTENT_TYPE];
 136         printf("** Record Content-type: %d\n", content);
 137         printf("** Record Version: %02x%02x\n",
 138                rec[RECORD_VERSION_HI], rec[RECORD_VERSION_LO]);
 139         epoch = (rec[RECORD_EPOCH_HI] << 8) | rec[RECORD_EPOCH_LO];
 140         printf("** Record Epoch: %d\n", epoch);
 141         printf("** Record Sequence: ");
 142         for (i = RECORD_SEQUENCE_START; i <= RECORD_SEQUENCE_END; i++)
 143             printf("%02x", rec[i]);
 144         reclen = (rec[RECORD_LEN_HI] << 8) | rec[RECORD_LEN_LO];
 145         printf("\n** Record Length: %d\n", reclen);
 146
 147         /* Now look at message */
 148         rec += DTLS1_RT_HEADER_LENGTH;
 149         rem -= DTLS1_RT_HEADER_LENGTH;
 150         if (content == SSL3_RT_HANDSHAKE) {
 151             printf("**---- START OF HANDSHAKE MESSAGE FRAGMENT ----\n");
 152             if (epoch > 0) {
 153                 printf("**---- HANDSHAKE MESSAGE FRAGMENT ENCRYPTED ----\n");
 154             } else if (rem < DTLS1_HM_HEADER_LENGTH
 155                     || reclen < DTLS1_HM_HEADER_LENGTH) {
 156                 printf("**---- HANDSHAKE MESSAGE FRAGMENT TRUNCATED ----\n");
 157             } else {
 158                 printf("*** Message Type: %d\n", rec[MSG_TYPE]);
 159                 msglen = (rec[MSG_LEN_HI] << 16) | (rec[MSG_LEN_MID] << 8)
 160                          | rec[MSG_LEN_LO];
 161                 printf("*** Message Length: %d\n", msglen);
 162                 printf("*** Message sequence: %d\n",
 163                        (rec[MSG_SEQ_HI] << 8) | rec[MSG_SEQ_LO]);
 164                 fragoff = (rec[MSG_FRAG_OFF_HI] << 16)
 165                           | (rec[MSG_FRAG_OFF_MID] << 8)
 166                           | rec[MSG_FRAG_OFF_LO];
 167                 printf("*** Message Fragment offset: %d\n", fragoff);
 168                 fraglen = (rec[MSG_FRAG_LEN_HI] << 16)
 169                           | (rec[MSG_FRAG_LEN_MID] << 8)
 170                           | rec[MSG_FRAG_LEN_LO];
 171                 printf("*** Message Fragment len: %d\n", fraglen);
 172                 if (fragoff + fraglen > msglen)
 173                     printf("***---- HANDSHAKE MESSAGE FRAGMENT INVALID ----\n");
 174                 else if (reclen < fraglen)
 175                     printf("**---- HANDSHAKE MESSAGE FRAGMENT TRUNCATED ----\n");
 176                 else
 177                     printf("**---- END OF HANDSHAKE MESSAGE FRAGMENT ----\n");
 178             }
 179         }
 180         if (rem < reclen) {
 181             printf("*---- RECORD TRUNCATED ----\n");
 182             rem = 0;
 183         } else {
 184             rec += reclen;
 185             rem -= reclen;
 186             printf("*---- END OF RECORD ----\n");
 187         }
 188     }
 189     printf("---- END OF PACKET ----\n\n");
 190     fflush(stdout);
 191 }
 192
 193 static int tls_dump_read(BIO *bio, char *out, int outl)
 194 {
 195     int ret;
 196     BIO *next = BIO_next(bio);
 197
 198     ret = BIO_read(next, out, outl);
 199     copy_flags(bio);
 200
 201     if (ret > 0) {
 202         dump_data(out, ret);
 203     }
 204
 205     return ret;
 206 }
 207
 208 static int tls_dump_write(BIO *bio, const char *in, int inl)
 209 {
 210     int ret;
 211     BIO *next = BIO_next(bio);
 212
 213     ret = BIO_write(next, in, inl);
 214     copy_flags(bio);
 215
 216     return ret;
 217 }
 218
 219 static long tls_dump_ctrl(BIO *bio, int cmd, long num, void *ptr)
 220 {
 221     long ret;
 222     BIO *next = BIO_next(bio);
 223
 224     if (next == NULL)
 225         return 0;
 226
 227     switch (cmd) {
 228     case BIO_CTRL_DUP:
 229         ret = 0L;
 230         break;
 231     default:
 232         ret = BIO_ctrl(next, cmd, num, ptr);
 233         break;
 234     }
 235     return ret;
 236 }
 237
 238 static int tls_dump_gets(BIO *bio, char *buf, int size)
 239 {
 240     /* We don't support this - not needed anyway */
 241     return -1;
 242 }
 243
 244 static int tls_dump_puts(BIO *bio, const char *str)
 245 {
 246     return tls_dump_write(bio, str, strlen(str));
 247 }
 248
 249
 250 struct mempacket_st {
 251     unsigned char *data;
 252     int len;
 253     unsigned int num;
 254     unsigned int type;
 255 };
 256
 257 static void mempacket_free(MEMPACKET *pkt)
 258 {
 259     if (pkt->data != NULL)
 260         OPENSSL_free(pkt->data);
 261     OPENSSL_free(pkt);
 262 }
 263
 264 typedef struct mempacket_test_ctx_st {
 265     STACK_OF(MEMPACKET) *pkts;
 266     unsigned int epoch;
 267     unsigned int currrec;
 268     unsigned int currpkt;
 269     unsigned int lastpkt;
 270     unsigned int injected;
 271     unsigned int noinject;
 272     unsigned int dropepoch;
 273     int droprec;
 274     int duprec;
 275 } MEMPACKET_TEST_CTX;
 276
 277 static int mempacket_test_new(BIO *bi);
 278 static int mempacket_test_free(BIO *a);
 279 static int mempacket_test_read(BIO *b, char *out, int outl);
 280 static int mempacket_test_write(BIO *b, const char *in, int inl);
 281 static long mempacket_test_ctrl(BIO *b, int cmd, long num, void *ptr);
 282 static int mempacket_test_gets(BIO *bp, char *buf, int size);
 283 static int mempacket_test_puts(BIO *bp, const char *str);
 284
 285 const BIO_METHOD *bio_s_mempacket_test(void)
 286 {
 287     if (meth_mem == NULL) {
 288         if (!TEST_ptr(meth_mem = BIO_meth_new(BIO_TYPE_MEMPACKET_TEST,
 289                                               "Mem Packet Test"))
 290             || !TEST_true(BIO_meth_set_write(meth_mem, mempacket_test_write))
 291             || !TEST_true(BIO_meth_set_read(meth_mem, mempacket_test_read))
 292             || !TEST_true(BIO_meth_set_puts(meth_mem, mempacket_test_puts))
 293             || !TEST_true(BIO_meth_set_gets(meth_mem, mempacket_test_gets))
 294             || !TEST_true(BIO_meth_set_ctrl(meth_mem, mempacket_test_ctrl))
 295             || !TEST_true(BIO_meth_set_create(meth_mem, mempacket_test_new))
 296             || !TEST_true(BIO_meth_set_destroy(meth_mem, mempacket_test_free)))
 297             return NULL;
 298     }
 299     return meth_mem;
 300 }
 301
 302 void bio_s_mempacket_test_free(void)
 303 {
 304     BIO_meth_free(meth_mem);
 305 }
 306
 307 static int mempacket_test_new(BIO *bio)
 308 {
 309     MEMPACKET_TEST_CTX *ctx;
 310
 311     if (!TEST_ptr(ctx = OPENSSL_zalloc(sizeof(*ctx))))
 312         return 0;
 313     if (!TEST_ptr(ctx->pkts = sk_MEMPACKET_new_null())) {
 314         OPENSSL_free(ctx);
 315         return 0;
 316     }
 317     ctx->dropepoch = 0;
 318     ctx->droprec = -1;
 319     BIO_set_init(bio, 1);
 320     BIO_set_data(bio, ctx);
 321     return 1;
 322 }
 323
 324 static int mempacket_test_free(BIO *bio)
 325 {
 326     MEMPACKET_TEST_CTX *ctx = BIO_get_data(bio);
 327
 328     sk_MEMPACKET_pop_free(ctx->pkts, mempacket_free);
 329     OPENSSL_free(ctx);
 330     BIO_set_data(bio, NULL);
 331     BIO_set_init(bio, 0);
 332     return 1;
 333 }
 334
 335 /* Record Header values */
 336 #define EPOCH_HI        3
 337 #define EPOCH_LO        4
 338 #define RECORD_SEQUENCE 10
 339 #define RECORD_LEN_HI   11
 340 #define RECORD_LEN_LO   12
 341
 342 #define STANDARD_PACKET                 0
 343
 344 static int mempacket_test_read(BIO *bio, char *out, int outl)
 345 {
 346     MEMPACKET_TEST_CTX *ctx = BIO_get_data(bio);
 347     MEMPACKET *thispkt;
 348     unsigned char *rec;
 349     int rem;
 350     unsigned int seq, offset, len, epoch;
 351
 352     BIO_clear_retry_flags(bio);
 353     thispkt = sk_MEMPACKET_value(ctx->pkts, 0);
 354     if (thispkt == NULL || thispkt->num != ctx->currpkt) {
 355         /* Probably run out of data */
 356         BIO_set_retry_read(bio);
 357         return -1;
 358     }
 359     (void)sk_MEMPACKET_shift(ctx->pkts);
 360     ctx->currpkt++;
 361
 362     if (outl > thispkt->len)
 363         outl = thispkt->len;
 364
 365     if (thispkt->type != INJECT_PACKET_IGNORE_REC_SEQ
 366             && (ctx->injected || ctx->droprec >= 0)) {
 367         /*
 368          * Overwrite the record sequence number. We strictly number them in
 369          * the order received. Since we are actually a reliable transport
 370          * we know that there won't be any re-ordering. We overwrite to deal
 371          * with any packets that have been injected
 372          */
 373         for (rem = thispkt->len, rec = thispkt->data; rem > 0; rem -= len) {
 374             if (rem < DTLS1_RT_HEADER_LENGTH)
 375                 return -1;
 376             epoch = (rec[EPOCH_HI] << 8) | rec[EPOCH_LO];
 377             if (epoch != ctx->epoch) {
 378                 ctx->epoch = epoch;
 379                 ctx->currrec = 0;
 380             }
 381             seq = ctx->currrec;
 382             offset = 0;
 383             do {
 384                 rec[RECORD_SEQUENCE - offset] = seq & 0xFF;
 385                 seq >>= 8;
 386                 offset++;
 387             } while (seq > 0);
 388
 389             len = ((rec[RECORD_LEN_HI] << 8) | rec[RECORD_LEN_LO])
 390                   + DTLS1_RT_HEADER_LENGTH;
 391             if (rem < (int)len)
 392                 return -1;
 393             if (ctx->droprec == (int)ctx->currrec && ctx->dropepoch == epoch) {
 394                 if (rem > (int)len)
 395                     memmove(rec, rec + len, rem - len);
 396                 outl -= len;
 397                 ctx->droprec = -1;
 398                 if (outl == 0)
 399                     BIO_set_retry_read(bio);
 400             } else {
 401                 rec += len;
 402             }
 403
 404             ctx->currrec++;
 405         }
 406     }
 407
 408     memcpy(out, thispkt->data, outl);
 409
 410     mempacket_free(thispkt);
 411     return outl;
 412 }
 413
 414 /*
 415  * Look for records from different epochs and swap them around
 416  */
 417 int mempacket_swap_epoch(BIO *bio)
 418 {
 419     MEMPACKET_TEST_CTX *ctx = BIO_get_data(bio);
 420     MEMPACKET *thispkt;
 421     int rem, len, prevlen = 0, pktnum;
 422     unsigned char *rec, *prevrec = NULL, *tmp;
 423     unsigned int epoch;
 424     int numpkts = sk_MEMPACKET_num(ctx->pkts);
 425
 426     if (numpkts <= 0)
 427         return 0;
 428
 429     /*
 430      * If there are multiple packets we only look in the last one. This should
 431      * always be the one where any epoch change occurs.
 432      */
 433     thispkt = sk_MEMPACKET_value(ctx->pkts, numpkts - 1);
 434     if (thispkt == NULL)
 435         return 0;
 436
 437     for (rem = thispkt->len, rec = thispkt->data; rem > 0; rem -= len, rec += len) {
 438         if (rem < DTLS1_RT_HEADER_LENGTH)
 439             return 0;
 440         epoch = (rec[EPOCH_HI] << 8) | rec[EPOCH_LO];
 441         len = ((rec[RECORD_LEN_HI] << 8) | rec[RECORD_LEN_LO])
 442                 + DTLS1_RT_HEADER_LENGTH;
 443         if (rem < len)
 444             return 0;
 445
 446         /* Assumes the epoch change does not happen on the first record */
 447         if (epoch != ctx->epoch) {
 448             if (prevrec == NULL)
 449                 return 0;
 450
 451             /*
 452              * We found 2 records with different epochs. Take a copy of the
 453              * earlier record
 454              */
 455             tmp = OPENSSL_malloc(prevlen);
 456             if (tmp == NULL)
 457                 return 0;
 458
 459             memcpy(tmp, prevrec, prevlen);
 460             /*
 461              * Move everything from this record onwards, including any trailing
 462              * records, and overwrite the earlier record
 463              */
 464             memmove(prevrec, rec, rem);
 465             thispkt->len -= prevlen;
 466             pktnum = thispkt->num;
 467
 468             /*
 469              * Create a new packet for the earlier record that we took out and
 470              * add it to the end of the packet list.
 471              */
 472             thispkt = OPENSSL_malloc(sizeof(*thispkt));
 473             if (thispkt == NULL) {
 474                 OPENSSL_free(tmp);
 475                 return 0;
 476             }
 477             thispkt->type = INJECT_PACKET;
 478             thispkt->data = tmp;
 479             thispkt->len = prevlen;
 480             thispkt->num = pktnum + 1;
 481             if (sk_MEMPACKET_insert(ctx->pkts, thispkt, numpkts) <= 0) {
 482                 OPENSSL_free(tmp);
 483                 OPENSSL_free(thispkt);
 484                 return 0;
 485             }
 486
 487             return 1;
 488         }
 489         prevrec = rec;
 490         prevlen = len;
 491     }
 492
 493     return 0;
 494 }
 495
 496 int mempacket_test_inject(BIO *bio, const char *in, int inl, int pktnum,
 497                           int type)
 498 {
 499     MEMPACKET_TEST_CTX *ctx = BIO_get_data(bio);
 500     MEMPACKET *thispkt = NULL, *looppkt, *nextpkt, *allpkts[3];
 501     int i, duprec;
 502     const unsigned char *inu = (const unsigned char *)in;
 503     size_t len = ((inu[RECORD_LEN_HI] << 8) | inu[RECORD_LEN_LO])
 504                  + DTLS1_RT_HEADER_LENGTH;
 505
 506     if (ctx == NULL)
 507         return -1;
 508
 509     if ((size_t)inl < len)
 510         return -1;
 511
 512     if ((size_t)inl == len)
 513         duprec = 0;
 514     else
 515         duprec = ctx->duprec > 0;
 516
 517     /* We don't support arbitrary injection when duplicating records */
 518     if (duprec && pktnum != -1)
 519         return -1;
 520
 521     /* We only allow injection before we've started writing any data */
 522     if (pktnum >= 0) {
 523         if (ctx->noinject)
 524             return -1;
 525         ctx->injected  = 1;
 526     } else {
 527         ctx->noinject = 1;
 528     }
 529
 530     for (i = 0; i < (duprec ? 3 : 1); i++) {
 531         if (!TEST_ptr(allpkts[i] = OPENSSL_malloc(sizeof(*thispkt))))
 532             goto err;
 533         thispkt = allpkts[i];
 534
 535         if (!TEST_ptr(thispkt->data = OPENSSL_malloc(inl)))
 536             goto err;
 537         /*
 538          * If we are duplicating the packet, we duplicate it three times. The
 539          * first two times we drop the first record if there are more than one.
 540          * In this way we know that libssl will not be able to make progress
 541          * until it receives the last packet, and hence will be forced to
 542          * buffer these records.
 543          */
 544         if (duprec && i != 2) {
 545             memcpy(thispkt->data, in + len, inl - len);
 546             thispkt->len = inl - len;
 547         } else {
 548             memcpy(thispkt->data, in, inl);
 549             thispkt->len = inl;
 550         }
 551         thispkt->num = (pktnum >= 0) ? (unsigned int)pktnum : ctx->lastpkt + i;
 552         thispkt->type = type;
 553     }
 554
 555     for (i = 0; (looppkt = sk_MEMPACKET_value(ctx->pkts, i)) != NULL; i++) {
 556         /* Check if we found the right place to insert this packet */
 557         if (looppkt->num > thispkt->num) {
 558             if (sk_MEMPACKET_insert(ctx->pkts, thispkt, i) == 0)
 559                 goto err;
 560             /* If we're doing up front injection then we're done */
 561             if (pktnum >= 0)
 562                 return inl;
 563             /*
 564              * We need to do some accounting on lastpkt. We increment it first,
 565              * but it might now equal the value of injected packets, so we need
 566              * to skip over those
 567              */
 568             ctx->lastpkt++;
 569             do {
 570                 i++;
 571                 nextpkt = sk_MEMPACKET_value(ctx->pkts, i);
 572                 if (nextpkt != NULL && nextpkt->num == ctx->lastpkt)
 573                     ctx->lastpkt++;
 574                 else
 575                     return inl;
 576             } while(1);
 577         } else if (looppkt->num == thispkt->num) {
 578             if (!ctx->noinject) {
 579                 /* We injected two packets with the same packet number! */
 580                 goto err;
 581             }
 582             ctx->lastpkt++;
 583             thispkt->num++;
 584         }
 585     }
 586     /*
 587      * We didn't find any packets with a packet number equal to or greater than
 588      * this one, so we just add it onto the end
 589      */
 590     for (i = 0; i < (duprec ? 3 : 1); i++) {
 591         thispkt = allpkts[i];
 592         if (!sk_MEMPACKET_push(ctx->pkts, thispkt))
 593             goto err;
 594
 595         if (pktnum < 0)
 596             ctx->lastpkt++;
 597     }
 598
 599     return inl;
 600
 601  err:
 602     for (i = 0; i < (ctx->duprec > 0 ? 3 : 1); i++)
 603         mempacket_free(allpkts[i]);
 604     return -1;
 605 }
 606
 607 static int mempacket_test_write(BIO *bio, const char *in, int inl)
 608 {
 609     return mempacket_test_inject(bio, in, inl, -1, STANDARD_PACKET);
 610 }
 611
 612 static long mempacket_test_ctrl(BIO *bio, int cmd, long num, void *ptr)
 613 {
 614     long ret = 1;
 615     MEMPACKET_TEST_CTX *ctx = BIO_get_data(bio);
 616     MEMPACKET *thispkt;
 617
 618     switch (cmd) {
 619     case BIO_CTRL_EOF:
 620         ret = (long)(sk_MEMPACKET_num(ctx->pkts) == 0);
 621         break;
 622     case BIO_CTRL_GET_CLOSE:
 623         ret = BIO_get_shutdown(bio);
 624         break;
 625     case BIO_CTRL_SET_CLOSE:
 626         BIO_set_shutdown(bio, (int)num);
 627         break;
 628     case BIO_CTRL_WPENDING:
 629         ret = 0L;
 630         break;
 631     case BIO_CTRL_PENDING:
 632         thispkt = sk_MEMPACKET_value(ctx->pkts, 0);
 633         if (thispkt == NULL)
 634             ret = 0;
 635         else
 636             ret = thispkt->len;
 637         break;
 638     case BIO_CTRL_FLUSH:
 639         ret = 1;
 640         break;
 641     case MEMPACKET_CTRL_SET_DROP_EPOCH:
 642         ctx->dropepoch = (unsigned int)num;
 643         break;
 644     case MEMPACKET_CTRL_SET_DROP_REC:
 645         ctx->droprec = (int)num;
 646         break;
 647     case MEMPACKET_CTRL_GET_DROP_REC:
 648         ret = ctx->droprec;
 649         break;
 650     case MEMPACKET_CTRL_SET_DUPLICATE_REC:
 651         ctx->duprec = (int)num;
 652         break;
 653     case BIO_CTRL_RESET:
 654     case BIO_CTRL_DUP:
 655     case BIO_CTRL_PUSH:
 656     case BIO_CTRL_POP:
 657     default:
 658         ret = 0;
 659         break;
 660     }
 661     return ret;
 662 }
 663
 664 static int mempacket_test_gets(BIO *bio, char *buf, int size)
 665 {
 666     /* We don't support this - not needed anyway */
 667     return -1;
 668 }
 669
 670 static int mempacket_test_puts(BIO *bio, const char *str)
 671 {
 672     return mempacket_test_write(bio, str, strlen(str));
 673 }
 674
 675 static int always_retry_new(BIO *bi);
 676 static int always_retry_free(BIO *a);
 677 static int always_retry_read(BIO *b, char *out, int outl);
 678 static int always_retry_write(BIO *b, const char *in, int inl);
 679 static long always_retry_ctrl(BIO *b, int cmd, long num, void *ptr);
 680 static int always_retry_gets(BIO *bp, char *buf, int size);
 681 static int always_retry_puts(BIO *bp, const char *str);
 682
 683 const BIO_METHOD *bio_s_always_retry(void)
 684 {
 685     if (meth_always_retry == NULL) {
 686         if (!TEST_ptr(meth_always_retry = BIO_meth_new(BIO_TYPE_ALWAYS_RETRY,
 687                                                        "Always Retry"))
 688             || !TEST_true(BIO_meth_set_write(meth_always_retry,
 689                                              always_retry_write))
 690             || !TEST_true(BIO_meth_set_read(meth_always_retry,
 691                                             always_retry_read))
 692             || !TEST_true(BIO_meth_set_puts(meth_always_retry,
 693                                             always_retry_puts))
 694             || !TEST_true(BIO_meth_set_gets(meth_always_retry,
 695                                             always_retry_gets))
 696             || !TEST_true(BIO_meth_set_ctrl(meth_always_retry,
 697                                             always_retry_ctrl))
 698             || !TEST_true(BIO_meth_set_create(meth_always_retry,
 699                                               always_retry_new))
 700             || !TEST_true(BIO_meth_set_destroy(meth_always_retry,
 701                                                always_retry_free)))
 702             return NULL;
 703     }
 704     return meth_always_retry;
 705 }
 706
 707 void bio_s_always_retry_free(void)
 708 {
 709     BIO_meth_free(meth_always_retry);
 710 }
 711
 712 static int always_retry_new(BIO *bio)
 713 {
 714     BIO_set_init(bio, 1);
 715     return 1;
 716 }
 717
 718 static int always_retry_free(BIO *bio)
 719 {
 720     BIO_set_data(bio, NULL);
 721     BIO_set_init(bio, 0);
 722     return 1;
 723 }
 724
 725 static int always_retry_read(BIO *bio, char *out, int outl)
 726 {
 727     BIO_set_retry_read(bio);
 728     return -1;
 729 }
 730
 731 static int always_retry_write(BIO *bio, const char *in, int inl)
 732 {
 733     BIO_set_retry_write(bio);
 734     return -1;
 735 }
 736
 737 static long always_retry_ctrl(BIO *bio, int cmd, long num, void *ptr)
 738 {
 739     long ret = 1;
 740
 741     switch (cmd) {
 742     case BIO_CTRL_FLUSH:
 743         BIO_set_retry_write(bio);
 744         /* fall through */
 745     case BIO_CTRL_EOF:
 746     case BIO_CTRL_RESET:
 747     case BIO_CTRL_DUP:
 748     case BIO_CTRL_PUSH:
 749     case BIO_CTRL_POP:
 750     default:
 751         ret = 0;
 752         break;
 753     }
 754     return ret;
 755 }
 756
 757 static int always_retry_gets(BIO *bio, char *buf, int size)
 758 {
 759     BIO_set_retry_read(bio);
 760     return -1;
 761 }
 762
 763 static int always_retry_puts(BIO *bio, const char *str)
 764 {
 765     BIO_set_retry_write(bio);
 766     return -1;
 767 }
 768
 769 int create_ssl_ctx_pair(OSSL_LIB_CTX *libctx, const SSL_METHOD *sm,
 770                         const SSL_METHOD *cm, int min_proto_version,
 771                         int max_proto_version, SSL_CTX **sctx, SSL_CTX **cctx,
 772                         char *certfile, char *privkeyfile)
 773 {
 774     SSL_CTX *serverctx = NULL;
 775     SSL_CTX *clientctx = NULL;
 776
 777     if (sctx != NULL) {
 778         if (*sctx != NULL)
 779             serverctx = *sctx;
 780         else if (!TEST_ptr(serverctx = SSL_CTX_new_ex(libctx, NULL, sm))
 781             || !TEST_true(SSL_CTX_set_options(serverctx,
 782                                               SSL_OP_ALLOW_CLIENT_RENEGOTIATION)))
 783             goto err;
 784     }
 785
 786     if (cctx != NULL) {
 787         if (*cctx != NULL)
 788             clientctx = *cctx;
 789         else if (!TEST_ptr(clientctx = SSL_CTX_new_ex(libctx, NULL, cm)))
 790             goto err;
 791     }
 792
 793 #if !defined(OPENSSL_NO_TLS1_3) \
 794     && defined(OPENSSL_NO_EC) \
 795     && defined(OPENSSL_NO_DH)
 796     /*
 797      * There are no usable built-in TLSv1.3 groups if ec and dh are both
 798      * disabled
 799      */
 800     if (max_proto_version == 0
 801             && (sm == TLS_server_method() || cm == TLS_client_method()))
 802         max_proto_version = TLS1_2_VERSION;
 803 #endif
 804
 805     if (serverctx != NULL
 806             && ((min_proto_version > 0
 807                  && !TEST_true(SSL_CTX_set_min_proto_version(serverctx,
 808                                                             min_proto_version)))
 809                 || (max_proto_version > 0
 810                     && !TEST_true(SSL_CTX_set_max_proto_version(serverctx,
 811                                                                 max_proto_version)))))
 812         goto err;
 813     if (clientctx != NULL
 814         && ((min_proto_version > 0
 815              && !TEST_true(SSL_CTX_set_min_proto_version(clientctx,
 816                                                          min_proto_version)))
 817             || (max_proto_version > 0
 818                 && !TEST_true(SSL_CTX_set_max_proto_version(clientctx,
 819                                                             max_proto_version)))))
 820         goto err;
 821
 822     if (serverctx != NULL && certfile != NULL && privkeyfile != NULL) {
 823         if (!TEST_int_eq(SSL_CTX_use_certificate_file(serverctx, certfile,
 824                                                       SSL_FILETYPE_PEM), 1)
 825                 || !TEST_int_eq(SSL_CTX_use_PrivateKey_file(serverctx,
 826                                                             privkeyfile,
 827                                                             SSL_FILETYPE_PEM), 1)
 828                 || !TEST_int_eq(SSL_CTX_check_private_key(serverctx), 1))
 829             goto err;
 830     }
 831
 832     if (sctx != NULL)
 833         *sctx = serverctx;
 834     if (cctx != NULL)
 835         *cctx = clientctx;
 836     return 1;
 837
 838  err:
 839     if (sctx != NULL && *sctx == NULL)
 840         SSL_CTX_free(serverctx);
 841     if (cctx != NULL && *cctx == NULL)
 842         SSL_CTX_free(clientctx);
 843     return 0;
 844 }
 845
 846 #define MAXLOOPS    1000000
 847
 848 #if !defined(OPENSSL_NO_KTLS) && !defined(OPENSSL_NO_SOCK)
 849 static int set_nb(int fd)
 850 {
 851     int flags;
 852
 853     flags = fcntl(fd, F_GETFL, 0);
 854     if (flags == -1)
 855         return flags;
 856     flags = fcntl(fd, F_SETFL, flags | O_NONBLOCK);
 857     return flags;
 858 }
 859
 860 int create_test_sockets(int *cfdp, int *sfdp)
 861 {
 862     struct sockaddr_in sin;
 863     const char *host = "127.0.0.1";
 864     int cfd_connected = 0, ret = 0;
 865     socklen_t slen = sizeof(sin);
 866     int afd = -1, cfd = -1, sfd = -1;
 867
 868     memset ((char *) &sin, 0, sizeof(sin));
 869     sin.sin_family = AF_INET;
 870     sin.sin_addr.s_addr = inet_addr(host);
 871
 872     afd = socket(AF_INET, SOCK_STREAM, 0);
 873     if (afd < 0)
 874         return 0;
 875
 876     if (bind(afd, (struct sockaddr*)&sin, sizeof(sin)) < 0)
 877         goto out;
 878
 879     if (getsockname(afd, (struct sockaddr*)&sin, &slen) < 0)
 880         goto out;
 881
 882     if (listen(afd, 1) < 0)
 883         goto out;
 884
 885     cfd = socket(AF_INET, SOCK_STREAM, 0);
 886     if (cfd < 0)
 887         goto out;
 888
 889     if (set_nb(afd) == -1)
 890         goto out;
 891
 892     while (sfd == -1 || !cfd_connected) {
 893         sfd = accept(afd, NULL, 0);
 894         if (sfd == -1 && errno != EAGAIN)
 895             goto out;
 896
 897         if (!cfd_connected && connect(cfd, (struct sockaddr*)&sin, sizeof(sin)) < 0)
 898             goto out;
 899         else
 900             cfd_connected = 1;
 901     }
 902
 903     if (set_nb(cfd) == -1 || set_nb(sfd) == -1)
 904         goto out;
 905     ret = 1;
 906     *cfdp = cfd;
 907     *sfdp = sfd;
 908     goto success;
 909
 910 out:
 911     if (cfd != -1)
 912         close(cfd);
 913     if (sfd != -1)
 914         close(sfd);
 915 success:
 916     if (afd != -1)
 917         close(afd);
 918     return ret;
 919 }
 920
 921 int create_ssl_objects2(SSL_CTX *serverctx, SSL_CTX *clientctx, SSL **sssl,
 922                           SSL **cssl, int sfd, int cfd)
 923 {
 924     SSL *serverssl = NULL, *clientssl = NULL;
 925     BIO *s_to_c_bio = NULL, *c_to_s_bio = NULL;
 926
 927     if (*sssl != NULL)
 928         serverssl = *sssl;
 929     else if (!TEST_ptr(serverssl = SSL_new(serverctx)))
 930         goto error;
 931     if (*cssl != NULL)
 932         clientssl = *cssl;
 933     else if (!TEST_ptr(clientssl = SSL_new(clientctx)))
 934         goto error;
 935
 936     if (!TEST_ptr(s_to_c_bio = BIO_new_socket(sfd, BIO_NOCLOSE))
 937             || !TEST_ptr(c_to_s_bio = BIO_new_socket(cfd, BIO_NOCLOSE)))
 938         goto error;
 939
 940     SSL_set_bio(clientssl, c_to_s_bio, c_to_s_bio);
 941     SSL_set_bio(serverssl, s_to_c_bio, s_to_c_bio);
 942     *sssl = serverssl;
 943     *cssl = clientssl;
 944     return 1;
 945
 946  error:
 947     SSL_free(serverssl);
 948     SSL_free(clientssl);
 949     BIO_free(s_to_c_bio);
 950     BIO_free(c_to_s_bio);
 951     return 0;
 952 }
 953 #endif
 954
 955 /*
 956  * NOTE: Transfers control of the BIOs - this function will free them on error
 957  */
 958 int create_ssl_objects(SSL_CTX *serverctx, SSL_CTX *clientctx, SSL **sssl,
 959                           SSL **cssl, BIO *s_to_c_fbio, BIO *c_to_s_fbio)
 960 {
 961     SSL *serverssl = NULL, *clientssl = NULL;
 962     BIO *s_to_c_bio = NULL, *c_to_s_bio = NULL;
 963
 964     if (*sssl != NULL)
 965         serverssl = *sssl;
 966     else if (!TEST_ptr(serverssl = SSL_new(serverctx)))
 967         goto error;
 968     if (*cssl != NULL)
 969         clientssl = *cssl;
 970     else if (!TEST_ptr(clientssl = SSL_new(clientctx)))
 971         goto error;
 972
 973     if (SSL_is_dtls(clientssl)) {
 974         if (!TEST_ptr(s_to_c_bio = BIO_new(bio_s_mempacket_test()))
 975                 || !TEST_ptr(c_to_s_bio = BIO_new(bio_s_mempacket_test())))
 976             goto error;
 977     } else {
 978         if (!TEST_ptr(s_to_c_bio = BIO_new(BIO_s_mem()))
 979                 || !TEST_ptr(c_to_s_bio = BIO_new(BIO_s_mem())))
 980             goto error;
 981     }
 982
 983     if (s_to_c_fbio != NULL
 984             && !TEST_ptr(s_to_c_bio = BIO_push(s_to_c_fbio, s_to_c_bio)))
 985         goto error;
 986     if (c_to_s_fbio != NULL
 987             && !TEST_ptr(c_to_s_bio = BIO_push(c_to_s_fbio, c_to_s_bio)))
 988         goto error;
 989
 990     /* Set Non-blocking IO behaviour */
 991     BIO_set_mem_eof_return(s_to_c_bio, -1);
 992     BIO_set_mem_eof_return(c_to_s_bio, -1);
 993
 994     /* Up ref these as we are passing them to two SSL objects */
 995     SSL_set_bio(serverssl, c_to_s_bio, s_to_c_bio);
 996     BIO_up_ref(s_to_c_bio);
 997     BIO_up_ref(c_to_s_bio);
 998     SSL_set_bio(clientssl, s_to_c_bio, c_to_s_bio);
 999     *sssl = serverssl;
1000     *cssl = clientssl;
1001     return 1;
1002
1003  error:
1004     SSL_free(serverssl);
1005     SSL_free(clientssl);
1006     BIO_free(s_to_c_bio);
1007     BIO_free(c_to_s_bio);
1008     BIO_free(s_to_c_fbio);
1009     BIO_free(c_to_s_fbio);
1010
1011     return 0;
1012 }
1013
1014 /*
1015  * Create an SSL connection, but does not read any post-handshake
1016  * NewSessionTicket messages.
1017  * If |read| is set and we're using DTLS then we will attempt to SSL_read on
1018  * the connection once we've completed one half of it, to ensure any retransmits
1019  * get triggered.
1020  * We stop the connection attempt (and return a failure value) if either peer
1021  * has SSL_get_error() return the value in the |want| parameter. The connection
1022  * attempt could be restarted by a subsequent call to this function.
1023  */
1024 int create_bare_ssl_connection(SSL *serverssl, SSL *clientssl, int want,
1025                                int read)
1026 {
1027     int retc = -1, rets = -1, err, abortctr = 0;
1028     int clienterr = 0, servererr = 0;
1029     int isdtls = SSL_is_dtls(serverssl);
1030
1031     do {
1032         err = SSL_ERROR_WANT_WRITE;
1033         while (!clienterr && retc <= 0 && err == SSL_ERROR_WANT_WRITE) {
1034             retc = SSL_connect(clientssl);
1035             if (retc <= 0)
1036                 err = SSL_get_error(clientssl, retc);
1037         }
1038
1039         if (!clienterr && retc <= 0 && err != SSL_ERROR_WANT_READ) {
1040             TEST_info("SSL_connect() failed %d, %d", retc, err);
1041             if (want != SSL_ERROR_SSL)
1042                 TEST_openssl_errors();
1043             clienterr = 1;
1044         }
1045         if (want != SSL_ERROR_NONE && err == want)
1046             return 0;
1047
1048         err = SSL_ERROR_WANT_WRITE;
1049         while (!servererr && rets <= 0 && err == SSL_ERROR_WANT_WRITE) {
1050             rets = SSL_accept(serverssl);
1051             if (rets <= 0)
1052                 err = SSL_get_error(serverssl, rets);
1053         }
1054
1055         if (!servererr && rets <= 0
1056                 && err != SSL_ERROR_WANT_READ
1057                 && err != SSL_ERROR_WANT_X509_LOOKUP) {
1058             TEST_info("SSL_accept() failed %d, %d", rets, err);
1059             if (want != SSL_ERROR_SSL)
1060                 TEST_openssl_errors();
1061             servererr = 1;
1062         }
1063         if (want != SSL_ERROR_NONE && err == want)
1064             return 0;
1065         if (clienterr && servererr)
1066             return 0;
1067         if (isdtls && read) {
1068             unsigned char buf[20];
1069
1070             /* Trigger any retransmits that may be appropriate */
1071             if (rets > 0 && retc <= 0) {
1072                 if (SSL_read(serverssl, buf, sizeof(buf)) > 0) {
1073                     /* We don't expect this to succeed! */
1074                     TEST_info("Unexpected SSL_read() success!");
1075                     return 0;
1076                 }
1077             }
1078             if (retc > 0 && rets <= 0) {
1079                 if (SSL_read(clientssl, buf, sizeof(buf)) > 0) {
1080                     /* We don't expect this to succeed! */
1081                     TEST_info("Unexpected SSL_read() success!");
1082                     return 0;
1083                 }
1084             }
1085         }
1086         if (++abortctr == MAXLOOPS) {
1087             TEST_info("No progress made");
1088             return 0;
1089         }
1090         if (isdtls && abortctr <= 50 && (abortctr % 10) == 0) {
1091             /*
1092              * It looks like we're just spinning. Pause for a short period to
1093              * give the DTLS timer a chance to do something. We only do this for
1094              * the first few times to prevent hangs.
1095              */
1096             ossl_sleep(50);
1097         }
1098     } while (retc <=0 || rets <= 0);
1099
1100     return 1;
1101 }
1102
1103 /*
1104  * Create an SSL connection including any post handshake NewSessionTicket
1105  * messages.
1106  */
1107 int create_ssl_connection(SSL *serverssl, SSL *clientssl, int want)
1108 {
1109     int i;
1110     unsigned char buf;
1111     size_t readbytes;
1112
1113     if (!create_bare_ssl_connection(serverssl, clientssl, want, 1))
1114         return 0;
1115
1116     /*
1117      * We attempt to read some data on the client side which we expect to fail.
1118      * This will ensure we have received the NewSessionTicket in TLSv1.3 where
1119      * appropriate. We do this twice because there are 2 NewSessionTickets.
1120      */
1121     for (i = 0; i < 2; i++) {
1122         if (SSL_read_ex(clientssl, &buf, sizeof(buf), &readbytes) > 0) {
1123             if (!TEST_ulong_eq(readbytes, 0))
1124                 return 0;
1125         } else if (!TEST_int_eq(SSL_get_error(clientssl, 0),
1126                                 SSL_ERROR_WANT_READ)) {
1127             return 0;
1128         }
1129     }
1130
1131     return 1;
1132 }
1133
1134 void shutdown_ssl_connection(SSL *serverssl, SSL *clientssl)
1135 {
1136     SSL_shutdown(clientssl);
1137     SSL_shutdown(serverssl);
1138     SSL_free(serverssl);
1139     SSL_free(clientssl);
1140 }