test/quic_txp_test.c

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