test/quic_txp_test.c

   1 /*
   2  * Copyright 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 #include "internal/packet.h"
  10 #include "internal/quic_txp.h"
  11 #include "internal/quic_statm.h"
  12 #include "internal/quic_demux.h"
  13 #include "internal/quic_record_rx.h"
  14 #include "testutil.h"
  15 #include "quic_record_test_util.h"
  16
  17 static const QUIC_CONN_ID scid_1 = {
  18     1, { 0x5f }
  19 };
  20
  21 static const QUIC_CONN_ID dcid_1 = {
  22     8, { 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8 }
  23 };
  24
  25 static const QUIC_CONN_ID cid_1 = {
  26     8, { 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8 }
  27 };
  28
  29 static const unsigned char reset_token_1[16] = {
  30     0x99, 0x88, 0x77, 0x66, 0x55, 0x44, 0x33, 0x22, 0x11,
  31     0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff, 0x12,
  32 };
  33
  34 static const unsigned char secret_1[32] = {
  35     0x01
  36 };
  37
  38 static OSSL_TIME fake_now(void *arg)
  39 {
  40     return ossl_time_now(); /* TODO */
  41 }
  42
  43 struct helper {
  44     OSSL_QUIC_TX_PACKETISER         *txp;
  45     OSSL_QUIC_TX_PACKETISER_ARGS    args;
  46     OSSL_QTX_ARGS                   qtx_args;
  47     BIO                             *bio1, *bio2;
  48     QUIC_TXFC                       conn_txfc;
  49     QUIC_RXFC                       conn_rxfc, stream_rxfc;
  50     QUIC_RXFC                       max_streams_bidi_rxfc, max_streams_uni_rxfc;
  51     OSSL_STATM                      statm;
  52     OSSL_CC_DATA                    *cc_data;
  53     const OSSL_CC_METHOD            *cc_method;
  54     QUIC_STREAM_MAP                 qsm;
  55     char                            have_statm, have_qsm;
  56     QUIC_DEMUX                      *demux;
  57     OSSL_QRX                        *qrx;
  58     OSSL_QRX_ARGS                   qrx_args;
  59     OSSL_QRX_PKT                    *qrx_pkt;
  60     PACKET                          pkt;
  61     uint64_t                        frame_type;
  62     union {
  63         uint64_t                        max_data;
  64         OSSL_QUIC_FRAME_NEW_CONN_ID     new_conn_id;
  65         OSSL_QUIC_FRAME_ACK             ack;
  66         struct {
  67             const unsigned char *token;
  68             size_t              token_len;
  69         } new_token;
  70         OSSL_QUIC_FRAME_CRYPTO          crypto;
  71         OSSL_QUIC_FRAME_STREAM          stream;
  72         OSSL_QUIC_FRAME_STOP_SENDING    stop_sending;
  73         OSSL_QUIC_FRAME_RESET_STREAM    reset_stream;
  74         OSSL_QUIC_FRAME_CONN_CLOSE      conn_close;
  75     } frame;
  76     OSSL_QUIC_ACK_RANGE     ack_ranges[16];
  77 };
  78
  79 static void helper_cleanup(struct helper *h)
  80 {
  81     size_t i;
  82     uint32_t pn_space;
  83
  84     ossl_qrx_pkt_release(h->qrx_pkt);
  85     h->qrx_pkt = NULL;
  86
  87     for (pn_space = QUIC_PN_SPACE_INITIAL;
  88          pn_space < QUIC_PN_SPACE_NUM;
  89          ++pn_space)
  90         ossl_ackm_on_pkt_space_discarded(h->args.ackm, pn_space);
  91
  92     ossl_quic_tx_packetiser_free(h->txp);
  93     ossl_qtx_free(h->args.qtx);
  94     ossl_quic_txpim_free(h->args.txpim);
  95     ossl_quic_cfq_free(h->args.cfq);
  96     if (h->cc_data != NULL)
  97         h->cc_method->free(h->cc_data);
  98     if (h->have_statm)
  99         ossl_statm_destroy(&h->statm);
 100     if (h->have_qsm)
 101         ossl_quic_stream_map_cleanup(&h->qsm);
 102     for (i = 0; i < QUIC_PN_SPACE_NUM; ++i)
 103         ossl_quic_sstream_free(h->args.crypto[i]);
 104     ossl_ackm_free(h->args.ackm);
 105     ossl_qrx_free(h->qrx);
 106     ossl_quic_demux_free(h->demux);
 107     BIO_free(h->bio1);
 108     BIO_free(h->bio2);
 109 }
 110
 111 static int helper_init(struct helper *h)
 112 {
 113     int rc = 0;
 114     size_t i;
 115
 116     memset(h, 0, sizeof(*h));
 117
 118     /* Initialisation */
 119     if (!TEST_true(BIO_new_bio_dgram_pair(&h->bio1, 0, &h->bio2, 0)))
 120         goto err;
 121
 122     h->qtx_args.bio    = h->bio1;
 123     h->qtx_args.mdpl   = 1200;
 124
 125     if (!TEST_ptr(h->args.qtx = ossl_qtx_new(&h->qtx_args)))
 126         goto err;
 127
 128     if (!TEST_ptr(h->args.txpim = ossl_quic_txpim_new()))
 129         goto err;
 130
 131     if (!TEST_ptr(h->args.cfq = ossl_quic_cfq_new()))
 132         goto err;
 133
 134     if (!TEST_true(ossl_quic_txfc_init(&h->conn_txfc, NULL)))
 135         goto err;
 136
 137     if (!TEST_true(ossl_quic_rxfc_init(&h->conn_rxfc, NULL,
 138                                        2 * 1024 * 1024,
 139                                        10 * 1024 * 1024,
 140                                        fake_now,
 141                                        NULL)))
 142         goto err;
 143
 144     if (!TEST_true(ossl_quic_rxfc_init(&h->stream_rxfc, &h->conn_rxfc,
 145                                        1 * 1024 * 1024,
 146                                        5 * 1024 * 1024,
 147                                        fake_now,
 148                                        NULL)))
 149         goto err;
 150
 151     if (!TEST_true(ossl_quic_rxfc_init(&h->max_streams_bidi_rxfc, NULL,
 152                                        100, 100,
 153                                        fake_now,
 154                                        NULL)))
 155         goto err;
 156
 157     if (!TEST_true(ossl_quic_rxfc_init(&h->max_streams_uni_rxfc, NULL,
 158                                        100, 100,
 159                                        fake_now,
 160                                        NULL)))
 161
 162     if (!TEST_true(ossl_statm_init(&h->statm)))
 163         goto err;
 164
 165     h->have_statm = 1;
 166
 167     h->cc_method = &ossl_cc_dummy_method;
 168     if (!TEST_ptr(h->cc_data = h->cc_method->new(fake_now, NULL)))
 169         goto err;
 170
 171     if (!TEST_ptr(h->args.ackm = ossl_ackm_new(fake_now, NULL,
 172                                                &h->statm,
 173                                                h->cc_method,
 174                                                h->cc_data)))
 175         goto err;
 176
 177     if (!TEST_true(ossl_quic_stream_map_init(&h->qsm, NULL, NULL,
 178                                              &h->max_streams_bidi_rxfc,
 179                                              &h->max_streams_uni_rxfc,
 180                                              /*is_server=*/0)))
 181         goto err;
 182
 183     h->have_qsm = 1;
 184
 185     for (i = 0; i < QUIC_PN_SPACE_NUM; ++i)
 186         if (!TEST_ptr(h->args.crypto[i] = ossl_quic_sstream_new(4096)))
 187             goto err;
 188
 189     h->args.cur_scid                = scid_1;
 190     h->args.cur_dcid                = dcid_1;
 191     h->args.qsm                     = &h->qsm;
 192     h->args.conn_txfc               = &h->conn_txfc;
 193     h->args.conn_rxfc               = &h->conn_rxfc;
 194     h->args.max_streams_bidi_rxfc   = &h->max_streams_bidi_rxfc;
 195     h->args.max_streams_uni_rxfc    = &h->max_streams_uni_rxfc;
 196     h->args.cc_method               = h->cc_method;
 197     h->args.cc_data                 = h->cc_data;
 198     h->args.now                     = fake_now;
 199
 200     if (!TEST_ptr(h->txp = ossl_quic_tx_packetiser_new(&h->args)))
 201         goto err;
 202
 203     if (!TEST_ptr(h->demux = ossl_quic_demux_new(h->bio2, 8,
 204                                                  fake_now, NULL)))
 205         goto err;
 206
 207     h->qrx_args.demux                  = h->demux;
 208     h->qrx_args.short_conn_id_len      = 8;
 209     h->qrx_args.max_deferred           = 32;
 210
 211     if (!TEST_ptr(h->qrx = ossl_qrx_new(&h->qrx_args)))
 212         goto err;
 213
 214     if (!TEST_true(ossl_qrx_add_dst_conn_id(h->qrx, &dcid_1)))
 215         goto err;
 216
 217     rc = 1;
 218 err:
 219     if (!rc)
 220         helper_cleanup(h);
 221
 222     return rc;
 223 }
 224
 225 #define OPK_END                     0   /* End of Script */
 226 #define OPK_TXP_GENERATE            1   /* Call generate, expect packet output */
 227 #define OPK_TXP_GENERATE_NONE       2   /* Call generate, expect no packet output */
 228 #define OPK_RX_PKT                  3   /* Receive, expect packet */
 229 #define OPK_RX_PKT_NONE             4   /* Receive, expect no packet */
 230 #define OPK_EXPECT_DGRAM_LEN        5   /* Expect received datagram length in range */
 231 #define OPK_EXPECT_FRAME            6   /* Expect next frame is of type */
 232 #define OPK_EXPECT_INITIAL_TOKEN    7   /* Expect initial token buffer match */
 233 #define OPK_EXPECT_HDR              8   /* Expect header structure match */
 234 #define OPK_CHECK                   9   /* Call check function */
 235 #define OPK_NEXT_FRAME              10  /* Next frame */
 236 #define OPK_EXPECT_NO_FRAME         11  /* Expect no further frames */
 237 #define OPK_PROVIDE_SECRET          12  /* Provide secret to QTX and QRX */
 238 #define OPK_DISCARD_EL              13  /* Discard QTX EL */
 239 #define OPK_CRYPTO_SEND             14  /* Push data into crypto send stream */
 240 #define OPK_STREAM_NEW              15  /* Create new application stream */
 241 #define OPK_STREAM_SEND             16  /* Push data into application send stream */
 242 #define OPK_STREAM_FIN              17  /* Mark stream as finished */
 243 #define OPK_STOP_SENDING            18  /* Mark stream for STOP_SENDING */
 244 #define OPK_RESET_STREAM            19  /* Mark stream for RESET_STREAM */
 245 #define OPK_CONN_TXFC_BUMP          20  /* Bump connection TXFC CWM */
 246 #define OPK_STREAM_TXFC_BUMP        21  /* Bump stream TXFC CWM */
 247 #define OPK_HANDSHAKE_COMPLETE      22  /* Mark handshake as complete */
 248 #define OPK_NOP                     23  /* No-op */
 249
 250 struct script_op {
 251     uint32_t opcode;
 252     uint64_t arg0, arg1;
 253     const void *buf;
 254     size_t buf_len;
 255     int (*check_func)(struct helper *h);
 256 };
 257
 258 #define OP_END      \
 259     { OPK_END }
 260 #define OP_TXP_GENERATE() \
 261     { OPK_TXP_GENERATE },
 262 #define OP_TXP_GENERATE_NONE() \
 263     { OPK_TXP_GENERATE_NONE },
 264 #define OP_RX_PKT() \
 265     { OPK_RX_PKT },
 266 #define OP_RX_PKT_NONE() \
 267     { OPK_RX_PKT_NONE },
 268 #define OP_EXPECT_DGRAM_LEN(lo, hi) \
 269     { OPK_EXPECT_DGRAM_LEN, (lo), (hi) },
 270 #define OP_EXPECT_FRAME(frame_type) \
 271     { OPK_EXPECT_FRAME, (frame_type) },
 272 #define OP_EXPECT_INITIAL_TOKEN(buf) \
 273     { OPK_EXPECT_INITIAL_TOKEN, sizeof(buf), 0, buf },
 274 #define OP_EXPECT_HDR(hdr) \
 275     { OPK_EXPECT_HDR, 0, 0, &(hdr) },
 276 #define OP_CHECK(func) \
 277     { OPK_CHECK, 0, 0, NULL, 0, (func) },
 278 #define OP_NEXT_FRAME() \
 279     { OPK_NEXT_FRAME },
 280 #define OP_EXPECT_NO_FRAME() \
 281     { OPK_EXPECT_NO_FRAME },
 282 #define OP_PROVIDE_SECRET(el, suite, secret) \
 283     { OPK_PROVIDE_SECRET, (el), (suite), (secret), sizeof(secret) },
 284 #define OP_DISCARD_EL(el) \
 285     { OPK_DISCARD_EL, (el) },
 286 #define OP_CRYPTO_SEND(pn_space, buf) \
 287     { OPK_CRYPTO_SEND, (pn_space), 0, (buf), sizeof(buf) },
 288 #define OP_STREAM_NEW(id) \
 289     { OPK_STREAM_NEW, (id) },
 290 #define OP_STREAM_SEND(id, buf) \
 291     { OPK_STREAM_SEND, (id), 0, (buf), sizeof(buf) },
 292 #define OP_STREAM_FIN(id) \
 293     { OPK_STREAM_FIN, (id) },
 294 #define OP_STOP_SENDING(id, aec) \
 295     { OPK_STOP_SENDING, (id), (aec) },
 296 #define OP_RESET_STREAM(id, aec) \
 297     { OPK_RESET_STREAM, (id), (aec) },
 298 #define OP_CONN_TXFC_BUMP(cwm) \
 299     { OPK_CONN_TXFC_BUMP, (cwm) },
 300 #define OP_STREAM_TXFC_BUMP(id, cwm) \
 301     { OPK_STREAM_TXFC_BUMP, (cwm), (id) },
 302 #define OP_HANDSHAKE_COMPLETE() \
 303     { OPK_HANDSHAKE_COMPLETE },
 304 #define OP_NOP() \
 305     { OPK_NOP },
 306
 307 static int schedule_handshake_done(struct helper *h)
 308 {
 309     ossl_quic_tx_packetiser_schedule_handshake_done(h->txp);
 310     return 1;
 311 }
 312
 313 static int schedule_ack_eliciting_app(struct helper *h)
 314 {
 315     ossl_quic_tx_packetiser_schedule_ack_eliciting(h->txp, QUIC_PN_SPACE_APP);
 316     return 1;
 317 }
 318
 319 /* 1. 1-RTT, Single Handshake Done Frame */
 320 static const struct script_op script_1[] = {
 321     OP_PROVIDE_SECRET(QUIC_ENC_LEVEL_1RTT, QRL_SUITE_AES128GCM, secret_1)
 322     OP_TXP_GENERATE_NONE()
 323     OP_CHECK(schedule_handshake_done)
 324     OP_TXP_GENERATE()
 325     OP_RX_PKT()
 326     /* Should not be long */
 327     OP_EXPECT_DGRAM_LEN(21, 32)
 328     OP_NEXT_FRAME()
 329     OP_EXPECT_FRAME(OSSL_QUIC_FRAME_TYPE_HANDSHAKE_DONE)
 330     OP_EXPECT_NO_FRAME()
 331     OP_RX_PKT_NONE()
 332     OP_TXP_GENERATE_NONE()
 333     OP_END
 334 };
 335
 336 /* 2. 1-RTT, Forced ACK-Eliciting Frame */
 337 static const struct script_op script_2[] = {
 338     OP_PROVIDE_SECRET(QUIC_ENC_LEVEL_1RTT, QRL_SUITE_AES128GCM, secret_1)
 339     OP_TXP_GENERATE_NONE()
 340     OP_CHECK(schedule_ack_eliciting_app)
 341     OP_TXP_GENERATE()
 342     OP_RX_PKT()
 343     /* Should not be long */
 344     OP_EXPECT_DGRAM_LEN(21, 32)
 345     /* A PING frame should have been added */
 346     OP_NEXT_FRAME()
 347     OP_EXPECT_FRAME(OSSL_QUIC_FRAME_TYPE_PING)
 348     OP_EXPECT_NO_FRAME()
 349     OP_RX_PKT_NONE()
 350     OP_TXP_GENERATE_NONE()
 351     OP_END
 352 };
 353
 354 /* 3. 1-RTT, MAX_DATA */
 355 static int schedule_max_data(struct helper *h)
 356 {
 357     uint64_t cwm;
 358
 359     cwm = ossl_quic_rxfc_get_cwm(&h->stream_rxfc);
 360
 361     if (!TEST_true(ossl_quic_rxfc_on_rx_stream_frame(&h->stream_rxfc, cwm, 0))
 362         || !TEST_true(ossl_quic_rxfc_on_retire(&h->stream_rxfc, cwm,
 363                                                ossl_ticks2time(OSSL_TIME_MS))))
 364         return 0;
 365
 366     return 1;
 367 }
 368
 369 static const struct script_op script_3[] = {
 370     OP_PROVIDE_SECRET(QUIC_ENC_LEVEL_1RTT, QRL_SUITE_AES128GCM, secret_1)
 371     OP_TXP_GENERATE_NONE()
 372     OP_CHECK(schedule_max_data)
 373     OP_TXP_GENERATE()
 374     OP_RX_PKT()
 375     /* Should not be long */
 376     OP_EXPECT_DGRAM_LEN(21, 40)
 377     /* A PING frame should have been added */
 378     OP_NEXT_FRAME()
 379     OP_EXPECT_FRAME(OSSL_QUIC_FRAME_TYPE_MAX_DATA)
 380     OP_EXPECT_NO_FRAME()
 381     OP_RX_PKT_NONE()
 382     OP_TXP_GENERATE_NONE()
 383     OP_END
 384 };
 385
 386 /* 4. 1-RTT, CFQ (NEW_CONN_ID) */
 387 static void free_buf_mem(unsigned char *buf, size_t buf_len, void *arg)
 388 {
 389     BUF_MEM_free((BUF_MEM *)arg);
 390 }
 391
 392 static int schedule_cfq_new_conn_id(struct helper *h)
 393 {
 394     int rc = 0;
 395     QUIC_CFQ_ITEM *cfq_item;
 396     WPACKET wpkt;
 397     BUF_MEM *buf_mem = NULL;
 398     size_t l = 0;
 399     OSSL_QUIC_FRAME_NEW_CONN_ID ncid = {0};
 400
 401     ncid.seq_num         = 2345;
 402     ncid.retire_prior_to = 1234;
 403     ncid.conn_id         = cid_1;
 404     memcpy(ncid.stateless_reset_token, reset_token_1, sizeof(reset_token_1));
 405
 406     if (!TEST_ptr(buf_mem = BUF_MEM_new()))
 407         goto err;
 408
 409     if (!TEST_true(WPACKET_init(&wpkt, buf_mem)))
 410         goto err;
 411
 412     if (!TEST_true(ossl_quic_wire_encode_frame_new_conn_id(&wpkt, &ncid))) {
 413         WPACKET_cleanup(&wpkt);
 414         goto err;
 415     }
 416
 417     WPACKET_finish(&wpkt);
 418
 419     if (!TEST_true(WPACKET_get_total_written(&wpkt, &l)))
 420         goto err;
 421
 422     if (!TEST_ptr(cfq_item = ossl_quic_cfq_add_frame(h->args.cfq, 1,
 423                                                      QUIC_PN_SPACE_APP,
 424                                                      OSSL_QUIC_FRAME_TYPE_NEW_CONN_ID,
 425                                                      (unsigned char *)buf_mem->data, l,
 426                                                      free_buf_mem,
 427                                                      buf_mem)))
 428         goto err;
 429
 430     rc = 1;
 431 err:
 432     if (!rc)
 433         BUF_MEM_free(buf_mem);
 434     return rc;
 435 }
 436
 437 static int check_cfq_new_conn_id(struct helper *h)
 438 {
 439     if (!TEST_uint64_t_eq(h->frame.new_conn_id.seq_num, 2345)
 440         || !TEST_uint64_t_eq(h->frame.new_conn_id.retire_prior_to, 1234)
 441         || !TEST_mem_eq(&h->frame.new_conn_id.conn_id, sizeof(cid_1),
 442                         &cid_1, sizeof(cid_1))
 443         || !TEST_mem_eq(&h->frame.new_conn_id.stateless_reset_token,
 444                         sizeof(reset_token_1),
 445                         reset_token_1,
 446                         sizeof(reset_token_1)))
 447         return 0;
 448
 449     return 1;
 450 }
 451
 452 static const struct script_op script_4[] = {
 453     OP_PROVIDE_SECRET(QUIC_ENC_LEVEL_1RTT, QRL_SUITE_AES128GCM, secret_1)
 454     OP_TXP_GENERATE_NONE()
 455     OP_CHECK(schedule_cfq_new_conn_id)
 456     OP_TXP_GENERATE()
 457     OP_RX_PKT()
 458     OP_EXPECT_DGRAM_LEN(21, 128)
 459     OP_NEXT_FRAME()
 460     OP_EXPECT_FRAME(OSSL_QUIC_FRAME_TYPE_NEW_CONN_ID)
 461     OP_CHECK(check_cfq_new_conn_id)
 462     OP_EXPECT_NO_FRAME()
 463     OP_RX_PKT_NONE()
 464     OP_TXP_GENERATE_NONE()
 465     OP_END
 466 };
 467
 468 /* 5. 1-RTT, CFQ (NEW_TOKEN) */
 469 static const unsigned char token_1[] = {
 470     0x10, 0x11, 0x12, 0x13, 0x14, 0x15
 471 };
 472
 473 static int schedule_cfq_new_token(struct helper *h)
 474 {
 475     int rc = 0;
 476     QUIC_CFQ_ITEM *cfq_item;
 477     WPACKET wpkt;
 478     BUF_MEM *buf_mem = NULL;
 479     size_t l = 0;
 480
 481     if (!TEST_ptr(buf_mem = BUF_MEM_new()))
 482         goto err;
 483
 484     if (!TEST_true(WPACKET_init(&wpkt, buf_mem)))
 485         goto err;
 486
 487     if (!TEST_true(ossl_quic_wire_encode_frame_new_token(&wpkt, token_1,
 488                                                          sizeof(token_1)))) {
 489         WPACKET_cleanup(&wpkt);
 490         goto err;
 491     }
 492
 493     WPACKET_finish(&wpkt);
 494
 495     if (!TEST_true(WPACKET_get_total_written(&wpkt, &l)))
 496         goto err;
 497
 498     if (!TEST_ptr(cfq_item = ossl_quic_cfq_add_frame(h->args.cfq, 1,
 499                                                      QUIC_PN_SPACE_APP,
 500                                                      OSSL_QUIC_FRAME_TYPE_NEW_TOKEN,
 501                                                      (unsigned char *)buf_mem->data, l,
 502                                                      free_buf_mem,
 503                                                      buf_mem)))
 504         goto err;
 505
 506     rc = 1;
 507 err:
 508     if (!rc)
 509         BUF_MEM_free(buf_mem);
 510     return rc;
 511 }
 512
 513 static int check_cfq_new_token(struct helper *h)
 514 {
 515     if (!TEST_mem_eq(h->frame.new_token.token,
 516                      h->frame.new_token.token_len,
 517                      token_1,
 518                      sizeof(token_1)))
 519         return 0;
 520
 521     return 1;
 522 }
 523
 524 static const struct script_op script_5[] = {
 525     OP_PROVIDE_SECRET(QUIC_ENC_LEVEL_1RTT, QRL_SUITE_AES128GCM, secret_1)
 526     OP_TXP_GENERATE_NONE()
 527     OP_CHECK(schedule_cfq_new_token)
 528     OP_TXP_GENERATE()
 529     OP_RX_PKT()
 530     OP_EXPECT_DGRAM_LEN(21, 512)
 531     OP_NEXT_FRAME()
 532     OP_EXPECT_FRAME(OSSL_QUIC_FRAME_TYPE_NEW_TOKEN)
 533     OP_CHECK(check_cfq_new_token)
 534     OP_EXPECT_NO_FRAME()
 535     OP_RX_PKT_NONE()
 536     OP_TXP_GENERATE_NONE()
 537     OP_END
 538 };
 539
 540 /* 6. 1-RTT, ACK */
 541 static int schedule_ack(struct helper *h)
 542 {
 543     size_t i;
 544     OSSL_ACKM_RX_PKT rx_pkt = {0};
 545
 546     /* Stimulate ACK emission by simulating a few received packets. */
 547     for (i = 0; i < 5; ++i) {
 548         rx_pkt.pkt_num          = i;
 549         rx_pkt.time             = fake_now(NULL);
 550         rx_pkt.pkt_space        = QUIC_PN_SPACE_APP;
 551         rx_pkt.is_ack_eliciting = 1;
 552
 553         if (!TEST_true(ossl_ackm_on_rx_packet(h->args.ackm, &rx_pkt)))
 554             return 0;
 555     }
 556
 557     return 1;
 558 }
 559
 560 static const struct script_op script_6[] = {
 561     OP_PROVIDE_SECRET(QUIC_ENC_LEVEL_1RTT, QRL_SUITE_AES128GCM, secret_1)
 562     OP_TXP_GENERATE_NONE()
 563     OP_CHECK(schedule_ack)
 564     OP_TXP_GENERATE()
 565     OP_RX_PKT()
 566     OP_EXPECT_DGRAM_LEN(21, 512)
 567     OP_NEXT_FRAME()
 568     OP_EXPECT_FRAME(OSSL_QUIC_FRAME_TYPE_ACK_WITHOUT_ECN)
 569     OP_EXPECT_NO_FRAME()
 570     OP_RX_PKT_NONE()
 571     OP_TXP_GENERATE_NONE()
 572     OP_END
 573 };
 574
 575 /* 7. 1-RTT, ACK, NEW_TOKEN */
 576 static const struct script_op script_7[] = {
 577     OP_PROVIDE_SECRET(QUIC_ENC_LEVEL_1RTT, QRL_SUITE_AES128GCM, secret_1)
 578     OP_TXP_GENERATE_NONE()
 579     OP_CHECK(schedule_cfq_new_token)
 580     OP_CHECK(schedule_ack)
 581     OP_TXP_GENERATE()
 582     OP_RX_PKT()
 583     OP_EXPECT_DGRAM_LEN(21, 512)
 584     /* ACK must come before NEW_TOKEN */
 585     OP_NEXT_FRAME()
 586     OP_EXPECT_FRAME(OSSL_QUIC_FRAME_TYPE_ACK_WITHOUT_ECN)
 587     OP_NEXT_FRAME()
 588     OP_EXPECT_FRAME(OSSL_QUIC_FRAME_TYPE_NEW_TOKEN)
 589     OP_EXPECT_NO_FRAME()
 590     OP_RX_PKT_NONE()
 591     OP_TXP_GENERATE_NONE()
 592     OP_END
 593 };
 594
 595 /* 8. 1-RTT, CRYPTO */
 596 static const unsigned char crypto_1[] = {
 597     0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09
 598 };
 599
 600 static const struct script_op script_8[] = {
 601     OP_PROVIDE_SECRET(QUIC_ENC_LEVEL_1RTT, QRL_SUITE_AES128GCM, secret_1)
 602     OP_TXP_GENERATE_NONE()
 603     OP_CRYPTO_SEND(QUIC_PN_SPACE_APP, crypto_1)
 604     OP_TXP_GENERATE()
 605     OP_RX_PKT()
 606     OP_EXPECT_DGRAM_LEN(21, 512)
 607     OP_NEXT_FRAME()
 608     OP_EXPECT_FRAME(OSSL_QUIC_FRAME_TYPE_CRYPTO)
 609     OP_EXPECT_NO_FRAME()
 610     OP_RX_PKT_NONE()
 611     OP_TXP_GENERATE_NONE()
 612     OP_END
 613 };
 614
 615 /* 9. 1-RTT, STREAM */
 616 static const unsigned char stream_9[] = {
 617     0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 0x7a, 0x7b
 618 };
 619
 620 static int check_stream_9(struct helper *h)
 621 {
 622     if (!TEST_mem_eq(h->frame.stream.data, (size_t)h->frame.stream.len,
 623                      stream_9, sizeof(stream_9)))
 624         return 0;
 625
 626     return 1;
 627 }
 628
 629 static const struct script_op script_9[] = {
 630     OP_PROVIDE_SECRET(QUIC_ENC_LEVEL_1RTT, QRL_SUITE_AES128GCM, secret_1)
 631     OP_HANDSHAKE_COMPLETE()
 632     OP_TXP_GENERATE_NONE()
 633     OP_STREAM_NEW(42)
 634     OP_STREAM_SEND(42, stream_9)
 635     /* Still no output because of TXFC */
 636     OP_TXP_GENERATE_NONE()
 637     /* Now grant a TXFC budget */
 638     OP_CONN_TXFC_BUMP(1000)
 639     OP_STREAM_TXFC_BUMP(42, 1000)
 640     OP_TXP_GENERATE()
 641     OP_RX_PKT()
 642     OP_EXPECT_DGRAM_LEN(21, 512)
 643     OP_NEXT_FRAME()
 644     OP_EXPECT_FRAME(OSSL_QUIC_FRAME_TYPE_STREAM)
 645     OP_CHECK(check_stream_9)
 646     OP_EXPECT_NO_FRAME()
 647     OP_RX_PKT_NONE()
 648     OP_TXP_GENERATE_NONE()
 649     OP_END
 650 };
 651
 652 /* 10. 1-RTT, STREAM, round robin */
 653 /* The data below is randomly generated data. */
 654 static const unsigned char stream_10a[1300] = {
 655     0x40, 0x0d, 0xb6, 0x0d, 0x25, 0x5f, 0xdd, 0xb9, 0x05, 0x79, 0xa8, 0xe3,
 656     0x79, 0x32, 0xb2, 0xa7, 0x30, 0x6d, 0x29, 0xf6, 0xba, 0x50, 0xbe, 0x83,
 657     0xcb, 0x56, 0xec, 0xd6, 0xc7, 0x80, 0x84, 0xa2, 0x2f, 0xeb, 0xc4, 0x37,
 658     0x40, 0x44, 0xef, 0xd8, 0x78, 0xbb, 0x92, 0x80, 0x22, 0x33, 0xc0, 0xce,
 659     0x33, 0x5b, 0x75, 0x8c, 0xa5, 0x1a, 0x7a, 0x2a, 0xa9, 0x88, 0xaf, 0xf6,
 660     0x3a, 0xe2, 0x5e, 0x60, 0x52, 0x6d, 0xef, 0x7f, 0x2a, 0x9a, 0xaa, 0x17,
 661     0x0e, 0x12, 0x51, 0x82, 0x08, 0x2f, 0x0f, 0x5b, 0xff, 0xf5, 0x7c, 0x7c,
 662     0x89, 0x04, 0xfb, 0xa7, 0x80, 0x4e, 0xda, 0x12, 0x89, 0x01, 0x4a, 0x81,
 663     0x84, 0x78, 0x15, 0xa9, 0x12, 0x28, 0x69, 0x4a, 0x25, 0xe5, 0x8b, 0x69,
 664     0xc2, 0x9f, 0xb6, 0x59, 0x49, 0xe3, 0x53, 0x90, 0xef, 0xc9, 0xb8, 0x40,
 665     0xdd, 0x62, 0x5f, 0x99, 0x68, 0xd2, 0x0a, 0x77, 0xde, 0xf3, 0x11, 0x39,
 666     0x7f, 0x93, 0x8b, 0x81, 0x69, 0x36, 0xa7, 0x76, 0xa4, 0x10, 0x56, 0x51,
 667     0xe5, 0x45, 0x3a, 0x42, 0x49, 0x6c, 0xc6, 0xa0, 0xb4, 0x13, 0x46, 0x59,
 668     0x0e, 0x48, 0x60, 0xc9, 0xff, 0x70, 0x10, 0x8d, 0x6a, 0xf9, 0x5b, 0x94,
 669     0xc2, 0x9e, 0x49, 0x19, 0x56, 0xf2, 0xc1, 0xff, 0x08, 0x3f, 0x9e, 0x26,
 670     0x8e, 0x99, 0x71, 0xc4, 0x25, 0xb1, 0x4e, 0xcc, 0x7e, 0x5f, 0xf0, 0x4e,
 671     0x25, 0xa2, 0x2f, 0x3f, 0x68, 0xaa, 0xcf, 0xbd, 0x19, 0x19, 0x1c, 0x92,
 672     0xa0, 0xb6, 0xb8, 0x32, 0xb1, 0x0b, 0x91, 0x05, 0xa9, 0xf8, 0x1a, 0x4b,
 673     0x74, 0x09, 0xf9, 0x57, 0xd0, 0x1c, 0x38, 0x10, 0x05, 0x54, 0xd8, 0x4e,
 674     0x12, 0x67, 0xcc, 0x43, 0xa3, 0x81, 0xa9, 0x3a, 0x12, 0x57, 0xe7, 0x4b,
 675     0x0e, 0xe5, 0x51, 0xf9, 0x5f, 0xd4, 0x46, 0x73, 0xa2, 0x78, 0xb7, 0x00,
 676     0x24, 0x69, 0x35, 0x10, 0x1e, 0xb8, 0xa7, 0x4a, 0x9b, 0xbc, 0xfc, 0x04,
 677     0x6f, 0x1a, 0xb0, 0x4f, 0x12, 0xc9, 0x2b, 0x3b, 0x94, 0x85, 0x1b, 0x8e,
 678     0xba, 0xac, 0xfd, 0x10, 0x22, 0x68, 0x90, 0x17, 0x13, 0x44, 0x18, 0x2f,
 679     0x33, 0x37, 0x1a, 0x89, 0xc0, 0x2c, 0x14, 0x59, 0xb2, 0xaf, 0xc0, 0x6b,
 680     0xdc, 0x28, 0xe1, 0xe9, 0xc1, 0x0c, 0xb4, 0x80, 0x90, 0xb9, 0x1f, 0x45,
 681     0xb4, 0x63, 0x9a, 0x0e, 0xfa, 0x33, 0xf5, 0x75, 0x3a, 0x4f, 0xc3, 0x8c,
 682     0x70, 0xdb, 0xd7, 0xbf, 0xf6, 0xb8, 0x7f, 0xcc, 0xe5, 0x85, 0xb6, 0xae,
 683     0x25, 0x60, 0x18, 0x5b, 0xf1, 0x51, 0x1a, 0x85, 0xc1, 0x7f, 0xf3, 0xbe,
 684     0xb6, 0x82, 0x38, 0xe3, 0xd2, 0xff, 0x8a, 0xc4, 0xdb, 0x08, 0xe6, 0x96,
 685     0xd5, 0x3d, 0x1f, 0xc5, 0x12, 0x35, 0x45, 0x75, 0x5d, 0x17, 0x4e, 0xe1,
 686     0xb8, 0xc9, 0xf0, 0x45, 0x95, 0x0b, 0x03, 0xcb, 0x85, 0x47, 0xaf, 0xc7,
 687     0x88, 0xb6, 0xc1, 0x2c, 0xb8, 0x9b, 0xe6, 0x8b, 0x51, 0xd5, 0x2e, 0x71,
 688     0xba, 0xc9, 0xa9, 0x37, 0x5e, 0x1c, 0x2c, 0x03, 0xf0, 0xc7, 0xc1, 0xd3,
 689     0x72, 0xaa, 0x4d, 0x19, 0xd6, 0x51, 0x64, 0x12, 0xeb, 0x39, 0xeb, 0x45,
 690     0xe9, 0xb4, 0x84, 0x08, 0xb6, 0x6c, 0xc7, 0x3e, 0xf0, 0x88, 0x64, 0xc2,
 691     0x91, 0xb7, 0xa5, 0x86, 0x66, 0x83, 0xd5, 0xd3, 0x41, 0x24, 0xb2, 0x1c,
 692     0x9a, 0x18, 0x10, 0x0e, 0xa5, 0xc9, 0xef, 0xcd, 0x06, 0xce, 0xa8, 0xaf,
 693     0x22, 0x52, 0x25, 0x0b, 0x99, 0x3d, 0xe9, 0x26, 0xda, 0xa9, 0x47, 0xd1,
 694     0x4b, 0xa6, 0x4c, 0xfc, 0x80, 0xaf, 0x6a, 0x59, 0x4b, 0x35, 0xa4, 0x93,
 695     0x39, 0x5b, 0xfa, 0x91, 0x9d, 0xdf, 0x9d, 0x3c, 0xfb, 0x53, 0xca, 0x18,
 696     0x19, 0xe4, 0xda, 0x95, 0x47, 0x5a, 0x37, 0x59, 0xd7, 0xd2, 0xe4, 0x75,
 697     0x45, 0x0d, 0x03, 0x7f, 0xa0, 0xa9, 0xa0, 0x71, 0x06, 0xb1, 0x9d, 0x46,
 698     0xbd, 0xcf, 0x4a, 0x8b, 0x73, 0xc1, 0x45, 0x5c, 0x00, 0x61, 0xfd, 0xd1,
 699     0xa4, 0xa2, 0x3e, 0xaa, 0xbe, 0x72, 0xf1, 0x7a, 0x1a, 0x76, 0x88, 0x5c,
 700     0x9e, 0x74, 0x6d, 0x2a, 0x34, 0xfc, 0xf7, 0x41, 0x28, 0xe8, 0xa3, 0x43,
 701     0x4d, 0x43, 0x1d, 0x6c, 0x36, 0xb1, 0x45, 0x71, 0x5a, 0x3c, 0xd3, 0x28,
 702     0x44, 0xe4, 0x9b, 0xbf, 0x54, 0x16, 0xc3, 0x99, 0x6c, 0x42, 0xd8, 0x20,
 703     0xb6, 0x20, 0x5f, 0x6e, 0xbc, 0xba, 0x88, 0x5e, 0x2f, 0xa5, 0xd1, 0x82,
 704     0x5c, 0x92, 0xd0, 0x79, 0xfd, 0xcc, 0x61, 0x49, 0xd0, 0x73, 0x92, 0xe6,
 705     0x98, 0xe3, 0x80, 0x7a, 0xf9, 0x56, 0x63, 0x33, 0x19, 0xda, 0x54, 0x13,
 706     0xf0, 0x21, 0xa8, 0x15, 0xf6, 0xb7, 0x43, 0x7c, 0x1c, 0x1e, 0xb1, 0x89,
 707     0x8d, 0xce, 0x20, 0x54, 0x81, 0x80, 0xb5, 0x8f, 0x9b, 0xb1, 0x09, 0x92,
 708     0xdb, 0x25, 0x6f, 0x30, 0x29, 0x08, 0x1a, 0x05, 0x08, 0xf4, 0x83, 0x8b,
 709     0x1e, 0x2d, 0xfd, 0xe4, 0xb2, 0x76, 0xc8, 0x4d, 0xf3, 0xa6, 0x49, 0x5f,
 710     0x2c, 0x99, 0x78, 0xbd, 0x07, 0xef, 0xc8, 0xd9, 0xb5, 0x70, 0x3b, 0x0a,
 711     0xcb, 0xbd, 0xa0, 0xea, 0x15, 0xfb, 0xd1, 0x6e, 0x61, 0x83, 0xcb, 0x90,
 712     0xd0, 0xa3, 0x81, 0x28, 0xdc, 0xd5, 0x84, 0xae, 0x55, 0x28, 0x13, 0x9e,
 713     0xc6, 0xd8, 0xf4, 0x67, 0xd6, 0x0d, 0xd4, 0x69, 0xac, 0xf6, 0x35, 0x95,
 714     0x99, 0x44, 0x26, 0x72, 0x36, 0x55, 0xf9, 0x42, 0xa6, 0x1b, 0x00, 0x93,
 715     0x00, 0x19, 0x2f, 0x70, 0xd3, 0x16, 0x66, 0x4e, 0x80, 0xbb, 0xb6, 0x84,
 716     0xa1, 0x2c, 0x09, 0xfb, 0x41, 0xdf, 0x63, 0xde, 0x62, 0x3e, 0xd0, 0xa8,
 717     0xd8, 0x0c, 0x03, 0x06, 0xa9, 0x82, 0x17, 0x9c, 0xd2, 0xa9, 0xd5, 0x6f,
 718     0xcc, 0xc0, 0xf2, 0x5d, 0xb1, 0xba, 0xf8, 0x2e, 0x37, 0x8b, 0xe6, 0x5d,
 719     0x9f, 0x1b, 0xfb, 0x53, 0x0a, 0x96, 0xbe, 0x69, 0x31, 0x19, 0x8f, 0x44,
 720     0x1b, 0xc2, 0x42, 0x7e, 0x65, 0x12, 0x1d, 0x52, 0x1e, 0xe2, 0xc0, 0x86,
 721     0x70, 0x88, 0xe5, 0xf6, 0x87, 0x5d, 0x03, 0x4b, 0x12, 0x3c, 0x2d, 0xaf,
 722     0x09, 0xf5, 0x4f, 0x82, 0x2e, 0x2e, 0xbe, 0x07, 0xe8, 0x8d, 0x57, 0x6e,
 723     0xc0, 0xeb, 0xf9, 0x37, 0xac, 0x89, 0x01, 0xb7, 0xc6, 0x52, 0x1c, 0x86,
 724     0xe5, 0xbc, 0x1f, 0xbd, 0xde, 0xa2, 0x42, 0xb6, 0x73, 0x85, 0x6f, 0x06,
 725     0x36, 0x56, 0x40, 0x2b, 0xea, 0x16, 0x8c, 0xf4, 0x7b, 0x65, 0x6a, 0xca,
 726     0x3c, 0x56, 0x68, 0x01, 0xe3, 0x9c, 0xbb, 0xb9, 0x45, 0x54, 0xcd, 0x13,
 727     0x74, 0xad, 0x80, 0x40, 0xbc, 0xd0, 0x74, 0xb4, 0x31, 0xe4, 0xca, 0xd5,
 728     0xf8, 0x4f, 0x08, 0x5b, 0xc4, 0x15, 0x1a, 0x51, 0x3b, 0xc6, 0x40, 0xc8,
 729     0xea, 0x76, 0x30, 0x95, 0xb7, 0x76, 0xa4, 0xda, 0x20, 0xdb, 0x75, 0x1c,
 730     0xf4, 0x87, 0x24, 0x29, 0x54, 0xc6, 0x59, 0x0c, 0xf0, 0xed, 0xf5, 0x3d,
 731     0xce, 0x95, 0x23, 0x30, 0x49, 0x91, 0xa7, 0x7b, 0x22, 0xb5, 0xd7, 0x71,
 732     0xb0, 0x60, 0xe1, 0xf0, 0x84, 0x74, 0x0e, 0x2f, 0xa8, 0x79, 0x35, 0xb9,
 733     0x03, 0xb5, 0x2c, 0xdc, 0x60, 0x48, 0x12, 0xd9, 0x14, 0x5a, 0x58, 0x5d,
 734     0x95, 0xc6, 0x47, 0xfd, 0xaf, 0x09, 0xc2, 0x67, 0xa5, 0x09, 0xae, 0xff,
 735     0x4b, 0xd5, 0x6c, 0x2f, 0x1d, 0x33, 0x31, 0xcb, 0xdb, 0xcf, 0xf5, 0xf6,
 736     0xbc, 0x90, 0xb2, 0x15, 0xd4, 0x34, 0xeb, 0xde, 0x0e, 0x8f, 0x3d, 0xea,
 737     0xa4, 0x9b, 0x29, 0x8a, 0xf9, 0x4a, 0xac, 0x38, 0x1e, 0x46, 0xb2, 0x2d,
 738     0xa2, 0x61, 0xc5, 0x99, 0x5e, 0x85, 0x36, 0x85, 0xb0, 0xb1, 0x6b, 0xc4,
 739     0x06, 0x68, 0xc7, 0x9b, 0x54, 0xb9, 0xc8, 0x9d, 0xf3, 0x1a, 0xe0, 0x67,
 740     0x0e, 0x4d, 0x5c, 0x13, 0x54, 0xa4, 0x62, 0x62, 0x6f, 0xae, 0x0e, 0x86,
 741     0xa2, 0xe0, 0x31, 0xc7, 0x72, 0xa1, 0xbb, 0x87, 0x3e, 0x61, 0x96, 0xb7,
 742     0x53, 0xf9, 0x34, 0xcb, 0xfd, 0x6c, 0x67, 0x25, 0x73, 0x61, 0x75, 0x4f,
 743     0xab, 0x37, 0x08, 0xef, 0x35, 0x5a, 0x03, 0xe5, 0x08, 0x43, 0xec, 0xdc,
 744     0xb5, 0x2c, 0x1f, 0xe6, 0xeb, 0xc6, 0x06, 0x0b, 0xed, 0xad, 0x74, 0xf4,
 745     0x55, 0xef, 0xe0, 0x2e, 0x83, 0x00, 0xdb, 0x32, 0xde, 0xe9, 0xe4, 0x2f,
 746     0xf5, 0x20, 0x6d, 0x72, 0x47, 0xf4, 0x68, 0xa6, 0x7f, 0x3e, 0x6a, 0x5a,
 747     0x21, 0x76, 0x31, 0x97, 0xa0, 0xc6, 0x7d, 0x03, 0xf7, 0x27, 0x45, 0x5a,
 748     0x75, 0x03, 0xc1, 0x5c, 0x94, 0x2b, 0x37, 0x9f, 0x46, 0x8f, 0xc3, 0xa7,
 749     0x50, 0xe4, 0xe7, 0x23, 0xf7, 0x20, 0xa2, 0x8e, 0x4b, 0xfd, 0x7a, 0xa7,
 750     0x8a, 0x54, 0x7b, 0x32, 0xef, 0x0e, 0x82, 0xb9, 0xf9, 0x14, 0x62, 0x68,
 751     0x32, 0x9e, 0x55, 0xc0, 0xd8, 0xc7, 0x41, 0x9c, 0x67, 0x95, 0xbf, 0xc3,
 752     0x86, 0x74, 0x70, 0x64, 0x44, 0x23, 0x77, 0x79, 0x82, 0x23, 0x1c, 0xf4,
 753     0xa1, 0x05, 0xd3, 0x98, 0x89, 0xde, 0x7d, 0xb3, 0x5b, 0xef, 0x38, 0xd2,
 754     0x07, 0xbc, 0x5a, 0x69, 0xa3, 0xe4, 0x37, 0x9b, 0x53, 0xff, 0x04, 0x6b,
 755     0xd9, 0xd8, 0x32, 0x89, 0xf7, 0x82, 0x77, 0xcf, 0xe6, 0xff, 0xf4, 0x15,
 756     0x54, 0x91, 0x65, 0x96, 0x49, 0xd7, 0x0a, 0xa4, 0xf3, 0x55, 0x2b, 0xc1,
 757     0x48, 0xc1, 0x7e, 0x56, 0x69, 0x27, 0xf4, 0xd1, 0x47, 0x1f, 0xde, 0x86,
 758     0x15, 0x67, 0x04, 0x9d, 0x41, 0x1f, 0xe8, 0xe1, 0x23, 0xe4, 0x56, 0xb9,
 759     0xdb, 0x4e, 0xe4, 0x84, 0x6c, 0x63, 0x39, 0xad, 0x44, 0x6d, 0x4e, 0x28,
 760     0xcd, 0xf6, 0xac, 0xec, 0xc2, 0xad, 0xcd, 0xc3, 0xed, 0x03, 0x63, 0x5d,
 761     0xef, 0x1d, 0x40, 0x8d, 0x9a, 0x02, 0x67, 0x4b, 0x55, 0xb5, 0xfe, 0x75,
 762     0xb6, 0x53, 0x34, 0x1d, 0x7b, 0x26, 0x23, 0xfe, 0xb9, 0x21, 0xd3, 0xe0,
 763     0xa0, 0x1a, 0x85, 0xe5
 764 };
 765
 766 static const unsigned char stream_10b[1300] = {
 767     0x18, 0x00, 0xd7, 0xfb, 0x12, 0xda, 0xdb, 0x68, 0xeb, 0x38, 0x4d, 0xf6,
 768     0xb2, 0x45, 0x74, 0x4c, 0xcc, 0xe7, 0xa7, 0xc1, 0x26, 0x84, 0x3d, 0xdf,
 769     0x7d, 0xc5, 0xe9, 0xd4, 0x31, 0xa2, 0x51, 0x38, 0x95, 0xe2, 0x68, 0x11,
 770     0x9d, 0xd1, 0x52, 0xb5, 0xef, 0x76, 0xe0, 0x3d, 0x11, 0x50, 0xd7, 0xb2,
 771     0xc1, 0x7d, 0x12, 0xaf, 0x02, 0x52, 0x97, 0x03, 0xf3, 0x2e, 0x54, 0xdf,
 772     0xa0, 0x40, 0x76, 0x52, 0x82, 0x23, 0x3c, 0xbd, 0x20, 0x6d, 0x0a, 0x6f,
 773     0x81, 0xfc, 0x41, 0x9d, 0x2e, 0xa7, 0x2c, 0x78, 0x9c, 0xd8, 0x56, 0xb0,
 774     0x31, 0x35, 0xc8, 0x53, 0xef, 0xf9, 0x43, 0x17, 0xc0, 0x8c, 0x2c, 0x8f,
 775     0x4a, 0x68, 0xe8, 0x9f, 0xbd, 0x3f, 0xf2, 0x18, 0xb8, 0xe6, 0x55, 0xea,
 776     0x2a, 0x37, 0x3e, 0xac, 0xb0, 0x75, 0xd4, 0x75, 0x12, 0x82, 0xec, 0x21,
 777     0xb9, 0xce, 0xe5, 0xc1, 0x62, 0x49, 0xd5, 0xf1, 0xca, 0xd4, 0x32, 0x76,
 778     0x34, 0x5f, 0x3e, 0xc9, 0xb3, 0x54, 0xe4, 0xd0, 0xa9, 0x7d, 0x0c, 0x64,
 779     0x48, 0x0a, 0x74, 0x38, 0x03, 0xd0, 0x20, 0xac, 0xe3, 0x58, 0x3d, 0x4b,
 780     0xa7, 0x46, 0xac, 0x57, 0x63, 0x12, 0x17, 0xcb, 0x96, 0xed, 0xc9, 0x39,
 781     0x64, 0xde, 0xff, 0xc6, 0xb2, 0x40, 0x2c, 0xf9, 0x1d, 0xa6, 0x94, 0x2a,
 782     0x16, 0x4d, 0x7f, 0x22, 0x91, 0x8b, 0xfe, 0x83, 0x77, 0x02, 0x68, 0x62,
 783     0x27, 0x77, 0x2e, 0xe9, 0xce, 0xbc, 0x20, 0xe8, 0xfb, 0xf8, 0x4e, 0x17,
 784     0x07, 0xe1, 0xaa, 0x29, 0xb7, 0x50, 0xcf, 0xb0, 0x6a, 0xcf, 0x01, 0xec,
 785     0xbf, 0xff, 0xb5, 0x9f, 0x00, 0x64, 0x80, 0xbb, 0xa6, 0xe4, 0xa2, 0x1e,
 786     0xe4, 0xf8, 0xa3, 0x0d, 0xc7, 0x65, 0x45, 0xb7, 0x01, 0x33, 0x80, 0x37,
 787     0x11, 0x16, 0x34, 0xc1, 0x06, 0xc5, 0xd3, 0xc4, 0x70, 0x62, 0x75, 0xd8,
 788     0xa3, 0xba, 0x84, 0x9f, 0x81, 0x9f, 0xda, 0x01, 0x83, 0x42, 0x84, 0x05,
 789     0x69, 0x68, 0xb0, 0x74, 0x73, 0x0f, 0x68, 0x39, 0xd3, 0x11, 0xc5, 0x55,
 790     0x3e, 0xf2, 0xb7, 0xf4, 0xa6, 0xed, 0x0b, 0x50, 0xbe, 0x44, 0xf8, 0x67,
 791     0x48, 0x46, 0x5e, 0x71, 0x07, 0xcf, 0xca, 0x8a, 0xbc, 0xa4, 0x3c, 0xd2,
 792     0x4a, 0x80, 0x2e, 0x4f, 0xc5, 0x3b, 0x61, 0xc1, 0x7e, 0x93, 0x9e, 0xe0,
 793     0x05, 0xfb, 0x10, 0xe8, 0x53, 0xff, 0x16, 0x5e, 0x18, 0xe0, 0x9f, 0x39,
 794     0xbf, 0xaa, 0x80, 0x6d, 0xb7, 0x9f, 0x51, 0x91, 0xa0, 0xf6, 0xce, 0xad,
 795     0xed, 0x56, 0x15, 0xb9, 0x12, 0x57, 0x60, 0xa6, 0xae, 0x54, 0x6e, 0x36,
 796     0xf3, 0xe0, 0x05, 0xd8, 0x3e, 0x6d, 0x08, 0x36, 0xc9, 0x79, 0x64, 0x51,
 797     0x63, 0x92, 0xa8, 0xa1, 0xbf, 0x55, 0x26, 0x80, 0x75, 0x44, 0x33, 0x33,
 798     0xfb, 0xb7, 0xec, 0xf9, 0xc6, 0x01, 0xf9, 0xd5, 0x93, 0xfc, 0xb7, 0x43,
 799     0xa2, 0x38, 0x0d, 0x17, 0x75, 0x67, 0xec, 0xc9, 0x98, 0xd6, 0x25, 0xe6,
 800     0xb9, 0xed, 0x61, 0xa4, 0xee, 0x2c, 0xda, 0x27, 0xbd, 0xff, 0x86, 0x1e,
 801     0x45, 0x64, 0xfe, 0xcf, 0x0c, 0x9b, 0x7b, 0x75, 0x5f, 0xf1, 0xe0, 0xba,
 802     0x77, 0x8c, 0x03, 0x8f, 0xb4, 0x3a, 0xb6, 0x9c, 0xda, 0x9a, 0x83, 0xcb,
 803     0xe9, 0xcb, 0x3f, 0xf4, 0x10, 0x99, 0x5b, 0xe1, 0x19, 0x8f, 0x6b, 0x95,
 804     0x50, 0xe6, 0x78, 0xc9, 0x35, 0xb6, 0x87, 0xd8, 0x9e, 0x17, 0x30, 0x96,
 805     0x70, 0xa3, 0x04, 0x69, 0x1c, 0xa2, 0x6c, 0xd4, 0x88, 0x48, 0x44, 0x14,
 806     0x94, 0xd4, 0xc9, 0x4d, 0xe3, 0x82, 0x7e, 0x62, 0xf0, 0x0a, 0x18, 0x4d,
 807     0xd0, 0xd6, 0x63, 0xa3, 0xdf, 0xea, 0x28, 0xf4, 0x00, 0x75, 0x70, 0x78,
 808     0x08, 0x70, 0x3f, 0xff, 0x84, 0x86, 0x72, 0xea, 0x4f, 0x15, 0x8c, 0x17,
 809     0x60, 0x5f, 0xa1, 0x50, 0xa0, 0xfc, 0x6f, 0x8a, 0x46, 0xfc, 0x01, 0x8d,
 810     0x7c, 0xdc, 0x69, 0x6a, 0xd3, 0x74, 0x69, 0x76, 0x77, 0xdd, 0xe4, 0x9c,
 811     0x49, 0x1e, 0x6f, 0x7d, 0x31, 0x14, 0xd9, 0xe9, 0xe7, 0x17, 0x66, 0x82,
 812     0x1b, 0xf1, 0x0f, 0xe2, 0xba, 0xd2, 0x28, 0xd1, 0x6f, 0x48, 0xc7, 0xac,
 813     0x08, 0x4e, 0xee, 0x94, 0x66, 0x99, 0x34, 0x16, 0x5d, 0x95, 0xae, 0xe3,
 814     0x59, 0x79, 0x7f, 0x8e, 0x9f, 0xe3, 0xdb, 0xff, 0xdc, 0x4d, 0xb0, 0xbf,
 815     0xf9, 0xf3, 0x3e, 0xec, 0xcf, 0x50, 0x3d, 0x2d, 0xba, 0x94, 0x1f, 0x1a,
 816     0xab, 0xa4, 0xf4, 0x67, 0x43, 0x7e, 0xb9, 0x65, 0x20, 0x13, 0xb1, 0xd9,
 817     0x88, 0x4a, 0x24, 0x13, 0x84, 0x86, 0xae, 0x2b, 0x0c, 0x6c, 0x7e, 0xd4,
 818     0x25, 0x6e, 0xaa, 0x8d, 0x0c, 0x54, 0x99, 0xde, 0x1d, 0xac, 0x8c, 0x5c,
 819     0x73, 0x94, 0xd9, 0x75, 0xcb, 0x5a, 0x54, 0x3d, 0xeb, 0xff, 0xc1, 0x95,
 820     0x53, 0xb5, 0x39, 0xf7, 0xe5, 0xf1, 0x77, 0xd1, 0x42, 0x82, 0x4b, 0xb0,
 821     0xab, 0x19, 0x28, 0xff, 0x53, 0x28, 0x87, 0x46, 0xc6, 0x6f, 0x05, 0x06,
 822     0xa6, 0x0c, 0x97, 0x93, 0x68, 0x38, 0xe1, 0x61, 0xed, 0xf8, 0x90, 0x13,
 823     0xa3, 0x6f, 0xf2, 0x08, 0x37, 0xd7, 0x05, 0x25, 0x34, 0x43, 0x57, 0x72,
 824     0xfd, 0x6c, 0xc2, 0x19, 0x26, 0xe7, 0x50, 0x30, 0xb8, 0x6d, 0x09, 0x71,
 825     0x83, 0x75, 0xd4, 0x11, 0x25, 0x29, 0xc6, 0xee, 0xb2, 0x51, 0x1c, 0x1c,
 826     0x9e, 0x2d, 0x09, 0xb9, 0x73, 0x2b, 0xbf, 0xda, 0xc8, 0x1e, 0x2b, 0xe5,
 827     0x3f, 0x1e, 0x63, 0xe9, 0xc0, 0x6d, 0x04, 0x3a, 0x48, 0x61, 0xa8, 0xc6,
 828     0x16, 0x8d, 0x69, 0xc0, 0x67, 0x0c, 0x3b, 0xc4, 0x05, 0x36, 0xa1, 0x30,
 829     0x62, 0x92, 0x4d, 0x44, 0x31, 0x66, 0x46, 0xda, 0xef, 0x0f, 0x4e, 0xfb,
 830     0x78, 0x6a, 0xa9, 0x5b, 0xf8, 0x56, 0x26, 0x74, 0x16, 0xab, 0x17, 0x93,
 831     0x3c, 0x36, 0xbb, 0xa2, 0xbf, 0xad, 0xba, 0xb1, 0xfe, 0xc4, 0x9f, 0x75,
 832     0x47, 0x1e, 0x99, 0x7e, 0x32, 0xe8, 0xd4, 0x6c, 0xa4, 0xf8, 0xd2, 0xe4,
 833     0xb2, 0x51, 0xbb, 0xb2, 0xd7, 0xce, 0x94, 0xaf, 0x7f, 0xe6, 0x2c, 0x13,
 834     0xae, 0xd2, 0x29, 0x30, 0x7b, 0xfd, 0x25, 0x61, 0xf9, 0xe8, 0x35, 0x2d,
 835     0x1a, 0xc9, 0x81, 0xa5, 0xfe, 0xce, 0xf6, 0x17, 0xc5, 0xfb, 0x8c, 0x79,
 836     0x67, 0xa8, 0x5f, 0x5c, 0x31, 0xbc, 0xfc, 0xf3, 0x6b, 0xd3, 0x0d, 0xe0,
 837     0x62, 0xab, 0x86, 0xc3, 0x17, 0x5a, 0xba, 0x97, 0x86, 0x8f, 0x65, 0xd6,
 838     0xbd, 0x0c, 0xa1, 0xfb, 0x7f, 0x7c, 0xdc, 0xcb, 0x94, 0x30, 0x0b, 0x04,
 839     0x54, 0xc4, 0x31, 0xa1, 0xca, 0x1e, 0xc5, 0xf0, 0xb6, 0x08, 0xd7, 0x2e,
 840     0xa1, 0x90, 0x41, 0xce, 0xd9, 0xef, 0x3a, 0x58, 0x01, 0x1a, 0x73, 0x18,
 841     0xad, 0xdc, 0x20, 0x25, 0x95, 0x1a, 0xfe, 0x61, 0xf1, 0x58, 0x32, 0x8b,
 842     0x43, 0x59, 0xd6, 0x21, 0xdb, 0xa9, 0x8e, 0x54, 0xe6, 0x21, 0xcf, 0xd3,
 843     0x6b, 0x59, 0x29, 0x9b, 0x3e, 0x6c, 0x7f, 0xe2, 0x29, 0x72, 0x8c, 0xd1,
 844     0x3e, 0x9a, 0x84, 0x98, 0xb0, 0xf3, 0x20, 0x30, 0x34, 0x71, 0xa7, 0x5b,
 845     0xf0, 0x26, 0xe1, 0xf4, 0x76, 0x65, 0xc9, 0xd7, 0xe4, 0xb9, 0x25, 0x48,
 846     0xc2, 0x7e, 0xa6, 0x0b, 0x0d, 0x05, 0x68, 0xa1, 0x96, 0x61, 0x0b, 0x4c,
 847     0x2f, 0x1a, 0xe3, 0x56, 0x71, 0x89, 0x48, 0x66, 0xd8, 0xd0, 0x69, 0x37,
 848     0x7a, 0xdf, 0xdb, 0xed, 0xad, 0x82, 0xaa, 0x40, 0x25, 0x47, 0x3e, 0x75,
 849     0xa6, 0x0e, 0xf5, 0x2f, 0xa7, 0x4e, 0x97, 0xa2, 0x5f, 0x01, 0x99, 0x48,
 850     0x3a, 0x63, 0x18, 0x20, 0x61, 0x72, 0xe4, 0xcf, 0x4b, 0x3b, 0x99, 0x36,
 851     0xe1, 0xf3, 0xbf, 0xae, 0x2b, 0x6b, 0xa1, 0x94, 0xa0, 0x15, 0x94, 0xd6,
 852     0xe0, 0xba, 0x71, 0xa2, 0x85, 0xa0, 0x8c, 0x5e, 0x58, 0xe2, 0xde, 0x6b,
 853     0x08, 0x68, 0x90, 0x82, 0x71, 0x8d, 0xfd, 0x12, 0xa2, 0x49, 0x87, 0x70,
 854     0xee, 0x2a, 0x08, 0xe2, 0x26, 0xaf, 0xeb, 0x85, 0x35, 0xd2, 0x0e, 0xfd,
 855     0x2b, 0x6f, 0xc0, 0xfe, 0x41, 0xbb, 0xd7, 0x0a, 0xa3, 0x8d, 0x8b, 0xec,
 856     0x44, 0x9f, 0x46, 0x59, 0x4d, 0xac, 0x04, 0x1e, 0xde, 0x10, 0x7b, 0x17,
 857     0x0a, 0xb0, 0xcc, 0x26, 0x0c, 0xa9, 0x3c, 0x5f, 0xd8, 0xe6, 0x52, 0xd3,
 858     0xfd, 0x0b, 0x66, 0x75, 0x06, 0x84, 0x23, 0x64, 0x2b, 0x80, 0x68, 0xf9,
 859     0xcb, 0xcd, 0x04, 0x07, 0xf7, 0xe0, 0x07, 0xb4, 0xc6, 0xa0, 0x08, 0xd0,
 860     0x76, 0x16, 0x77, 0xd8, 0x48, 0xf0, 0x45, 0x4e, 0xe2, 0xf2, 0x88, 0xcd,
 861     0x0f, 0xbd, 0x7d, 0xb6, 0xbe, 0x4e, 0x9e, 0x5d, 0x6c, 0x47, 0x26, 0x34,
 862     0x94, 0xfb, 0xc5, 0x4f, 0x5c, 0xb5, 0xb5, 0xfc, 0x99, 0x34, 0x71, 0xe5,
 863     0xe1, 0x36, 0x0c, 0xd2, 0x95, 0xb8, 0x93, 0x3c, 0x5d, 0x2d, 0x71, 0x55,
 864     0x0b, 0x96, 0x4e, 0x9f, 0x07, 0x9a, 0x38, 0x9a, 0xcc, 0x24, 0xb5, 0xac,
 865     0x05, 0x8b, 0x1c, 0x61, 0xd4, 0xf2, 0xdf, 0x9e, 0x11, 0xe3, 0x7d, 0x64,
 866     0x2f, 0xe5, 0x13, 0xd4, 0x0a, 0xe9, 0x32, 0x26, 0xa8, 0x93, 0x21, 0x59,
 867     0xf3, 0x41, 0x48, 0x0a, 0xbd, 0x59, 0x8f, 0xf8, 0x72, 0xab, 0xd3, 0x65,
 868     0x8e, 0xdc, 0xaa, 0x0c, 0xc0, 0x01, 0x36, 0xb7, 0xf5, 0x84, 0x27, 0x9a,
 869     0x98, 0x89, 0x73, 0x3a, 0xeb, 0x55, 0x15, 0xc9, 0x3d, 0xe1, 0xf8, 0xea,
 870     0xf6, 0x11, 0x28, 0xe0, 0x80, 0x93, 0xcc, 0xba, 0xe1, 0xf1, 0x81, 0xbc,
 871     0xa4, 0x30, 0xbc, 0x98, 0xe8, 0x9e, 0x8d, 0x17, 0x7e, 0xb7, 0xb1, 0x27,
 872     0x6f, 0xcf, 0x9c, 0x0d, 0x1d, 0x01, 0xea, 0x45, 0xc0, 0x90, 0xda, 0x53,
 873     0xf6, 0xde, 0xdf, 0x12, 0xa1, 0x23, 0x3d, 0x92, 0x89, 0x77, 0xa7, 0x2a,
 874     0xe7, 0x45, 0x24, 0xdd, 0xf2, 0x17, 0x10, 0xca, 0x6e, 0x14, 0xb2, 0x77,
 875     0x08, 0xc4, 0x18, 0xcd
 876 };
 877
 878 static uint64_t stream_10a_off, stream_10b_off;
 879
 880 static int check_stream_10a(struct helper *h)
 881 {
 882     /*
 883      * Must have filled or almost filled the packet (using default MDPL of
 884      * 1200).
 885      */
 886     if (!TEST_uint64_t_ge(h->frame.stream.len, 1150)
 887         || !TEST_uint64_t_le(h->frame.stream.len, 1200))
 888         return 0;
 889
 890     if (!TEST_mem_eq(h->frame.stream.data, (size_t)h->frame.stream.len,
 891                      stream_10a, (size_t)h->frame.stream.len))
 892         return 0;
 893
 894     stream_10a_off = h->frame.stream.offset + h->frame.stream.len;
 895     return 1;
 896 }
 897
 898 static int check_stream_10b(struct helper *h)
 899 {
 900     if (!TEST_uint64_t_ge(h->frame.stream.len, 1150)
 901         || !TEST_uint64_t_le(h->frame.stream.len, 1200))
 902         return 0;
 903
 904     if (!TEST_mem_eq(h->frame.stream.data, (size_t)h->frame.stream.len,
 905                      stream_10b, (size_t)h->frame.stream.len))
 906         return 0;
 907
 908     stream_10b_off = h->frame.stream.offset + h->frame.stream.len;
 909     return 1;
 910 }
 911
 912 static int check_stream_10c(struct helper *h)
 913 {
 914     if (!TEST_uint64_t_ge(h->frame.stream.len, 5)
 915         || !TEST_uint64_t_le(h->frame.stream.len, 200))
 916         return 0;
 917
 918     if (!TEST_mem_eq(h->frame.stream.data, (size_t)h->frame.stream.len,
 919                      stream_10a + stream_10a_off, (size_t)h->frame.stream.len))
 920         return 0;
 921
 922     return 1;
 923 }
 924
 925 static int check_stream_10d(struct helper *h)
 926 {
 927     if (!TEST_uint64_t_ge(h->frame.stream.len, 5)
 928         || !TEST_uint64_t_le(h->frame.stream.len, 200))
 929         return 0;
 930
 931     if (!TEST_mem_eq(h->frame.stream.data, (size_t)h->frame.stream.len,
 932                      stream_10b + stream_10b_off, (size_t)h->frame.stream.len))
 933         return 0;
 934
 935     return 1;
 936 }
 937
 938 static const struct script_op script_10[] = {
 939     OP_PROVIDE_SECRET(QUIC_ENC_LEVEL_1RTT, QRL_SUITE_AES128GCM, secret_1)
 940     OP_HANDSHAKE_COMPLETE()
 941     OP_TXP_GENERATE_NONE()
 942     OP_STREAM_NEW(42)
 943     OP_STREAM_NEW(43)
 944     OP_CONN_TXFC_BUMP(10000)
 945     OP_STREAM_TXFC_BUMP(42, 5000)
 946     OP_STREAM_TXFC_BUMP(43, 5000)
 947     OP_STREAM_SEND(42, stream_10a)
 948     OP_STREAM_SEND(43, stream_10b)
 949
 950     /* First packet containing data from stream 42 */
 951     OP_TXP_GENERATE()
 952     OP_RX_PKT()
 953     OP_EXPECT_DGRAM_LEN(1100, 1200)
 954     OP_NEXT_FRAME()
 955     OP_EXPECT_FRAME(OSSL_QUIC_FRAME_TYPE_STREAM)
 956     OP_CHECK(check_stream_10a)
 957     OP_EXPECT_NO_FRAME()
 958
 959     /* Second packet containing data from stream 43 */
 960     OP_TXP_GENERATE()
 961     OP_RX_PKT()
 962     OP_EXPECT_DGRAM_LEN(1100, 1200)
 963     OP_NEXT_FRAME()
 964     OP_EXPECT_FRAME(OSSL_QUIC_FRAME_TYPE_STREAM)
 965     OP_CHECK(check_stream_10b)
 966     OP_EXPECT_NO_FRAME()
 967
 968     /* Third packet containing data from stream 42 */
 969     OP_TXP_GENERATE()
 970     OP_RX_PKT()
 971     OP_EXPECT_DGRAM_LEN(200, 500)
 972     OP_NEXT_FRAME()
 973     OP_EXPECT_FRAME(OSSL_QUIC_FRAME_TYPE_STREAM_OFF_LEN)
 974     OP_CHECK(check_stream_10c)
 975     OP_NEXT_FRAME()
 976     OP_EXPECT_FRAME(OSSL_QUIC_FRAME_TYPE_STREAM_OFF)
 977     OP_CHECK(check_stream_10d)
 978     OP_EXPECT_NO_FRAME()
 979
 980     OP_RX_PKT_NONE()
 981     OP_TXP_GENERATE_NONE()
 982
 983     OP_END
 984 };
 985
 986 /* 11. Initial, CRYPTO */
 987 static const struct script_op script_11[] = {
 988     OP_PROVIDE_SECRET(QUIC_ENC_LEVEL_INITIAL, QRL_SUITE_AES128GCM, secret_1)
 989     OP_TXP_GENERATE_NONE()
 990     OP_CRYPTO_SEND(QUIC_PN_SPACE_INITIAL, crypto_1)
 991     OP_TXP_GENERATE()
 992     OP_RX_PKT()
 993     OP_EXPECT_DGRAM_LEN(1200, 1200)
 994     OP_NEXT_FRAME()
 995     OP_EXPECT_FRAME(OSSL_QUIC_FRAME_TYPE_CRYPTO)
 996     OP_EXPECT_NO_FRAME()
 997     OP_RX_PKT_NONE()
 998     OP_TXP_GENERATE_NONE()
 999     OP_END
1000 };
1001
1002 /* 12. 1-RTT, STOP_SENDING */
1003 static int check_stream_12(struct helper *h)
1004 {
1005     if (!TEST_uint64_t_eq(h->frame.stop_sending.stream_id, 42)
1006         || !TEST_uint64_t_eq(h->frame.stop_sending.app_error_code, 4568))
1007         return 0;
1008
1009     return 1;
1010 }
1011
1012 static const struct script_op script_12[] = {
1013     OP_PROVIDE_SECRET(QUIC_ENC_LEVEL_1RTT, QRL_SUITE_AES128GCM, secret_1)
1014     OP_HANDSHAKE_COMPLETE()
1015     OP_TXP_GENERATE_NONE()
1016     OP_STREAM_NEW(42)
1017     OP_STOP_SENDING(42, 4568)
1018     OP_TXP_GENERATE()
1019     OP_RX_PKT()
1020     OP_EXPECT_DGRAM_LEN(21, 128)
1021     OP_NEXT_FRAME()
1022     OP_EXPECT_FRAME(OSSL_QUIC_FRAME_TYPE_STOP_SENDING)
1023     OP_CHECK(check_stream_12)
1024     OP_EXPECT_NO_FRAME()
1025     OP_RX_PKT_NONE()
1026     OP_TXP_GENERATE_NONE()
1027     OP_END
1028 };
1029
1030 /* 13. 1-RTT, RESET_STREAM */
1031 static const unsigned char stream_13[] = {
1032     0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 0x7a, 0x7b
1033 };
1034
1035 static ossl_unused int check_stream_13(struct helper *h)
1036 {
1037     if (!TEST_uint64_t_eq(h->frame.reset_stream.stream_id, 42)
1038         || !TEST_uint64_t_eq(h->frame.reset_stream.app_error_code, 4568)
1039         || !TEST_uint64_t_eq(h->frame.reset_stream.final_size, 0))
1040         return 0;
1041
1042     return 1;
1043 }
1044
1045 static const struct script_op script_13[] = {
1046     OP_PROVIDE_SECRET(QUIC_ENC_LEVEL_1RTT, QRL_SUITE_AES128GCM, secret_1)
1047     OP_HANDSHAKE_COMPLETE()
1048     OP_TXP_GENERATE_NONE()
1049     OP_STREAM_NEW(42)
1050     OP_CONN_TXFC_BUMP(8)
1051     OP_STREAM_TXFC_BUMP(42, 8)
1052     OP_STREAM_SEND(42, stream_13)
1053     OP_RESET_STREAM(42, 4568)
1054     OP_TXP_GENERATE()
1055     OP_RX_PKT()
1056     OP_EXPECT_DGRAM_LEN(21, 128)
1057     OP_NEXT_FRAME()
1058     OP_EXPECT_FRAME(OSSL_QUIC_FRAME_TYPE_RESET_STREAM)
1059     OP_CHECK(check_stream_13)
1060     OP_NEXT_FRAME()
1061     OP_EXPECT_NO_FRAME()
1062     OP_RX_PKT_NONE()
1063     OP_TXP_GENERATE_NONE()
1064     OP_END
1065 };
1066
1067 /* 14. 1-RTT, CONNECTION_CLOSE */
1068 static int gen_conn_close(struct helper *h)
1069 {
1070     OSSL_QUIC_FRAME_CONN_CLOSE f = {0};
1071
1072     f.error_code     = 2345;
1073     f.frame_type     = OSSL_QUIC_FRAME_TYPE_HANDSHAKE_DONE;
1074     f.reason         = "Reason string";
1075     f.reason_len     = strlen(f.reason);
1076
1077     if (!TEST_true(ossl_quic_tx_packetiser_schedule_conn_close(h->txp, &f)))
1078         return 0;
1079
1080     return 1;
1081 }
1082
1083 static int check_14(struct helper *h)
1084 {
1085     if (!TEST_int_eq(h->frame.conn_close.is_app, 0)
1086         || !TEST_uint64_t_eq(h->frame.conn_close.frame_type,
1087                              OSSL_QUIC_FRAME_TYPE_HANDSHAKE_DONE)
1088         || !TEST_uint64_t_eq(h->frame.conn_close.error_code, 2345)
1089         || !TEST_mem_eq(h->frame.conn_close.reason, h->frame.conn_close.reason_len,
1090                         "Reason string", 13))
1091         return 0;
1092
1093     return 1;
1094 }
1095
1096 static const struct script_op script_14[] = {
1097     OP_PROVIDE_SECRET(QUIC_ENC_LEVEL_1RTT, QRL_SUITE_AES128GCM, secret_1)
1098     OP_HANDSHAKE_COMPLETE()
1099     OP_TXP_GENERATE_NONE()
1100     OP_CHECK(gen_conn_close)
1101     OP_TXP_GENERATE()
1102     OP_RX_PKT()
1103     OP_EXPECT_DGRAM_LEN(21, 512)
1104     OP_NEXT_FRAME()
1105     OP_EXPECT_FRAME(OSSL_QUIC_FRAME_TYPE_CONN_CLOSE_TRANSPORT)
1106     OP_CHECK(check_14)
1107     OP_EXPECT_NO_FRAME()
1108     OP_RX_PKT_NONE()
1109     OP_END
1110 };
1111
1112 /* 15. INITIAL, Anti-Deadlock Probe Simulation */
1113 static int gen_probe_initial(struct helper *h)
1114 {
1115     OSSL_ACKM_PROBE_INFO *probe = ossl_ackm_get0_probe_request(h->args.ackm);
1116
1117     /*
1118      * Pretend the ACKM asked for an anti-deadlock Initial probe.
1119      * We test output of this in the ACKM unit tests.
1120      */
1121     ++probe->anti_deadlock_initial;
1122     return 1;
1123 }
1124
1125 static const struct script_op script_15[] = {
1126     OP_PROVIDE_SECRET(QUIC_ENC_LEVEL_INITIAL, QRL_SUITE_AES128GCM, secret_1)
1127     OP_TXP_GENERATE_NONE()
1128     OP_CHECK(gen_probe_initial)
1129     OP_TXP_GENERATE()
1130     OP_RX_PKT()
1131     OP_EXPECT_DGRAM_LEN(1200, 1200)
1132     OP_NEXT_FRAME()
1133     OP_EXPECT_FRAME(OSSL_QUIC_FRAME_TYPE_PING)
1134     OP_EXPECT_NO_FRAME()
1135     OP_RX_PKT_NONE()
1136     OP_TXP_GENERATE_NONE()
1137     OP_END
1138 };
1139
1140 /* 16. HANDSHAKE, Anti-Deadlock Probe Simulation */
1141 static int gen_probe_handshake(struct helper *h)
1142 {
1143     OSSL_ACKM_PROBE_INFO *probe = ossl_ackm_get0_probe_request(h->args.ackm);
1144
1145     /*
1146      * Pretend the ACKM asked for an anti-deadlock Handshake probe.
1147      * We test output of this in the ACKM unit tests.
1148      */
1149     ++probe->anti_deadlock_handshake;
1150     return 1;
1151 }
1152
1153 static const struct script_op script_16[] = {
1154     OP_DISCARD_EL(QUIC_ENC_LEVEL_INITIAL)
1155     OP_PROVIDE_SECRET(QUIC_ENC_LEVEL_HANDSHAKE, QRL_SUITE_AES128GCM, secret_1)
1156     OP_TXP_GENERATE_NONE()
1157     OP_CHECK(gen_probe_handshake)
1158     OP_TXP_GENERATE()
1159     OP_RX_PKT()
1160     OP_EXPECT_DGRAM_LEN(21, 512)
1161     OP_NEXT_FRAME()
1162     OP_EXPECT_FRAME(OSSL_QUIC_FRAME_TYPE_PING)
1163     OP_EXPECT_NO_FRAME()
1164     OP_RX_PKT_NONE()
1165     OP_TXP_GENERATE_NONE()
1166     OP_END
1167 };
1168
1169 /* 17. 1-RTT, Probe Simulation */
1170 static int gen_probe_1rtt(struct helper *h)
1171 {
1172     OSSL_ACKM_PROBE_INFO *probe = ossl_ackm_get0_probe_request(h->args.ackm);
1173
1174     /*
1175      * Pretend the ACKM asked for a 1-RTT PTO probe.
1176      * We test output of this in the ACKM unit tests.
1177      */
1178     ++probe->pto[QUIC_PN_SPACE_APP];
1179     return 1;
1180 }
1181
1182 static const struct script_op script_17[] = {
1183     OP_DISCARD_EL(QUIC_ENC_LEVEL_INITIAL)
1184     OP_DISCARD_EL(QUIC_ENC_LEVEL_HANDSHAKE)
1185     OP_PROVIDE_SECRET(QUIC_ENC_LEVEL_1RTT, QRL_SUITE_AES128GCM, secret_1)
1186     OP_TXP_GENERATE_NONE()
1187     OP_CHECK(gen_probe_1rtt)
1188     OP_TXP_GENERATE()
1189     OP_RX_PKT()
1190     OP_EXPECT_DGRAM_LEN(21, 512)
1191     OP_NEXT_FRAME()
1192     OP_EXPECT_FRAME(OSSL_QUIC_FRAME_TYPE_PING)
1193     OP_EXPECT_NO_FRAME()
1194     OP_RX_PKT_NONE()
1195     OP_TXP_GENERATE_NONE()
1196     OP_END
1197 };
1198
1199 static const struct script_op *const scripts[] = {
1200     script_1,
1201     script_2,
1202     script_3,
1203     script_4,
1204     script_5,
1205     script_6,
1206     script_7,
1207     script_8,
1208     script_9,
1209     script_10,
1210     script_11,
1211     script_12,
1212     script_13,
1213     script_14,
1214     script_15,
1215     script_16,
1216     script_17
1217 };
1218
1219 static void skip_padding(struct helper *h)
1220 {
1221     uint64_t frame_type;
1222
1223     if (!ossl_quic_wire_peek_frame_header(&h->pkt, &frame_type, NULL))
1224         return; /* EOF */
1225
1226     if (frame_type == OSSL_QUIC_FRAME_TYPE_PADDING)
1227         ossl_quic_wire_decode_padding(&h->pkt);
1228 }
1229
1230 static int run_script(int script_idx, const struct script_op *script)
1231 {
1232     int testresult = 0, have_helper = 0;
1233     QUIC_TXP_STATUS status;
1234     struct helper h;
1235     const struct script_op *op;
1236     size_t opn = 0;
1237
1238     if (!helper_init(&h))
1239         goto err;
1240
1241     have_helper = 1;
1242     for (op = script, opn = 0; op->opcode != OPK_END; ++op, ++opn) {
1243         switch (op->opcode) {
1244         case OPK_TXP_GENERATE:
1245             if (!TEST_int_eq(ossl_quic_tx_packetiser_generate(h.txp, &status),
1246                              TX_PACKETISER_RES_SENT_PKT))
1247                 goto err;
1248
1249             ossl_qtx_finish_dgram(h.args.qtx);
1250             ossl_qtx_flush_net(h.args.qtx);
1251             break;
1252         case OPK_TXP_GENERATE_NONE:
1253             if (!TEST_int_eq(ossl_quic_tx_packetiser_generate(h.txp, &status),
1254                              TX_PACKETISER_RES_NO_PKT))
1255                 goto err;
1256
1257             break;
1258         case OPK_RX_PKT:
1259             ossl_quic_demux_pump(h.demux);
1260             ossl_qrx_pkt_release(h.qrx_pkt);
1261             h.qrx_pkt = NULL;
1262             if (!TEST_true(ossl_qrx_read_pkt(h.qrx, &h.qrx_pkt)))
1263                 goto err;
1264             if (!TEST_true(PACKET_buf_init(&h.pkt,
1265                                            h.qrx_pkt->hdr->data,
1266                                            h.qrx_pkt->hdr->len)))
1267                 goto err;
1268             h.frame_type = UINT64_MAX;
1269             break;
1270         case OPK_RX_PKT_NONE:
1271             ossl_quic_demux_pump(h.demux);
1272             if (!TEST_false(ossl_qrx_read_pkt(h.qrx, &h.qrx_pkt)))
1273                 goto err;
1274             h.frame_type = UINT64_MAX;
1275             break;
1276         case OPK_EXPECT_DGRAM_LEN:
1277             if (!TEST_size_t_ge(h.qrx_pkt->datagram_len, (size_t)op->arg0)
1278                 || !TEST_size_t_le(h.qrx_pkt->datagram_len, (size_t)op->arg1))
1279                 goto err;
1280             break;
1281         case OPK_EXPECT_FRAME:
1282             if (!TEST_uint64_t_eq(h.frame_type, op->arg0))
1283                 goto err;
1284             break;
1285         case OPK_EXPECT_INITIAL_TOKEN:
1286             if (!TEST_mem_eq(h.qrx_pkt->hdr->token, h.qrx_pkt->hdr->token_len,
1287                              op->buf, (size_t)op->arg0))
1288                 goto err;
1289             break;
1290         case OPK_EXPECT_HDR:
1291             if (!TEST_true(cmp_pkt_hdr(h.qrx_pkt->hdr, op->buf,
1292                                        NULL, 0, 0)))
1293                 goto err;
1294             break;
1295         case OPK_CHECK:
1296             if (!TEST_true(op->check_func(&h)))
1297                 goto err;
1298             break;
1299         case OPK_NEXT_FRAME:
1300             skip_padding(&h);
1301             if (!ossl_quic_wire_peek_frame_header(&h.pkt, &h.frame_type, NULL)) {
1302                 h.frame_type = UINT64_MAX;
1303                 break;
1304             }
1305
1306             switch (h.frame_type) {
1307             case OSSL_QUIC_FRAME_TYPE_HANDSHAKE_DONE:
1308                 if (!TEST_true(ossl_quic_wire_decode_frame_handshake_done(&h.pkt)))
1309                     goto err;
1310                 break;
1311             case OSSL_QUIC_FRAME_TYPE_PING:
1312                 if (!TEST_true(ossl_quic_wire_decode_frame_ping(&h.pkt)))
1313                     goto err;
1314                 break;
1315             case OSSL_QUIC_FRAME_TYPE_MAX_DATA:
1316                 if (!TEST_true(ossl_quic_wire_decode_frame_max_data(&h.pkt,
1317                                                                     &h.frame.max_data)))
1318                     goto err;
1319                 break;
1320             case OSSL_QUIC_FRAME_TYPE_NEW_CONN_ID:
1321                 if (!TEST_true(ossl_quic_wire_decode_frame_new_conn_id(&h.pkt,
1322                                                                        &h.frame.new_conn_id)))
1323                     goto err;
1324                 break;
1325             case OSSL_QUIC_FRAME_TYPE_NEW_TOKEN:
1326                 if (!TEST_true(ossl_quic_wire_decode_frame_new_token(&h.pkt,
1327                                                                      &h.frame.new_token.token,
1328                                                                      &h.frame.new_token.token_len)))
1329                     goto err;
1330                 break;
1331             case OSSL_QUIC_FRAME_TYPE_ACK_WITH_ECN:
1332             case OSSL_QUIC_FRAME_TYPE_ACK_WITHOUT_ECN:
1333                 h.frame.ack.ack_ranges      = h.ack_ranges;
1334                 h.frame.ack.num_ack_ranges  = OSSL_NELEM(h.ack_ranges);
1335                 if (!TEST_true(ossl_quic_wire_decode_frame_ack(&h.pkt,
1336                                                                h.args.ack_delay_exponent,
1337                                                                &h.frame.ack,
1338                                                                NULL)))
1339                     goto err;
1340                 break;
1341             case OSSL_QUIC_FRAME_TYPE_CRYPTO:
1342                 if (!TEST_true(ossl_quic_wire_decode_frame_crypto(&h.pkt, 0, &h.frame.crypto)))
1343                     goto err;
1344                 break;
1345
1346             case OSSL_QUIC_FRAME_TYPE_STREAM:
1347             case OSSL_QUIC_FRAME_TYPE_STREAM_FIN:
1348             case OSSL_QUIC_FRAME_TYPE_STREAM_LEN:
1349             case OSSL_QUIC_FRAME_TYPE_STREAM_LEN_FIN:
1350             case OSSL_QUIC_FRAME_TYPE_STREAM_OFF:
1351             case OSSL_QUIC_FRAME_TYPE_STREAM_OFF_FIN:
1352             case OSSL_QUIC_FRAME_TYPE_STREAM_OFF_LEN:
1353             case OSSL_QUIC_FRAME_TYPE_STREAM_OFF_LEN_FIN:
1354                 if (!TEST_true(ossl_quic_wire_decode_frame_stream(&h.pkt, 0, &h.frame.stream)))
1355                     goto err;
1356                 break;
1357
1358             case OSSL_QUIC_FRAME_TYPE_STOP_SENDING:
1359                 if (!TEST_true(ossl_quic_wire_decode_frame_stop_sending(&h.pkt,
1360                                                                         &h.frame.stop_sending)))
1361                     goto err;
1362                 break;
1363
1364             case OSSL_QUIC_FRAME_TYPE_RESET_STREAM:
1365                 if (!TEST_true(ossl_quic_wire_decode_frame_reset_stream(&h.pkt,
1366                                                                         &h.frame.reset_stream)))
1367                     goto err;
1368                 break;
1369
1370             case OSSL_QUIC_FRAME_TYPE_CONN_CLOSE_TRANSPORT:
1371             case OSSL_QUIC_FRAME_TYPE_CONN_CLOSE_APP:
1372                 if (!TEST_true(ossl_quic_wire_decode_frame_conn_close(&h.pkt,
1373                                                                       &h.frame.conn_close)))
1374                     goto err;
1375                 break;
1376
1377             default:
1378                 TEST_error("unknown frame type");
1379                 goto err;
1380             }
1381             break;
1382         case OPK_EXPECT_NO_FRAME:
1383             skip_padding(&h);
1384             if (!TEST_size_t_eq(PACKET_remaining(&h.pkt), 0))
1385                 goto err;
1386             break;
1387         case OPK_PROVIDE_SECRET:
1388             if (!TEST_true(ossl_qtx_provide_secret(h.args.qtx,
1389                                                    (uint32_t)op->arg0,
1390                                                    (uint32_t)op->arg1,
1391                                                    NULL, op->buf, op->buf_len)))
1392                 goto err;
1393             if (!TEST_true(ossl_qrx_provide_secret(h.qrx,
1394                                                    (uint32_t)op->arg0,
1395                                                    (uint32_t)op->arg1,
1396                                                    NULL, op->buf, op->buf_len)))
1397                 goto err;
1398             break;
1399         case OPK_DISCARD_EL:
1400             if (!TEST_true(ossl_quic_tx_packetiser_discard_enc_level(h.txp,
1401                                                                      (uint32_t)op->arg0)))
1402                 goto err;
1403             /*
1404              * We do not discard on the QRX here, the object is to test the
1405              * TXP so if the TXP does erroneously send at a discarded EL we
1406              * want to know about it.
1407              */
1408             break;
1409         case OPK_CRYPTO_SEND:
1410             {
1411                 size_t consumed = 0;
1412
1413                 if (!TEST_true(ossl_quic_sstream_append(h.args.crypto[op->arg0],
1414                                                         op->buf, op->buf_len,
1415                                                         &consumed)))
1416                     goto err;
1417
1418                 if (!TEST_size_t_eq(consumed, op->buf_len))
1419                     goto err;
1420             }
1421             break;
1422         case OPK_STREAM_NEW:
1423             {
1424                 QUIC_STREAM *s;
1425
1426                 if (!TEST_ptr(s = ossl_quic_stream_map_alloc(h.args.qsm, op->arg0,
1427                                                              QUIC_STREAM_DIR_BIDI)))
1428                     goto err;
1429
1430                 if (!TEST_ptr(s->sstream = ossl_quic_sstream_new(512 * 1024))
1431                     || !TEST_true(ossl_quic_txfc_init(&s->txfc, &h.conn_txfc))
1432                     || !TEST_true(ossl_quic_rxfc_init(&s->rxfc, &h.conn_rxfc,
1433                                                       1 * 1024 * 1024,
1434                                                       16 * 1024 * 1024,
1435                                                       fake_now, NULL))
1436                     || !TEST_ptr(s->rstream = ossl_quic_rstream_new(&s->rxfc,
1437                                                                     NULL, 1024))) {
1438                     ossl_quic_sstream_free(s->sstream);
1439                     ossl_quic_stream_map_release(h.args.qsm, s);
1440                     goto err;
1441                 }
1442             }
1443             break;
1444         case OPK_STREAM_SEND:
1445             {
1446                 QUIC_STREAM *s;
1447                 size_t consumed = 0;
1448
1449                 if (!TEST_ptr(s = ossl_quic_stream_map_get_by_id(h.args.qsm,
1450                                                                  op->arg0)))
1451                     goto err;
1452
1453                 if (!TEST_true(ossl_quic_sstream_append(s->sstream, op->buf,
1454                                                         op->buf_len, &consumed)))
1455                     goto err;
1456
1457                 if (!TEST_size_t_eq(consumed, op->buf_len))
1458                     goto err;
1459
1460                 ossl_quic_stream_map_update_state(h.args.qsm, s);
1461             }
1462             break;
1463         case OPK_STREAM_FIN:
1464             {
1465                 QUIC_STREAM *s;
1466
1467                 if (!TEST_ptr(s = ossl_quic_stream_map_get_by_id(h.args.qsm,
1468                                                                  op->arg0)))
1469                     goto err;
1470
1471                 ossl_quic_sstream_fin(s->sstream);
1472             }
1473             break;
1474         case OPK_STOP_SENDING:
1475             {
1476                 QUIC_STREAM *s;
1477
1478                 if (!TEST_ptr(s = ossl_quic_stream_map_get_by_id(h.args.qsm,
1479                                                                  op->arg0)))
1480                     goto err;
1481
1482                 if (!TEST_true(ossl_quic_stream_map_stop_sending_recv_part(h.args.qsm,
1483                                                                            s, op->arg1)))
1484                     goto err;
1485
1486                 ossl_quic_stream_map_update_state(h.args.qsm, s);
1487
1488                 if (!TEST_true(s->active))
1489                     goto err;
1490             }
1491             break;
1492         case OPK_RESET_STREAM:
1493             {
1494                 QUIC_STREAM *s;
1495
1496                 if (!TEST_ptr(s = ossl_quic_stream_map_get_by_id(h.args.qsm,
1497                                                                  op->arg0)))
1498                     goto err;
1499
1500                 if (!TEST_true(ossl_quic_stream_map_reset_stream_send_part(h.args.qsm,
1501                                                                            s, op->arg1)))
1502                     goto err;
1503
1504                 ossl_quic_stream_map_update_state(h.args.qsm, s);
1505
1506                 if (!TEST_true(s->active))
1507                     goto err;
1508             }
1509             break;
1510         case OPK_CONN_TXFC_BUMP:
1511             if (!TEST_true(ossl_quic_txfc_bump_cwm(h.args.conn_txfc, op->arg0)))
1512                 goto err;
1513
1514             break;
1515         case OPK_STREAM_TXFC_BUMP:
1516             {
1517                 QUIC_STREAM *s;
1518
1519                 if (!TEST_ptr(s = ossl_quic_stream_map_get_by_id(h.args.qsm,
1520                                                                  op->arg1)))
1521                     goto err;
1522
1523                 if (!TEST_true(ossl_quic_txfc_bump_cwm(&s->txfc, op->arg0)))
1524                     goto err;
1525
1526                 ossl_quic_stream_map_update_state(h.args.qsm, s);
1527             }
1528             break;
1529         case OPK_HANDSHAKE_COMPLETE:
1530             ossl_quic_tx_packetiser_notify_handshake_complete(h.txp);
1531             break;
1532         case OPK_NOP:
1533             break;
1534         default:
1535             TEST_error("bad opcode");
1536             goto err;
1537         }
1538     }
1539
1540     testresult = 1;
1541 err:
1542     if (!testresult)
1543         TEST_error("script %d failed at op %zu", script_idx + 1, opn + 1);
1544     if (have_helper)
1545         helper_cleanup(&h);
1546     return testresult;
1547 }
1548
1549 static int test_script(int idx)
1550 {
1551     if (idx + 1 != 18) return 1;
1552     return run_script(idx, scripts[idx]);
1553 }
1554
1555 /*
1556  * Dynamic Script 1.
1557  *
1558  * This script exists to test the interactions between multiple packets (ELs) in
1559  * the same datagram when there is a padding requirement (due to the datagram
1560  * containing an Initial packet). There are boundary cases which are difficult
1561  * to get right so it is important to test this entire space. Examples of such
1562  * edge cases include:
1563  *
1564  * - If we are planning on generating both an Initial and Handshake packet in a
1565  *   datagram ordinarily we would plan on adding the padding frames to meet the
1566  *   mandatory minimum size to the last packet in the datagram (i.e., the
1567  *   Handshake packet). But if the amount of room remaining in a datagram is
1568  *   e.g. only 3 bytes after generating the Initial packet, this is not
1569  *   enough room for another packet and we have a problem as having finished
1570  *   the Initial packet we have no way to add the necessary padding.
1571  *
1572  * - If we do have room for another packet but it is not enough room to encode
1573  *   any desired frame.
1574  *
1575  * This test confirms we handle these cases correctly for multi-packet datagrams
1576  * by placing two packets in a datagram and varying the size of the first
1577  * datagram.
1578  */
1579 static const unsigned char dyn_script_1_crypto_1a[1200];
1580 static const unsigned char dyn_script_1_crypto_1b[1];
1581
1582 static int check_is_initial(struct helper *h)
1583 {
1584     return h->qrx_pkt->hdr->type == QUIC_PKT_TYPE_INITIAL;
1585 }
1586
1587 static int check_is_handshake(struct helper *h)
1588 {
1589     return h->qrx_pkt->hdr->type == QUIC_PKT_TYPE_HANDSHAKE;
1590 }
1591
1592 static struct script_op dyn_script_1[] = {
1593     OP_PROVIDE_SECRET(QUIC_ENC_LEVEL_INITIAL, QRL_SUITE_AES128GCM, secret_1)
1594     OP_PROVIDE_SECRET(QUIC_ENC_LEVEL_HANDSHAKE, QRL_SUITE_AES128GCM, secret_1)
1595     OP_TXP_GENERATE_NONE()
1596     OP_CRYPTO_SEND(QUIC_PN_SPACE_INITIAL, dyn_script_1_crypto_1a) /* [crypto_idx] */
1597     OP_CRYPTO_SEND(QUIC_PN_SPACE_HANDSHAKE, dyn_script_1_crypto_1b)
1598     OP_TXP_GENERATE()
1599     OP_RX_PKT()
1600     OP_EXPECT_DGRAM_LEN(1200, 1200)
1601     OP_CHECK(check_is_initial)
1602     OP_NOP() /* [pkt_idx] */
1603     OP_NOP() /* [check_idx] */
1604     OP_END
1605 };
1606
1607 static const size_t dyn_script_1_crypto_idx     = 3;
1608 static const size_t dyn_script_1_pkt_idx        = 9;
1609 static const size_t dyn_script_1_check_idx      = 10;
1610 static const size_t dyn_script_1_start_from     = 1000;
1611
1612 static int test_dyn_script_1(int idx)
1613 {
1614     size_t target_size = dyn_script_1_start_from + (size_t)idx;
1615     int expect_handshake_pkt_in_same_dgram = (target_size <= 1115);
1616
1617     dyn_script_1[dyn_script_1_crypto_idx].buf_len = target_size;
1618
1619     if (expect_handshake_pkt_in_same_dgram) {
1620         dyn_script_1[dyn_script_1_pkt_idx].opcode       = OPK_RX_PKT;
1621         dyn_script_1[dyn_script_1_check_idx].opcode     = OPK_CHECK;
1622         dyn_script_1[dyn_script_1_check_idx].check_func = check_is_handshake;
1623     } else {
1624         dyn_script_1[dyn_script_1_pkt_idx].opcode       = OPK_RX_PKT_NONE;
1625         dyn_script_1[dyn_script_1_check_idx].opcode     = OPK_NOP;
1626     }
1627
1628     if (!run_script(idx, dyn_script_1)) {
1629         TEST_error("failed dyn script 1 with target size %zu", target_size);
1630         return 0;
1631     }
1632
1633     return 1;
1634 }
1635
1636 int setup_tests(void)
1637 {
1638     ADD_ALL_TESTS(test_script, OSSL_NELEM(scripts));
1639     ADD_ALL_TESTS(test_dyn_script_1,
1640                   OSSL_NELEM(dyn_script_1_crypto_1a)
1641                   - dyn_script_1_start_from + 1);
1642     return 1;
1643 }