test/quic_txp_test.c

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