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