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