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, NULL, NULL)))
 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,
 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 /* 15. INITIAL, Anti-Deadlock Probe Simulation */
1090 static int gen_probe_initial(struct helper *h)
1091 {
1092     OSSL_ACKM_PROBE_INFO *probe = ossl_ackm_get0_probe_request(h->args.ackm);
1093
1094     /*
1095      * Pretend the ACKM asked for an anti-deadlock Initial probe.
1096      * We test output of this in the ACKM unit tests.
1097      */
1098     ++probe->anti_deadlock_initial;
1099     return 1;
1100 }
1101
1102 static const struct script_op script_15[] = {
1103     OP_PROVIDE_SECRET(QUIC_ENC_LEVEL_INITIAL, QRL_SUITE_AES128GCM, secret_1)
1104     OP_TXP_GENERATE_NONE(TX_PACKETISER_ARCHETYPE_NORMAL)
1105     OP_CHECK(gen_probe_initial)
1106     OP_TXP_GENERATE(TX_PACKETISER_ARCHETYPE_NORMAL)
1107     OP_RX_PKT()
1108     OP_EXPECT_DGRAM_LEN(1200, 1200)
1109     OP_NEXT_FRAME()
1110     OP_EXPECT_FRAME(OSSL_QUIC_FRAME_TYPE_PING)
1111     OP_EXPECT_NO_FRAME()
1112     OP_RX_PKT_NONE()
1113     OP_TXP_GENERATE_NONE(TX_PACKETISER_ARCHETYPE_NORMAL)
1114     OP_END
1115 };
1116
1117 /* 16. HANDSHAKE, Anti-Deadlock Probe Simulation */
1118 static int gen_probe_handshake(struct helper *h)
1119 {
1120     OSSL_ACKM_PROBE_INFO *probe = ossl_ackm_get0_probe_request(h->args.ackm);
1121
1122     /*
1123      * Pretend the ACKM asked for an anti-deadlock Handshake probe.
1124      * We test output of this in the ACKM unit tests.
1125      */
1126     ++probe->anti_deadlock_handshake;
1127     return 1;
1128 }
1129
1130 static const struct script_op script_16[] = {
1131     OP_DISCARD_EL(QUIC_ENC_LEVEL_INITIAL)
1132     OP_PROVIDE_SECRET(QUIC_ENC_LEVEL_HANDSHAKE, QRL_SUITE_AES128GCM, secret_1)
1133     OP_TXP_GENERATE_NONE(TX_PACKETISER_ARCHETYPE_NORMAL)
1134     OP_CHECK(gen_probe_handshake)
1135     OP_TXP_GENERATE(TX_PACKETISER_ARCHETYPE_NORMAL)
1136     OP_RX_PKT()
1137     OP_EXPECT_DGRAM_LEN(21, 512)
1138     OP_NEXT_FRAME()
1139     OP_EXPECT_FRAME(OSSL_QUIC_FRAME_TYPE_PING)
1140     OP_EXPECT_NO_FRAME()
1141     OP_RX_PKT_NONE()
1142     OP_TXP_GENERATE_NONE(TX_PACKETISER_ARCHETYPE_NORMAL)
1143     OP_END
1144 };
1145
1146 /* 17. 1-RTT, Probe Simulation */
1147 static int gen_probe_1rtt(struct helper *h)
1148 {
1149     OSSL_ACKM_PROBE_INFO *probe = ossl_ackm_get0_probe_request(h->args.ackm);
1150
1151     /*
1152      * Pretend the ACKM asked for a 1-RTT PTO probe.
1153      * We test output of this in the ACKM unit tests.
1154      */
1155     ++probe->pto[QUIC_PN_SPACE_APP];
1156     return 1;
1157 }
1158
1159 static const struct script_op script_17[] = {
1160     OP_DISCARD_EL(QUIC_ENC_LEVEL_INITIAL)
1161     OP_DISCARD_EL(QUIC_ENC_LEVEL_HANDSHAKE)
1162     OP_PROVIDE_SECRET(QUIC_ENC_LEVEL_1RTT, QRL_SUITE_AES128GCM, secret_1)
1163     OP_TXP_GENERATE_NONE(TX_PACKETISER_ARCHETYPE_NORMAL)
1164     OP_CHECK(gen_probe_1rtt)
1165     OP_TXP_GENERATE(TX_PACKETISER_ARCHETYPE_NORMAL)
1166     OP_RX_PKT()
1167     OP_EXPECT_DGRAM_LEN(21, 512)
1168     OP_NEXT_FRAME()
1169     OP_EXPECT_FRAME(OSSL_QUIC_FRAME_TYPE_PING)
1170     OP_EXPECT_NO_FRAME()
1171     OP_RX_PKT_NONE()
1172     OP_TXP_GENERATE_NONE(TX_PACKETISER_ARCHETYPE_NORMAL)
1173     OP_END
1174 };
1175
1176 static const struct script_op *const scripts[] = {
1177     script_1,
1178     script_2,
1179     script_3,
1180     script_4,
1181     script_5,
1182     script_6,
1183     script_7,
1184     script_8,
1185     script_9,
1186     script_10,
1187     script_11,
1188     script_12,
1189     script_13,
1190     script_14,
1191     script_15,
1192     script_16,
1193     script_17
1194 };
1195
1196 static void skip_padding(struct helper *h)
1197 {
1198     uint64_t frame_type;
1199
1200     if (!ossl_quic_wire_peek_frame_header(&h->pkt, &frame_type))
1201         return; /* EOF */
1202
1203     if (frame_type == OSSL_QUIC_FRAME_TYPE_PADDING)
1204         ossl_quic_wire_decode_padding(&h->pkt);
1205 }
1206
1207 static int run_script(const struct script_op *script)
1208 {
1209     int testresult = 0, have_helper = 0;
1210     struct helper h;
1211     const struct script_op *op;
1212
1213     if (!helper_init(&h))
1214         goto err;
1215
1216     have_helper = 1;
1217     for (op = script; op->opcode != OPK_END; ++op) {
1218         switch (op->opcode) {
1219         case OPK_TXP_GENERATE:
1220             if (!TEST_int_eq(ossl_quic_tx_packetiser_generate(h.txp, (int)op->arg0),
1221                              TX_PACKETISER_RES_SENT_PKT))
1222                 goto err;
1223
1224             ossl_qtx_finish_dgram(h.args.qtx);
1225             ossl_qtx_flush_net(h.args.qtx);
1226             break;
1227         case OPK_TXP_GENERATE_NONE:
1228             if (!TEST_int_eq(ossl_quic_tx_packetiser_generate(h.txp, (int)op->arg0),
1229                              TX_PACKETISER_RES_NO_PKT))
1230                 goto err;
1231
1232             break;
1233         case OPK_RX_PKT:
1234             ossl_quic_demux_pump(h.demux);
1235             ossl_qrx_pkt_release(h.qrx_pkt);
1236             h.qrx_pkt = NULL;
1237             if (!TEST_true(ossl_qrx_read_pkt(h.qrx, &h.qrx_pkt)))
1238                 goto err;
1239             if (!TEST_true(PACKET_buf_init(&h.pkt,
1240                                            h.qrx_pkt->hdr->data,
1241                                            h.qrx_pkt->hdr->len)))
1242                 goto err;
1243             h.frame_type = UINT64_MAX;
1244             break;
1245         case OPK_RX_PKT_NONE:
1246             ossl_quic_demux_pump(h.demux);
1247             if (!TEST_false(ossl_qrx_read_pkt(h.qrx, &h.qrx_pkt)))
1248                 goto err;
1249             h.frame_type = UINT64_MAX;
1250             break;
1251         case OPK_EXPECT_DGRAM_LEN:
1252             if (!TEST_size_t_ge(h.qrx_pkt->datagram_len, (size_t)op->arg0)
1253                 || !TEST_size_t_le(h.qrx_pkt->datagram_len, (size_t)op->arg1))
1254                 goto err;
1255             break;
1256         case OPK_EXPECT_FRAME:
1257             if (!TEST_uint64_t_eq(h.frame_type, op->arg0))
1258                 goto err;
1259             break;
1260         case OPK_EXPECT_INITIAL_TOKEN:
1261             if (!TEST_mem_eq(h.qrx_pkt->hdr->token, h.qrx_pkt->hdr->token_len,
1262                              op->buf, (size_t)op->arg0))
1263                 goto err;
1264             break;
1265         case OPK_EXPECT_HDR:
1266             if (!TEST_true(cmp_pkt_hdr(h.qrx_pkt->hdr, op->buf,
1267                                        NULL, 0, 0)))
1268                 goto err;
1269             break;
1270         case OPK_CHECK:
1271             if (!TEST_true(op->check_func(&h)))
1272                 goto err;
1273             break;
1274         case OPK_NEXT_FRAME:
1275             skip_padding(&h);
1276             if (!ossl_quic_wire_peek_frame_header(&h.pkt, &h.frame_type)) {
1277                 h.frame_type = UINT64_MAX;
1278                 break;
1279             }
1280
1281             switch (h.frame_type) {
1282             case OSSL_QUIC_FRAME_TYPE_HANDSHAKE_DONE:
1283                 if (!TEST_true(ossl_quic_wire_decode_frame_handshake_done(&h.pkt)))
1284                     goto err;
1285                 break;
1286             case OSSL_QUIC_FRAME_TYPE_PING:
1287                 if (!TEST_true(ossl_quic_wire_decode_frame_ping(&h.pkt)))
1288                     goto err;
1289                 break;
1290             case OSSL_QUIC_FRAME_TYPE_MAX_DATA:
1291                 if (!TEST_true(ossl_quic_wire_decode_frame_max_data(&h.pkt,
1292                                                                     &h.frame.max_data)))
1293                     goto err;
1294                 break;
1295             case OSSL_QUIC_FRAME_TYPE_NEW_CONN_ID:
1296                 if (!TEST_true(ossl_quic_wire_decode_frame_new_conn_id(&h.pkt,
1297                                                                        &h.frame.new_conn_id)))
1298                     goto err;
1299                 break;
1300             case OSSL_QUIC_FRAME_TYPE_NEW_TOKEN:
1301                 if (!TEST_true(ossl_quic_wire_decode_frame_new_token(&h.pkt,
1302                                                                      &h.frame.new_token.token,
1303                                                                      &h.frame.new_token.token_len)))
1304                     goto err;
1305                 break;
1306             case OSSL_QUIC_FRAME_TYPE_ACK_WITH_ECN:
1307             case OSSL_QUIC_FRAME_TYPE_ACK_WITHOUT_ECN:
1308                 h.frame.ack.ack_ranges      = h.ack_ranges;
1309                 h.frame.ack.num_ack_ranges  = OSSL_NELEM(h.ack_ranges);
1310                 if (!TEST_true(ossl_quic_wire_decode_frame_ack(&h.pkt,
1311                                                                h.args.ack_delay_exponent,
1312                                                                &h.frame.ack,
1313                                                                NULL)))
1314                     goto err;
1315                 break;
1316             case OSSL_QUIC_FRAME_TYPE_CRYPTO:
1317                 if (!TEST_true(ossl_quic_wire_decode_frame_crypto(&h.pkt, &h.frame.crypto)))
1318                     goto err;
1319                 break;
1320
1321             case OSSL_QUIC_FRAME_TYPE_STREAM:
1322             case OSSL_QUIC_FRAME_TYPE_STREAM_FIN:
1323             case OSSL_QUIC_FRAME_TYPE_STREAM_LEN:
1324             case OSSL_QUIC_FRAME_TYPE_STREAM_LEN_FIN:
1325             case OSSL_QUIC_FRAME_TYPE_STREAM_OFF:
1326             case OSSL_QUIC_FRAME_TYPE_STREAM_OFF_FIN:
1327             case OSSL_QUIC_FRAME_TYPE_STREAM_OFF_LEN:
1328             case OSSL_QUIC_FRAME_TYPE_STREAM_OFF_LEN_FIN:
1329                 if (!TEST_true(ossl_quic_wire_decode_frame_stream(&h.pkt, &h.frame.stream)))
1330                     goto err;
1331                 break;
1332
1333             case OSSL_QUIC_FRAME_TYPE_STOP_SENDING:
1334                 if (!TEST_true(ossl_quic_wire_decode_frame_stop_sending(&h.pkt,
1335                                                                         &h.frame.stop_sending)))
1336                     goto err;
1337                 break;
1338
1339             case OSSL_QUIC_FRAME_TYPE_RESET_STREAM:
1340                 if (!TEST_true(ossl_quic_wire_decode_frame_reset_stream(&h.pkt,
1341                                                                         &h.frame.reset_stream)))
1342                     goto err;
1343                 break;
1344
1345             case OSSL_QUIC_FRAME_TYPE_CONN_CLOSE_TRANSPORT:
1346             case OSSL_QUIC_FRAME_TYPE_CONN_CLOSE_APP:
1347                 if (!TEST_true(ossl_quic_wire_decode_frame_conn_close(&h.pkt,
1348                                                                       &h.frame.conn_close)))
1349                     goto err;
1350                 break;
1351
1352             default:
1353                 TEST_error("unknown frame type");
1354                 goto err;
1355             }
1356             break;
1357         case OPK_EXPECT_NO_FRAME:
1358             skip_padding(&h);
1359             if (!TEST_size_t_eq(PACKET_remaining(&h.pkt), 0))
1360                 goto err;
1361             break;
1362         case OPK_PROVIDE_SECRET:
1363             if (!TEST_true(ossl_qtx_provide_secret(h.args.qtx,
1364                                                    (uint32_t)op->arg0,
1365                                                    (uint32_t)op->arg1,
1366                                                    NULL, op->buf, op->buf_len)))
1367                 goto err;
1368             if (!TEST_true(ossl_qrx_provide_secret(h.qrx,
1369                                                    (uint32_t)op->arg0,
1370                                                    (uint32_t)op->arg1,
1371                                                    NULL, op->buf, op->buf_len)))
1372                 goto err;
1373             break;
1374         case OPK_DISCARD_EL:
1375             if (!TEST_true(ossl_quic_tx_packetiser_discard_enc_level(h.txp,
1376                                                                      (uint32_t)op->arg0)))
1377                 goto err;
1378             /*
1379              * We do not discard on the QRX here, the object is to test the
1380              * TXP so if the TXP does erroneously send at a discarded EL we
1381              * want to know about it.
1382              */
1383             break;
1384         case OPK_CRYPTO_SEND:
1385             {
1386                 size_t consumed = 0;
1387
1388                 if (!TEST_true(ossl_quic_sstream_append(h.args.crypto[op->arg0],
1389                                                         op->buf, op->buf_len,
1390                                                         &consumed)))
1391                     goto err;
1392
1393                 if (!TEST_size_t_eq(consumed, op->buf_len))
1394                     goto err;
1395             }
1396             break;
1397         case OPK_STREAM_NEW:
1398             {
1399                 QUIC_STREAM *s;
1400
1401                 if (!TEST_ptr(s = ossl_quic_stream_map_alloc(h.args.qsm, op->arg0,
1402                                                              QUIC_STREAM_DIR_BIDI)))
1403                     goto err;
1404
1405                 if (!TEST_ptr(s->sstream = ossl_quic_sstream_new(512 * 1024))
1406                     || !TEST_true(ossl_quic_txfc_init(&s->txfc, &h.conn_txfc))
1407                     || !TEST_true(ossl_quic_rxfc_init(&s->rxfc, &h.conn_rxfc,
1408                                                       1 * 1024 * 1024,
1409                                                       16 * 1024 * 1024,
1410                                                       fake_now, NULL))) {
1411                     ossl_quic_sstream_free(s->sstream);
1412                     ossl_quic_stream_map_release(h.args.qsm, s);
1413                     goto err;
1414                 }
1415             }
1416             break;
1417         case OPK_STREAM_SEND:
1418             {
1419                 QUIC_STREAM *s;
1420                 size_t consumed = 0;
1421
1422                 if (!TEST_ptr(s = ossl_quic_stream_map_get_by_id(h.args.qsm,
1423                                                                  op->arg0)))
1424                     goto err;
1425
1426                 if (!TEST_true(ossl_quic_sstream_append(s->sstream, op->buf,
1427                                                         op->buf_len, &consumed)))
1428                     goto err;
1429
1430                 if (!TEST_size_t_eq(consumed, op->buf_len))
1431                     goto err;
1432
1433                 ossl_quic_stream_map_update_state(h.args.qsm, s);
1434             }
1435             break;
1436         case OPK_STREAM_FIN:
1437             {
1438                 QUIC_STREAM *s;
1439
1440                 if (!TEST_ptr(s = ossl_quic_stream_map_get_by_id(h.args.qsm,
1441                                                                  op->arg0)))
1442                     goto err;
1443
1444                 ossl_quic_sstream_fin(s->sstream);
1445             }
1446             break;
1447         case OPK_STOP_SENDING:
1448             {
1449                 QUIC_STREAM *s;
1450
1451                 if (!TEST_ptr(s = ossl_quic_stream_map_get_by_id(h.args.qsm,
1452                                                                  op->arg0)))
1453                     goto err;
1454
1455                 if (!TEST_true(ossl_quic_stream_stop_sending(s, op->arg1)))
1456                     goto err;
1457
1458                 ossl_quic_stream_map_update_state(h.args.qsm, s);
1459
1460                 if (!TEST_true(s->active))
1461                     goto err;
1462             }
1463             break;
1464         case OPK_RESET_STREAM:
1465             {
1466                 QUIC_STREAM *s;
1467
1468                 if (!TEST_ptr(s = ossl_quic_stream_map_get_by_id(h.args.qsm,
1469                                                                  op->arg0)))
1470                     goto err;
1471
1472                 if (!TEST_true(ossl_quic_stream_reset(s, op->arg1)))
1473                     goto err;
1474
1475                 ossl_quic_stream_map_update_state(h.args.qsm, s);
1476
1477                 if (!TEST_true(s->active))
1478                     goto err;
1479             }
1480             break;
1481         case OPK_CONN_TXFC_BUMP:
1482             if (!TEST_true(ossl_quic_txfc_bump_cwm(h.args.conn_txfc, op->arg0)))
1483                 goto err;
1484
1485             break;
1486         case OPK_STREAM_TXFC_BUMP:
1487             {
1488                 QUIC_STREAM *s;
1489
1490                 if (!TEST_ptr(s = ossl_quic_stream_map_get_by_id(h.args.qsm,
1491                                                                  op->arg1)))
1492                     goto err;
1493
1494                 if (!TEST_true(ossl_quic_txfc_bump_cwm(&s->txfc, op->arg0)))
1495                     goto err;
1496
1497                 ossl_quic_stream_map_update_state(h.args.qsm, s);
1498             }
1499             break;
1500         case OPK_HANDSHAKE_COMPLETE:
1501             ossl_quic_tx_packetiser_notify_handshake_complete(h.txp);
1502             break;
1503         default:
1504             TEST_error("bad opcode");
1505             goto err;
1506         }
1507     }
1508
1509     testresult = 1;
1510 err:
1511     if (have_helper)
1512         helper_cleanup(&h);
1513     return testresult;
1514 }
1515
1516 static int test_script(int idx)
1517 {
1518     return run_script(scripts[idx]);
1519 }
1520
1521 int setup_tests(void)
1522 {
1523     ADD_ALL_TESTS(test_script, OSSL_NELEM(scripts));
1524     return 1;
1525 }