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     mempacket_free(thispkt);
 410     return outl;
 411 }
 412
 413 int mempacket_test_inject(BIO *bio, const char *in, int inl, int pktnum,
 414                           int type)
 415 {
 416     MEMPACKET_TEST_CTX *ctx = BIO_get_data(bio);
 417     MEMPACKET *thispkt = NULL, *looppkt, *nextpkt, *allpkts[3];
 418     int i, duprec;
 419     const unsigned char *inu = (const unsigned char *)in;
 420     size_t len = ((inu[RECORD_LEN_HI] << 8) | inu[RECORD_LEN_LO])
 421                  + DTLS1_RT_HEADER_LENGTH;
 422
 423     if (ctx == NULL)
 424         return -1;
 425
 426     if ((size_t)inl < len)
 427         return -1;
 428
 429     if ((size_t)inl == len)
 430         duprec = 0;
 431     else
 432         duprec = ctx->duprec > 0;
 433
 434     /* We don't support arbitrary injection when duplicating records */
 435     if (duprec && pktnum != -1)
 436         return -1;
 437
 438     /* We only allow injection before we've started writing any data */
 439     if (pktnum >= 0) {
 440         if (ctx->noinject)
 441             return -1;
 442         ctx->injected  = 1;
 443     } else {
 444         ctx->noinject = 1;
 445     }
 446
 447     for (i = 0; i < (duprec ? 3 : 1); i++) {
 448         if (!TEST_ptr(allpkts[i] = OPENSSL_malloc(sizeof(*thispkt))))
 449             goto err;
 450         thispkt = allpkts[i];
 451
 452         if (!TEST_ptr(thispkt->data = OPENSSL_malloc(inl)))
 453             goto err;
 454         /*
 455          * If we are duplicating the packet, we duplicate it three times. The
 456          * first two times we drop the first record if there are more than one.
 457          * In this way we know that libssl will not be able to make progress
 458          * until it receives the last packet, and hence will be forced to
 459          * buffer these records.
 460          */
 461         if (duprec && i != 2) {
 462             memcpy(thispkt->data, in + len, inl - len);
 463             thispkt->len = inl - len;
 464         } else {
 465             memcpy(thispkt->data, in, inl);
 466             thispkt->len = inl;
 467         }
 468         thispkt->num = (pktnum >= 0) ? (unsigned int)pktnum : ctx->lastpkt + i;
 469         thispkt->type = type;
 470     }
 471
 472     for (i = 0; (looppkt = sk_MEMPACKET_value(ctx->pkts, i)) != NULL; i++) {
 473         /* Check if we found the right place to insert this packet */
 474         if (looppkt->num > thispkt->num) {
 475             if (sk_MEMPACKET_insert(ctx->pkts, thispkt, i) == 0)
 476                 goto err;
 477             /* If we're doing up front injection then we're done */
 478             if (pktnum >= 0)
 479                 return inl;
 480             /*
 481              * We need to do some accounting on lastpkt. We increment it first,
 482              * but it might now equal the value of injected packets, so we need
 483              * to skip over those
 484              */
 485             ctx->lastpkt++;
 486             do {
 487                 i++;
 488                 nextpkt = sk_MEMPACKET_value(ctx->pkts, i);
 489                 if (nextpkt != NULL && nextpkt->num == ctx->lastpkt)
 490                     ctx->lastpkt++;
 491                 else
 492                     return inl;
 493             } while(1);
 494         } else if (looppkt->num == thispkt->num) {
 495             if (!ctx->noinject) {
 496                 /* We injected two packets with the same packet number! */
 497                 goto err;
 498             }
 499             ctx->lastpkt++;
 500             thispkt->num++;
 501         }
 502     }
 503     /*
 504      * We didn't find any packets with a packet number equal to or greater than
 505      * this one, so we just add it onto the end
 506      */
 507     for (i = 0; i < (duprec ? 3 : 1); i++) {
 508         thispkt = allpkts[i];
 509         if (!sk_MEMPACKET_push(ctx->pkts, thispkt))
 510             goto err;
 511
 512         if (pktnum < 0)
 513             ctx->lastpkt++;
 514     }
 515
 516     return inl;
 517
 518  err:
 519     for (i = 0; i < (ctx->duprec > 0 ? 3 : 1); i++)
 520         mempacket_free(allpkts[i]);
 521     return -1;
 522 }
 523
 524 static int mempacket_test_write(BIO *bio, const char *in, int inl)
 525 {
 526     return mempacket_test_inject(bio, in, inl, -1, STANDARD_PACKET);
 527 }
 528
 529 static long mempacket_test_ctrl(BIO *bio, int cmd, long num, void *ptr)
 530 {
 531     long ret = 1;
 532     MEMPACKET_TEST_CTX *ctx = BIO_get_data(bio);
 533     MEMPACKET *thispkt;
 534
 535     switch (cmd) {
 536     case BIO_CTRL_EOF:
 537         ret = (long)(sk_MEMPACKET_num(ctx->pkts) == 0);
 538         break;
 539     case BIO_CTRL_GET_CLOSE:
 540         ret = BIO_get_shutdown(bio);
 541         break;
 542     case BIO_CTRL_SET_CLOSE:
 543         BIO_set_shutdown(bio, (int)num);
 544         break;
 545     case BIO_CTRL_WPENDING:
 546         ret = 0L;
 547         break;
 548     case BIO_CTRL_PENDING:
 549         thispkt = sk_MEMPACKET_value(ctx->pkts, 0);
 550         if (thispkt == NULL)
 551             ret = 0;
 552         else
 553             ret = thispkt->len;
 554         break;
 555     case BIO_CTRL_FLUSH:
 556         ret = 1;
 557         break;
 558     case MEMPACKET_CTRL_SET_DROP_EPOCH:
 559         ctx->dropepoch = (unsigned int)num;
 560         break;
 561     case MEMPACKET_CTRL_SET_DROP_REC:
 562         ctx->droprec = (int)num;
 563         break;
 564     case MEMPACKET_CTRL_GET_DROP_REC:
 565         ret = ctx->droprec;
 566         break;
 567     case MEMPACKET_CTRL_SET_DUPLICATE_REC:
 568         ctx->duprec = (int)num;
 569         break;
 570     case BIO_CTRL_RESET:
 571     case BIO_CTRL_DUP:
 572     case BIO_CTRL_PUSH:
 573     case BIO_CTRL_POP:
 574     default:
 575         ret = 0;
 576         break;
 577     }
 578     return ret;
 579 }
 580
 581 static int mempacket_test_gets(BIO *bio, char *buf, int size)
 582 {
 583     /* We don't support this - not needed anyway */
 584     return -1;
 585 }
 586
 587 static int mempacket_test_puts(BIO *bio, const char *str)
 588 {
 589     return mempacket_test_write(bio, str, strlen(str));
 590 }
 591
 592 static int always_retry_new(BIO *bi);
 593 static int always_retry_free(BIO *a);
 594 static int always_retry_read(BIO *b, char *out, int outl);
 595 static int always_retry_write(BIO *b, const char *in, int inl);
 596 static long always_retry_ctrl(BIO *b, int cmd, long num, void *ptr);
 597 static int always_retry_gets(BIO *bp, char *buf, int size);
 598 static int always_retry_puts(BIO *bp, const char *str);
 599
 600 const BIO_METHOD *bio_s_always_retry(void)
 601 {
 602     if (meth_always_retry == NULL) {
 603         if (!TEST_ptr(meth_always_retry = BIO_meth_new(BIO_TYPE_ALWAYS_RETRY,
 604                                                        "Always Retry"))
 605             || !TEST_true(BIO_meth_set_write(meth_always_retry,
 606                                              always_retry_write))
 607             || !TEST_true(BIO_meth_set_read(meth_always_retry,
 608                                             always_retry_read))
 609             || !TEST_true(BIO_meth_set_puts(meth_always_retry,
 610                                             always_retry_puts))
 611             || !TEST_true(BIO_meth_set_gets(meth_always_retry,
 612                                             always_retry_gets))
 613             || !TEST_true(BIO_meth_set_ctrl(meth_always_retry,
 614                                             always_retry_ctrl))
 615             || !TEST_true(BIO_meth_set_create(meth_always_retry,
 616                                               always_retry_new))
 617             || !TEST_true(BIO_meth_set_destroy(meth_always_retry,
 618                                                always_retry_free)))
 619             return NULL;
 620     }
 621     return meth_always_retry;
 622 }
 623
 624 void bio_s_always_retry_free(void)
 625 {
 626     BIO_meth_free(meth_always_retry);
 627 }
 628
 629 static int always_retry_new(BIO *bio)
 630 {
 631     BIO_set_init(bio, 1);
 632     return 1;
 633 }
 634
 635 static int always_retry_free(BIO *bio)
 636 {
 637     BIO_set_data(bio, NULL);
 638     BIO_set_init(bio, 0);
 639     return 1;
 640 }
 641
 642 static int always_retry_read(BIO *bio, char *out, int outl)
 643 {
 644     BIO_set_retry_read(bio);
 645     return -1;
 646 }
 647
 648 static int always_retry_write(BIO *bio, const char *in, int inl)
 649 {
 650     BIO_set_retry_write(bio);
 651     return -1;
 652 }
 653
 654 static long always_retry_ctrl(BIO *bio, int cmd, long num, void *ptr)
 655 {
 656     long ret = 1;
 657
 658     switch (cmd) {
 659     case BIO_CTRL_FLUSH:
 660         BIO_set_retry_write(bio);
 661         /* fall through */
 662     case BIO_CTRL_EOF:
 663     case BIO_CTRL_RESET:
 664     case BIO_CTRL_DUP:
 665     case BIO_CTRL_PUSH:
 666     case BIO_CTRL_POP:
 667     default:
 668         ret = 0;
 669         break;
 670     }
 671     return ret;
 672 }
 673
 674 static int always_retry_gets(BIO *bio, char *buf, int size)
 675 {
 676     BIO_set_retry_read(bio);
 677     return -1;
 678 }
 679
 680 static int always_retry_puts(BIO *bio, const char *str)
 681 {
 682     BIO_set_retry_write(bio);
 683     return -1;
 684 }
 685
 686 int create_ssl_ctx_pair(OSSL_LIB_CTX *libctx, const SSL_METHOD *sm,
 687                         const SSL_METHOD *cm, int min_proto_version,
 688                         int max_proto_version, SSL_CTX **sctx, SSL_CTX **cctx,
 689                         char *certfile, char *privkeyfile)
 690 {
 691     SSL_CTX *serverctx = NULL;
 692     SSL_CTX *clientctx = NULL;
 693
 694     if (sctx != NULL) {
 695         if (*sctx != NULL)
 696             serverctx = *sctx;
 697         else if (!TEST_ptr(serverctx = SSL_CTX_new_ex(libctx, NULL, sm))
 698             || !TEST_true(SSL_CTX_set_options(serverctx,
 699                                               SSL_OP_ALLOW_CLIENT_RENEGOTIATION)))
 700             goto err;
 701     }
 702
 703     if (cctx != NULL) {
 704         if (*cctx != NULL)
 705             clientctx = *cctx;
 706         else if (!TEST_ptr(clientctx = SSL_CTX_new_ex(libctx, NULL, cm)))
 707             goto err;
 708     }
 709
 710 #if !defined(OPENSSL_NO_TLS1_3) \
 711     && defined(OPENSSL_NO_EC) \
 712     && defined(OPENSSL_NO_DH)
 713     /*
 714      * There are no usable built-in TLSv1.3 groups if ec and dh are both
 715      * disabled
 716      */
 717     if (max_proto_version == 0
 718             && (sm == TLS_server_method() || cm == TLS_client_method()))
 719         max_proto_version = TLS1_2_VERSION;
 720 #endif
 721
 722     if (serverctx != NULL
 723             && ((min_proto_version > 0
 724                  && !TEST_true(SSL_CTX_set_min_proto_version(serverctx,
 725                                                             min_proto_version)))
 726                 || (max_proto_version > 0
 727                     && !TEST_true(SSL_CTX_set_max_proto_version(serverctx,
 728                                                                 max_proto_version)))))
 729         goto err;
 730     if (clientctx != NULL
 731         && ((min_proto_version > 0
 732              && !TEST_true(SSL_CTX_set_min_proto_version(clientctx,
 733                                                          min_proto_version)))
 734             || (max_proto_version > 0
 735                 && !TEST_true(SSL_CTX_set_max_proto_version(clientctx,
 736                                                             max_proto_version)))))
 737         goto err;
 738
 739     if (serverctx != NULL && certfile != NULL && privkeyfile != NULL) {
 740         if (!TEST_int_eq(SSL_CTX_use_certificate_file(serverctx, certfile,
 741                                                       SSL_FILETYPE_PEM), 1)
 742                 || !TEST_int_eq(SSL_CTX_use_PrivateKey_file(serverctx,
 743                                                             privkeyfile,
 744                                                             SSL_FILETYPE_PEM), 1)
 745                 || !TEST_int_eq(SSL_CTX_check_private_key(serverctx), 1))
 746             goto err;
 747     }
 748
 749     if (sctx != NULL)
 750         *sctx = serverctx;
 751     if (cctx != NULL)
 752         *cctx = clientctx;
 753     return 1;
 754
 755  err:
 756     if (sctx != NULL && *sctx == NULL)
 757         SSL_CTX_free(serverctx);
 758     if (cctx != NULL && *cctx == NULL)
 759         SSL_CTX_free(clientctx);
 760     return 0;
 761 }
 762
 763 #define MAXLOOPS    1000000
 764
 765 #if !defined(OPENSSL_NO_KTLS) && !defined(OPENSSL_NO_SOCK)
 766 static int set_nb(int fd)
 767 {
 768     int flags;
 769
 770     flags = fcntl(fd, F_GETFL, 0);
 771     if (flags == -1)
 772         return flags;
 773     flags = fcntl(fd, F_SETFL, flags | O_NONBLOCK);
 774     return flags;
 775 }
 776
 777 int create_test_sockets(int *cfdp, int *sfdp)
 778 {
 779     struct sockaddr_in sin;
 780     const char *host = "127.0.0.1";
 781     int cfd_connected = 0, ret = 0;
 782     socklen_t slen = sizeof(sin);
 783     int afd = -1, cfd = -1, sfd = -1;
 784
 785     memset ((char *) &sin, 0, sizeof(sin));
 786     sin.sin_family = AF_INET;
 787     sin.sin_addr.s_addr = inet_addr(host);
 788
 789     afd = socket(AF_INET, SOCK_STREAM, 0);
 790     if (afd < 0)
 791         return 0;
 792
 793     if (bind(afd, (struct sockaddr*)&sin, sizeof(sin)) < 0)
 794         goto out;
 795
 796     if (getsockname(afd, (struct sockaddr*)&sin, &slen) < 0)
 797         goto out;
 798
 799     if (listen(afd, 1) < 0)
 800         goto out;
 801
 802     cfd = socket(AF_INET, SOCK_STREAM, 0);
 803     if (cfd < 0)
 804         goto out;
 805
 806     if (set_nb(afd) == -1)
 807         goto out;
 808
 809     while (sfd == -1 || !cfd_connected) {
 810         sfd = accept(afd, NULL, 0);
 811         if (sfd == -1 && errno != EAGAIN)
 812             goto out;
 813
 814         if (!cfd_connected && connect(cfd, (struct sockaddr*)&sin, sizeof(sin)) < 0)
 815             goto out;
 816         else
 817             cfd_connected = 1;
 818     }
 819
 820     if (set_nb(cfd) == -1 || set_nb(sfd) == -1)
 821         goto out;
 822     ret = 1;
 823     *cfdp = cfd;
 824     *sfdp = sfd;
 825     goto success;
 826
 827 out:
 828     if (cfd != -1)
 829         close(cfd);
 830     if (sfd != -1)
 831         close(sfd);
 832 success:
 833     if (afd != -1)
 834         close(afd);
 835     return ret;
 836 }
 837
 838 int create_ssl_objects2(SSL_CTX *serverctx, SSL_CTX *clientctx, SSL **sssl,
 839                           SSL **cssl, int sfd, int cfd)
 840 {
 841     SSL *serverssl = NULL, *clientssl = NULL;
 842     BIO *s_to_c_bio = NULL, *c_to_s_bio = NULL;
 843
 844     if (*sssl != NULL)
 845         serverssl = *sssl;
 846     else if (!TEST_ptr(serverssl = SSL_new(serverctx)))
 847         goto error;
 848     if (*cssl != NULL)
 849         clientssl = *cssl;
 850     else if (!TEST_ptr(clientssl = SSL_new(clientctx)))
 851         goto error;
 852
 853     if (!TEST_ptr(s_to_c_bio = BIO_new_socket(sfd, BIO_NOCLOSE))
 854             || !TEST_ptr(c_to_s_bio = BIO_new_socket(cfd, BIO_NOCLOSE)))
 855         goto error;
 856
 857     SSL_set_bio(clientssl, c_to_s_bio, c_to_s_bio);
 858     SSL_set_bio(serverssl, s_to_c_bio, s_to_c_bio);
 859     *sssl = serverssl;
 860     *cssl = clientssl;
 861     return 1;
 862
 863  error:
 864     SSL_free(serverssl);
 865     SSL_free(clientssl);
 866     BIO_free(s_to_c_bio);
 867     BIO_free(c_to_s_bio);
 868     return 0;
 869 }
 870 #endif
 871
 872 /*
 873  * NOTE: Transfers control of the BIOs - this function will free them on error
 874  */
 875 int create_ssl_objects(SSL_CTX *serverctx, SSL_CTX *clientctx, SSL **sssl,
 876                           SSL **cssl, BIO *s_to_c_fbio, BIO *c_to_s_fbio)
 877 {
 878     SSL *serverssl = NULL, *clientssl = NULL;
 879     BIO *s_to_c_bio = NULL, *c_to_s_bio = NULL;
 880
 881     if (*sssl != NULL)
 882         serverssl = *sssl;
 883     else if (!TEST_ptr(serverssl = SSL_new(serverctx)))
 884         goto error;
 885     if (*cssl != NULL)
 886         clientssl = *cssl;
 887     else if (!TEST_ptr(clientssl = SSL_new(clientctx)))
 888         goto error;
 889
 890     if (SSL_is_dtls(clientssl)) {
 891         if (!TEST_ptr(s_to_c_bio = BIO_new(bio_s_mempacket_test()))
 892                 || !TEST_ptr(c_to_s_bio = BIO_new(bio_s_mempacket_test())))
 893             goto error;
 894     } else {
 895         if (!TEST_ptr(s_to_c_bio = BIO_new(BIO_s_mem()))
 896                 || !TEST_ptr(c_to_s_bio = BIO_new(BIO_s_mem())))
 897             goto error;
 898     }
 899
 900     if (s_to_c_fbio != NULL
 901             && !TEST_ptr(s_to_c_bio = BIO_push(s_to_c_fbio, s_to_c_bio)))
 902         goto error;
 903     if (c_to_s_fbio != NULL
 904             && !TEST_ptr(c_to_s_bio = BIO_push(c_to_s_fbio, c_to_s_bio)))
 905         goto error;
 906
 907     /* Set Non-blocking IO behaviour */
 908     BIO_set_mem_eof_return(s_to_c_bio, -1);
 909     BIO_set_mem_eof_return(c_to_s_bio, -1);
 910
 911     /* Up ref these as we are passing them to two SSL objects */
 912     SSL_set_bio(serverssl, c_to_s_bio, s_to_c_bio);
 913     BIO_up_ref(s_to_c_bio);
 914     BIO_up_ref(c_to_s_bio);
 915     SSL_set_bio(clientssl, s_to_c_bio, c_to_s_bio);
 916     *sssl = serverssl;
 917     *cssl = clientssl;
 918     return 1;
 919
 920  error:
 921     SSL_free(serverssl);
 922     SSL_free(clientssl);
 923     BIO_free(s_to_c_bio);
 924     BIO_free(c_to_s_bio);
 925     BIO_free(s_to_c_fbio);
 926     BIO_free(c_to_s_fbio);
 927
 928     return 0;
 929 }
 930
 931 /*
 932  * Create an SSL connection, but does not read any post-handshake
 933  * NewSessionTicket messages.
 934  * If |read| is set and we're using DTLS then we will attempt to SSL_read on
 935  * the connection once we've completed one half of it, to ensure any retransmits
 936  * get triggered.
 937  * We stop the connection attempt (and return a failure value) if either peer
 938  * has SSL_get_error() return the value in the |want| parameter. The connection
 939  * attempt could be restarted by a subsequent call to this function.
 940  */
 941 int create_bare_ssl_connection(SSL *serverssl, SSL *clientssl, int want,
 942                                int read)
 943 {
 944     int retc = -1, rets = -1, err, abortctr = 0;
 945     int clienterr = 0, servererr = 0;
 946     int isdtls = SSL_is_dtls(serverssl);
 947
 948     do {
 949         err = SSL_ERROR_WANT_WRITE;
 950         while (!clienterr && retc <= 0 && err == SSL_ERROR_WANT_WRITE) {
 951             retc = SSL_connect(clientssl);
 952             if (retc <= 0)
 953                 err = SSL_get_error(clientssl, retc);
 954         }
 955
 956         if (!clienterr && retc <= 0 && err != SSL_ERROR_WANT_READ) {
 957             TEST_info("SSL_connect() failed %d, %d", retc, err);
 958             if (want != SSL_ERROR_SSL)
 959                 TEST_openssl_errors();
 960             clienterr = 1;
 961         }
 962         if (want != SSL_ERROR_NONE && err == want)
 963             return 0;
 964
 965         err = SSL_ERROR_WANT_WRITE;
 966         while (!servererr && rets <= 0 && err == SSL_ERROR_WANT_WRITE) {
 967             rets = SSL_accept(serverssl);
 968             if (rets <= 0)
 969                 err = SSL_get_error(serverssl, rets);
 970         }
 971
 972         if (!servererr && rets <= 0
 973                 && err != SSL_ERROR_WANT_READ
 974                 && err != SSL_ERROR_WANT_X509_LOOKUP) {
 975             TEST_info("SSL_accept() failed %d, %d", rets, err);
 976             if (want != SSL_ERROR_SSL)
 977                 TEST_openssl_errors();
 978             servererr = 1;
 979         }
 980         if (want != SSL_ERROR_NONE && err == want)
 981             return 0;
 982         if (clienterr && servererr)
 983             return 0;
 984         if (isdtls && read) {
 985             unsigned char buf[20];
 986
 987             /* Trigger any retransmits that may be appropriate */
 988             if (rets > 0 && retc <= 0) {
 989                 if (SSL_read(serverssl, buf, sizeof(buf)) > 0) {
 990                     /* We don't expect this to succeed! */
 991                     TEST_info("Unexpected SSL_read() success!");
 992                     return 0;
 993                 }
 994             }
 995             if (retc > 0 && rets <= 0) {
 996                 if (SSL_read(clientssl, buf, sizeof(buf)) > 0) {
 997                     /* We don't expect this to succeed! */
 998                     TEST_info("Unexpected SSL_read() success!");
 999                     return 0;
1000                 }
1001             }
1002         }
1003         if (++abortctr == MAXLOOPS) {
1004             TEST_info("No progress made");
1005             return 0;
1006         }
1007         if (isdtls && abortctr <= 50 && (abortctr % 10) == 0) {
1008             /*
1009              * It looks like we're just spinning. Pause for a short period to
1010              * give the DTLS timer a chance to do something. We only do this for
1011              * the first few times to prevent hangs.
1012              */
1013             ossl_sleep(50);
1014         }
1015     } while (retc <=0 || rets <= 0);
1016
1017     return 1;
1018 }
1019
1020 /*
1021  * Create an SSL connection including any post handshake NewSessionTicket
1022  * messages.
1023  */
1024 int create_ssl_connection(SSL *serverssl, SSL *clientssl, int want)
1025 {
1026     int i;
1027     unsigned char buf;
1028     size_t readbytes;
1029
1030     if (!create_bare_ssl_connection(serverssl, clientssl, want, 1))
1031         return 0;
1032
1033     /*
1034      * We attempt to read some data on the client side which we expect to fail.
1035      * This will ensure we have received the NewSessionTicket in TLSv1.3 where
1036      * appropriate. We do this twice because there are 2 NewSessionTickets.
1037      */
1038     for (i = 0; i < 2; i++) {
1039         if (SSL_read_ex(clientssl, &buf, sizeof(buf), &readbytes) > 0) {
1040             if (!TEST_ulong_eq(readbytes, 0))
1041                 return 0;
1042         } else if (!TEST_int_eq(SSL_get_error(clientssl, 0),
1043                                 SSL_ERROR_WANT_READ)) {
1044             return 0;
1045         }
1046     }
1047
1048     return 1;
1049 }
1050
1051 void shutdown_ssl_connection(SSL *serverssl, SSL *clientssl)
1052 {
1053     SSL_shutdown(clientssl);
1054     SSL_shutdown(serverssl);
1055     SSL_free(serverssl);
1056     SSL_free(clientssl);
1057 }