test/quic_record_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
  10 #include "internal/quic_record_rx.h"
  11 #include "internal/quic_rx_depack.h"
  12 #include "internal/quic_record_tx.h"
  13 #include "internal/quic_ackm.h"
  14 #include "internal/quic_cc.h"
  15 #include "internal/quic_ssl.h"
  16 #include "testutil.h"
  17 #include "quic_record_test_util.h"
  18
  19 static const QUIC_CONN_ID empty_conn_id = {0, {0}};
  20
  21 #define RX_TEST_OP_END                     0 /* end of script */
  22 #define RX_TEST_OP_SET_SCID_LEN            1 /* change SCID length */
  23 #define RX_TEST_OP_SET_INIT_LARGEST_PN     2 /* set initial largest PN */
  24 #define RX_TEST_OP_ADD_RX_DCID             3 /* register an RX DCID */
  25 #define RX_TEST_OP_INJECT                  4 /* inject a datagram into demux */
  26 #define RX_TEST_OP_PROVIDE_SECRET          5 /* provide RX secret */
  27 #define RX_TEST_OP_PROVIDE_SECRET_INITIAL  6 /* provide RX secret for initial */
  28 #define RX_TEST_OP_DISCARD_EL              7 /* discard an encryption level */
  29 #define RX_TEST_OP_CHECK_PKT               8 /* read packet, compare to expected */
  30 #define RX_TEST_OP_CHECK_NO_PKT            9 /* check no packet is available to read */
  31 #define RX_TEST_OP_CHECK_KEY_EPOCH        10 /* check key epoch value matches */
  32 #define RX_TEST_OP_KEY_UPDATE_TIMEOUT     11 /* complete key update process */
  33 #define RX_TEST_OP_SET_INIT_KEY_PHASE     12 /* initial Key Phase bit value */
  34
  35 /* These are subtest ops for RX_TEST_OP_CHECK_PKT, to additionally check frames */
  36 #define RX_TEST_OP_CHECK_PKT_FRAMES_OK        1 /* check that frames are parsed ok */
  37 #define RX_TEST_OP_CHECK_PKT_FRAMES_INVALID   2 /* check that frames fail to parse ok */
  38
  39 struct rx_test_op {
  40     unsigned char op;
  41     unsigned char subop;
  42     const unsigned char *buf;
  43     size_t buf_len;
  44     const QUIC_PKT_HDR *hdr;
  45     uint32_t enc_level, suite_id;
  46     QUIC_PN largest_pn;
  47     const QUIC_CONN_ID *dcid;
  48     int (*new_qrx)(QUIC_DEMUX **demux, OSSL_QRX **qrx);
  49
  50     /* For frame checking */
  51 };
  52
  53 #define RX_OP_END \
  54     { RX_TEST_OP_END }
  55 #define RX_OP_SET_SCID_LEN(scid_len) \
  56     { RX_TEST_OP_SET_SCID_LEN, 0, NULL, 0, NULL, (scid_len), 0, 0, NULL, NULL },
  57 #define RX_OP_SET_INIT_LARGEST_PN(largest_pn) \
  58     { RX_TEST_OP_SET_INIT_LARGEST_PN, 0, NULL, 0, NULL, 0, 0, (largest_pn), NULL, NULL },
  59 #define RX_OP_ADD_RX_DCID(dcid) \
  60     { RX_TEST_OP_ADD_RX_DCID, 0, NULL, 0, NULL, 0, 0, 0, &(dcid), NULL },
  61 #define RX_OP_INJECT(dgram) \
  62     { RX_TEST_OP_INJECT, 0, (dgram), sizeof(dgram), NULL, 0, 0, 0, NULL },
  63 #define RX_OP_PROVIDE_SECRET(el, suite, key)                           \
  64     {                                                               \
  65         RX_TEST_OP_PROVIDE_SECRET, 0, (key), sizeof(key),             \
  66         NULL, (el), (suite), 0, NULL, NULL                          \
  67     },
  68 #define RX_OP_PROVIDE_SECRET_INITIAL(dcid) \
  69     { RX_TEST_OP_PROVIDE_SECRET_INITIAL, 0, NULL, 0, NULL, 0, 0, 0, &(dcid), NULL },
  70 #define RX_OP_DISCARD_EL(el) \
  71     { RX_TEST_OP_DISCARD_EL, 0, NULL, 0, NULL, (el), 0, 0, NULL, NULL },
  72 #define RX_OP_CHECK_PKT(expect_hdr, expect_body)                       \
  73     {                                                               \
  74         RX_TEST_OP_CHECK_PKT, 0, (expect_body), sizeof(expect_body),  \
  75         &(expect_hdr), 0, 0, 0, NULL, NULL                          \
  76     },
  77 #define RX_OP_CHECK_PKT_FRAMES_OK(expect_hdr, expect_body)          \
  78     {                                                               \
  79         RX_TEST_OP_CHECK_PKT, RX_TEST_OP_CHECK_PKT_FRAMES_OK,       \
  80         (expect_body), sizeof(expect_body), &(expect_hdr),          \
  81         0, 0, 0, NULL, NULL                                         \
  82     },
  83 #define RX_OP_CHECK_PKT_FRAMES_INVALID(expect_hdr, expect_body)     \
  84     {                                                               \
  85         RX_TEST_OP_CHECK_PKT, RX_TEST_OP_CHECK_PKT_FRAMES_INVALID,  \
  86         (expect_body), sizeof(expect_body), &(expect_hdr),          \
  87         0, 0, 0, NULL, NULL                                         \
  88     },
  89 #define RX_OP_CHECK_NO_PKT() \
  90     { RX_TEST_OP_CHECK_NO_PKT, 0, NULL, 0, NULL, 0, 0, 0, NULL, NULL },
  91 #define RX_OP_CHECK_KEY_EPOCH(expected) \
  92     { RX_TEST_OP_CHECK_KEY_EPOCH, 0, NULL, 0, NULL, 0, 0, (expected), NULL },
  93 #define RX_OP_KEY_UPDATE_TIMEOUT(normal) \
  94     { RX_TEST_OP_KEY_UPDATE_TIMEOUT, 0, NULL, 0, NULL, (normal), 0, 0, NULL },
  95 #define RX_OP_SET_INIT_KEY_PHASE(kp_bit) \
  96     { RX_TEST_OP_SET_INIT_KEY_PHASE, 0, NULL, 0, NULL, (kp_bit), 0, 0, NULL },
  97
  98 #define RX_OP_INJECT_N(n)                                          \
  99     RX_OP_INJECT(rx_script_##n##_in)
 100 #define RX_OP_CHECK_PKT_N(n)                                       \
 101     RX_OP_CHECK_PKT(rx_script_##n##_expect_hdr, rx_script_##n##_body)
 102 #define RX_OP_CHECK_PKT_FRAMES_OK_N(n)                             \
 103     RX_OP_CHECK_PKT_FRAMES_OK(rx_script_##n##_expect_hdr, rx_script_##n##_body)
 104 #define RX_OP_CHECK_PKT_FRAMES_INVALID_N(n)                        \
 105     RX_OP_CHECK_PKT_FRAMES_INVALID(rx_script_##n##_expect_hdr, rx_script_##n##_body)
 106
 107 #define RX_OP_INJECT_CHECK(n)                                  \
 108     RX_OP_INJECT_N(n)                                              \
 109     RX_OP_CHECK_PKT_N(n)
 110
 111 #define RX_OP_INJECT_CHECK_FRAMES_OK(n)                            \
 112     RX_OP_INJECT_N(n)                                              \
 113     RX_OP_CHECK_PKT_FRAMES_OK_N(n)
 114
 115 #define RX_OP_INJECT_CHECK_FRAMES_INVALID(n)                       \
 116     RX_OP_INJECT_N(n)                                              \
 117     RX_OP_CHECK_PKT_FRAMES_INVALID_N(3)
 118
 119 /* 1. RFC 9001 - A.3 Server Initial */
 120 static const unsigned char rx_script_1_in[] = {
 121     0xcf, 0x00, 0x00, 0x00, 0x01, 0x00, 0x08, 0xf0, 0x67, 0xa5, 0x50, 0x2a,
 122     0x42, 0x62, 0xb5, 0x00, 0x40, 0x75, 0xc0, 0xd9, 0x5a, 0x48, 0x2c, 0xd0,
 123     0x99, 0x1c, 0xd2, 0x5b, 0x0a, 0xac, 0x40, 0x6a, 0x58, 0x16, 0xb6, 0x39,
 124     0x41, 0x00, 0xf3, 0x7a, 0x1c, 0x69, 0x79, 0x75, 0x54, 0x78, 0x0b, 0xb3,
 125     0x8c, 0xc5, 0xa9, 0x9f, 0x5e, 0xde, 0x4c, 0xf7, 0x3c, 0x3e, 0xc2, 0x49,
 126     0x3a, 0x18, 0x39, 0xb3, 0xdb, 0xcb, 0xa3, 0xf6, 0xea, 0x46, 0xc5, 0xb7,
 127     0x68, 0x4d, 0xf3, 0x54, 0x8e, 0x7d, 0xde, 0xb9, 0xc3, 0xbf, 0x9c, 0x73,
 128     0xcc, 0x3f, 0x3b, 0xde, 0xd7, 0x4b, 0x56, 0x2b, 0xfb, 0x19, 0xfb, 0x84,
 129     0x02, 0x2f, 0x8e, 0xf4, 0xcd, 0xd9, 0x37, 0x95, 0xd7, 0x7d, 0x06, 0xed,
 130     0xbb, 0x7a, 0xaf, 0x2f, 0x58, 0x89, 0x18, 0x50, 0xab, 0xbd, 0xca, 0x3d,
 131     0x20, 0x39, 0x8c, 0x27, 0x64, 0x56, 0xcb, 0xc4, 0x21, 0x58, 0x40, 0x7d,
 132     0xd0, 0x74, 0xee
 133 };
 134
 135 static const unsigned char rx_script_1_body[] = {
 136     0x02, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x40, 0x5a, 0x02, 0x00, 0x00,
 137     0x56, 0x03, 0x03, 0xee, 0xfc, 0xe7, 0xf7, 0xb3, 0x7b, 0xa1, 0xd1, 0x63,
 138     0x2e, 0x96, 0x67, 0x78, 0x25, 0xdd, 0xf7, 0x39, 0x88, 0xcf, 0xc7, 0x98,
 139     0x25, 0xdf, 0x56, 0x6d, 0xc5, 0x43, 0x0b, 0x9a, 0x04, 0x5a, 0x12, 0x00,
 140     0x13, 0x01, 0x00, 0x00, 0x2e, 0x00, 0x33, 0x00, 0x24, 0x00, 0x1d, 0x00,
 141     0x20, 0x9d, 0x3c, 0x94, 0x0d, 0x89, 0x69, 0x0b, 0x84, 0xd0, 0x8a, 0x60,
 142     0x99, 0x3c, 0x14, 0x4e, 0xca, 0x68, 0x4d, 0x10, 0x81, 0x28, 0x7c, 0x83,
 143     0x4d, 0x53, 0x11, 0xbc, 0xf3, 0x2b, 0xb9, 0xda, 0x1a, 0x00, 0x2b, 0x00,
 144     0x02, 0x03, 0x04
 145 };
 146
 147 static const QUIC_CONN_ID rx_script_1_dcid = {
 148     8, { 0x83, 0x94, 0xc8, 0xf0, 0x3e, 0x51, 0x57, 0x08 }
 149 };
 150
 151 static const QUIC_PKT_HDR rx_script_1_expect_hdr = {
 152     QUIC_PKT_TYPE_INITIAL,
 153     0, 0, 2, 0, 1, 1, { 0, {0} },
 154     { 8, {0xf0, 0x67, 0xa5, 0x50, 0x2a, 0x42, 0x62, 0xb5 } },
 155     { 0, 1, 0, 0 },
 156     NULL, 0,
 157     99, NULL
 158 };
 159
 160 static const struct rx_test_op rx_script_1[] = {
 161     RX_OP_SET_SCID_LEN(2)
 162     RX_OP_SET_INIT_LARGEST_PN(0)
 163     RX_OP_ADD_RX_DCID(empty_conn_id)
 164     RX_OP_PROVIDE_SECRET_INITIAL(rx_script_1_dcid)
 165     RX_OP_INJECT_CHECK_FRAMES_OK(1)
 166     RX_OP_CHECK_NO_PKT()
 167     RX_OP_END
 168 };
 169
 170 /* 2. RFC 9001 - A.5 ChaCha20-Poly1305 Short Header Packet */
 171 #ifndef OPENSSL_NO_CHACHA
 172 static const unsigned char rx_script_2_in[] = {
 173     0x4c, 0xfe, 0x41, 0x89, 0x65, 0x5e, 0x5c, 0xd5, 0x5c, 0x41, 0xf6, 0x90,
 174     0x80, 0x57, 0x5d, 0x79, 0x99, 0xc2, 0x5a, 0x5b, 0xfb
 175 };
 176
 177 static const unsigned char rx_script_2_secret[] = {
 178     0x9a, 0xc3, 0x12, 0xa7, 0xf8, 0x77, 0x46, 0x8e, 0xbe, 0x69, 0x42, 0x27,
 179     0x48, 0xad, 0x00, 0xa1, 0x54, 0x43, 0xf1, 0x82, 0x03, 0xa0, 0x7d, 0x60,
 180     0x60, 0xf6, 0x88, 0xf3, 0x0f, 0x21, 0x63, 0x2b
 181 };
 182
 183 static const unsigned char rx_script_2_body[] = {
 184     0x01
 185 };
 186
 187 static const QUIC_PKT_HDR rx_script_2_expect_hdr = {
 188     QUIC_PKT_TYPE_1RTT,
 189     0, 0, 3, 0, 1, 0, {0, {0}}, {0, {0}},
 190     {0x00, 0xbf, 0xf4, 0x00},
 191     NULL, 0,
 192     1, NULL
 193 };
 194
 195 static const struct rx_test_op rx_script_2[] = {
 196     RX_OP_SET_INIT_LARGEST_PN(654360560)
 197     RX_OP_ADD_RX_DCID(empty_conn_id)
 198     RX_OP_PROVIDE_SECRET(QUIC_ENC_LEVEL_1RTT, QRL_SUITE_CHACHA20POLY1305,
 199                          rx_script_2_secret)
 200     RX_OP_INJECT_CHECK_FRAMES_OK(2)
 201     RX_OP_CHECK_NO_PKT()
 202     RX_OP_END
 203 };
 204 #endif /* !defined(OPENSSL_NO_CHACHA) */
 205
 206 /* 3. Real World - Version Negotiation Response */
 207 static const unsigned char rx_script_3_in[] = {
 208     0xc7,                               /* Long; Random Bits */
 209     0x00, 0x00, 0x00, 0x00,             /* Version 0 (Version Negotiation) */
 210     0x00,                               /* DCID */
 211     0x0c, 0x35, 0x3c, 0x1b, 0x97, 0xca, /* SCID */
 212     0xf8, 0x99, 0x11, 0x39, 0xad, 0x79,
 213     0x1f,
 214     0x00, 0x00, 0x00, 0x01,             /* Supported Version: 1 */
 215     0xaa, 0x9a, 0x3a, 0x9a              /* Supported Version: Random (GREASE) */
 216 };
 217
 218 static const QUIC_PKT_HDR rx_script_3_expect_hdr = {
 219     QUIC_PKT_TYPE_VERSION_NEG,
 220     0,          /* Spin Bit */
 221     0,          /* Key Phase */
 222     0,          /* PN Length */
 223     0,          /* Partial */
 224     1,          /* Fixed */
 225     0,          /* Version */
 226     {0, {0}},                                   /* DCID */
 227     {12, {0x35, 0x3c, 0x1b, 0x97, 0xca, 0xf8,   /* SCID */
 228           0x99, 0x11, 0x39, 0xad, 0x79, 0x1f}},
 229     {0},        /* PN */
 230     NULL, 0,    /* Token/Token Len */
 231     8, NULL
 232 };
 233
 234 static const unsigned char rx_script_3_body[] = {
 235     0x00, 0x00, 0x00, 0x01,
 236     0xaa, 0x9a, 0x3a, 0x9a
 237 };
 238
 239 static const struct rx_test_op rx_script_3[] = {
 240     RX_OP_ADD_RX_DCID(empty_conn_id)
 241     /*
 242      * This is a version negotiation packet, so doesn't have any frames.
 243      * However, the depacketizer still handles this sort of packet, so
 244      * we still pass the packet to it, to exercise what it does.
 245      */
 246     RX_OP_INJECT_CHECK_FRAMES_OK(3)
 247     RX_OP_CHECK_NO_PKT()
 248     RX_OP_END
 249 };
 250
 251 /* 4. Real World - Retry (S2C) */
 252 static const unsigned char rx_script_4_in[] = {
 253     0xf0,                           /* Long; Retry */
 254     0x00, 0x00, 0x00, 0x01,         /* Version 1 */
 255     0x00,                           /* DCID */
 256     0x04, 0xad, 0x15, 0x3f, 0xae,   /* SCID */
 257     /* Retry Token, including 16-byte Retry Integrity Tag */
 258     0xf6, 0x8b, 0x6e, 0xa3, 0xdc, 0x40, 0x38, 0xc6, 0xa5, 0x99, 0x1c, 0xa9,
 259     0x77, 0xe6, 0x1d, 0x4f, 0x09, 0x36, 0x12, 0x26, 0x00, 0x56, 0x0b, 0x29,
 260     0x7d, 0x5e, 0xda, 0x39, 0xc6, 0x61, 0x57, 0x69, 0x15, 0xff, 0x93, 0x39,
 261     0x95, 0xf0, 0x57, 0xf1, 0xe5, 0x36, 0x08, 0xad, 0xd2, 0x75, 0xa9, 0x68,
 262     0x29, 0xed, 0xaa, 0x03, 0x0e, 0x5f, 0xac, 0xbd, 0x26, 0x07, 0x95, 0x4e,
 263     0x48, 0x61, 0x26, 0xc5, 0xe2, 0x6c, 0x60, 0xbf, 0xa8, 0x6f, 0x51, 0xbb,
 264     0x1d, 0xf7, 0x98, 0x95, 0x3b, 0x2c, 0x50, 0x79, 0xcc, 0xde, 0x27, 0x84,
 265     0x44, 0x9b, 0xb2, 0x4a, 0x94, 0x4d, 0x4d, 0x3d, 0xbc, 0x00, 0x9d, 0x69,
 266     0xad, 0x45, 0x89, 0x04, 0x48, 0xca, 0x04, 0xf6, 0x3a, 0x62, 0xc1, 0x38,
 267     0x9d, 0x82, 0xb3, 0x45, 0x62, 0x4c,
 268 };
 269
 270 static const QUIC_PKT_HDR rx_script_4_expect_hdr = {
 271     QUIC_PKT_TYPE_RETRY,
 272     0,          /* Spin Bit */
 273     0,          /* Key Phase */
 274     0,          /* PN Length */
 275     0,          /* Partial */
 276     1,          /* Fixed */
 277     1,          /* Version */
 278     {0, {0}},                           /* DCID */
 279     {4, {0xad, 0x15, 0x3f, 0xae}},      /* SCID */
 280     {0},        /* PN */
 281     NULL, 0,    /* Token/Token Len */
 282     114, NULL
 283 };
 284
 285 static const unsigned char rx_script_4_body[] = {
 286     0xf6, 0x8b, 0x6e, 0xa3, 0xdc, 0x40, 0x38, 0xc6, 0xa5, 0x99, 0x1c, 0xa9,
 287     0x77, 0xe6, 0x1d, 0x4f, 0x09, 0x36, 0x12, 0x26, 0x00, 0x56, 0x0b, 0x29,
 288     0x7d, 0x5e, 0xda, 0x39, 0xc6, 0x61, 0x57, 0x69, 0x15, 0xff, 0x93, 0x39,
 289     0x95, 0xf0, 0x57, 0xf1, 0xe5, 0x36, 0x08, 0xad, 0xd2, 0x75, 0xa9, 0x68,
 290     0x29, 0xed, 0xaa, 0x03, 0x0e, 0x5f, 0xac, 0xbd, 0x26, 0x07, 0x95, 0x4e,
 291     0x48, 0x61, 0x26, 0xc5, 0xe2, 0x6c, 0x60, 0xbf, 0xa8, 0x6f, 0x51, 0xbb,
 292     0x1d, 0xf7, 0x98, 0x95, 0x3b, 0x2c, 0x50, 0x79, 0xcc, 0xde, 0x27, 0x84,
 293     0x44, 0x9b, 0xb2, 0x4a, 0x94, 0x4d, 0x4d, 0x3d, 0xbc, 0x00, 0x9d, 0x69,
 294     0xad, 0x45, 0x89, 0x04, 0x48, 0xca, 0x04, 0xf6, 0x3a, 0x62, 0xc1, 0x38,
 295     0x9d, 0x82, 0xb3, 0x45, 0x62, 0x4c
 296 };
 297
 298 static const struct rx_test_op rx_script_4[] = {
 299     RX_OP_ADD_RX_DCID(empty_conn_id)
 300     RX_OP_INJECT_CHECK_FRAMES_OK(4)
 301     RX_OP_CHECK_NO_PKT()
 302     RX_OP_END
 303 };
 304
 305 /*
 306  * 5. Real World - S2C Multiple Packets
 307  *      - Initial, Handshake, 1-RTT (AES-128-GCM/SHA256)
 308  */
 309 static const QUIC_CONN_ID rx_script_5_c2s_init_dcid = {
 310     4, {0xad, 0x15, 0x3f, 0xae}
 311 };
 312
 313 static const unsigned char rx_script_5_handshake_secret[32] = {
 314     0x5e, 0xc6, 0x4a, 0x4d, 0x0d, 0x40, 0x43, 0x3b, 0xd5, 0xbd, 0xe0, 0x19,
 315     0x71, 0x47, 0x56, 0xf3, 0x59, 0x3a, 0xa6, 0xc9, 0x3e, 0xdc, 0x81, 0x1e,
 316     0xc7, 0x72, 0x9d, 0x83, 0xd8, 0x8f, 0x88, 0x77
 317 };
 318
 319 static const unsigned char rx_script_5_1rtt_secret[32] = {
 320     0x53, 0xf2, 0x1b, 0x94, 0xa7, 0x65, 0xf7, 0x76, 0xfb, 0x06, 0x27, 0xaa,
 321     0xd2, 0x3f, 0xe0, 0x9a, 0xbb, 0xcf, 0x99, 0x6f, 0x13, 0x2c, 0x6a, 0x37,
 322     0x95, 0xf3, 0xda, 0x21, 0xcb, 0xcb, 0xa5, 0x26,
 323 };
 324
 325 static const unsigned char rx_script_5_in[] = {
 326     /* First Packet: Initial */
 327     0xc4,                           /* Long, Initial, PN Length=2 bytes */
 328     0x00, 0x00, 0x00, 0x01,         /* Version */
 329     0x00,                           /* DCID */
 330     0x04, 0x83, 0xd0, 0x0a, 0x27,   /* SCID */
 331     0x00,                           /* Token Length */
 332     0x41, 0xd2,                     /* Length (466) */
 333     0xe3, 0xab,                     /* PN (0) */
 334     0x22, 0x35, 0x34, 0x12, 0xcf, 0x20, 0x2b, 0x16, 0xaf, 0x08, 0xd4, 0xe0,
 335     0x94, 0x8b, 0x1e, 0x62, 0xdf, 0x31, 0x61, 0xcc, 0xf9, 0xfa, 0x66, 0x4f,
 336     0x18, 0x61, 0x07, 0xcb, 0x13, 0xd3, 0xf9, 0xbf, 0xe2, 0x8e, 0x25, 0x8d,
 337     0xd1, 0xdf, 0x58, 0x9c, 0x05, 0x20, 0xf9, 0xf2, 0x01, 0x20, 0xe9, 0x39,
 338     0xc3, 0x80, 0x77, 0xec, 0xa4, 0x57, 0xcf, 0x57, 0x8c, 0xdd, 0x68, 0x82,
 339     0x91, 0xfe, 0x71, 0xa0, 0xfa, 0x56, 0x4c, 0xf2, 0xe7, 0x2b, 0xd0, 0xc0,
 340     0xda, 0x81, 0xe2, 0x39, 0xb5, 0xf0, 0x0f, 0xd9, 0x07, 0xd5, 0x67, 0x09,
 341     0x02, 0xf0, 0xff, 0x74, 0xb0, 0xa0, 0xd9, 0x3a, 0x7e, 0xb6, 0x57, 0x82,
 342     0x47, 0x18, 0x66, 0xed, 0xe2, 0x18, 0x4d, 0xc2, 0x5c, 0x9f, 0x05, 0x09,
 343     0x18, 0x24, 0x0e, 0x3f, 0x3d, 0xf9, 0x15, 0x8b, 0x08, 0xfd, 0x25, 0xe9,
 344     0xc9, 0xb7, 0x8c, 0x18, 0x7b, 0xf3, 0x37, 0x58, 0xf0, 0xf0, 0xac, 0x33,
 345     0x55, 0x3f, 0x39, 0xbc, 0x62, 0x03, 0x8a, 0xc0, 0xd6, 0xcc, 0x49, 0x47,
 346     0xeb, 0x85, 0xb6, 0x72, 0xd7, 0xf8, 0xdc, 0x01, 0x32, 0xec, 0x1b, 0x4e,
 347     0x38, 0x6e, 0x2c, 0xc5, 0x80, 0xf2, 0x43, 0x4a, 0xf5, 0xe5, 0xa2, 0xf8,
 348     0x76, 0xa7, 0xa8, 0x57, 0x32, 0x67, 0x72, 0xeb, 0x82, 0xac, 0x3e, 0xc0,
 349     0x15, 0x67, 0xac, 0x32, 0x19, 0x18, 0x0a, 0xef, 0x20, 0xa1, 0xe8, 0xaf,
 350     0xac, 0x33, 0x87, 0x4c, 0x55, 0x05, 0x9b, 0x78, 0xf0, 0x3a, 0xce, 0x02,
 351     0x28, 0x06, 0x84, 0x61, 0x97, 0xac, 0x87, 0x8f, 0x25, 0xe7, 0x1b, 0xa3,
 352     0x02, 0x08, 0x4c, 0x2e, 0xef, 0xbd, 0x4f, 0x82, 0xe7, 0x37, 0x6c, 0x27,
 353     0x6f, 0x85, 0xb4, 0xbc, 0x79, 0x38, 0x45, 0x80, 0x8a, 0xda, 0x2f, 0x11,
 354     0x11, 0xac, 0x9c, 0xf3, 0x93, 0xc1, 0x49, 0x1b, 0x94, 0x12, 0x77, 0x07,
 355     0xdc, 0xbf, 0xc2, 0xfd, 0x8b, 0xf6, 0xf1, 0x66, 0x1c, 0x7f, 0x07, 0xbf,
 356     0x1f, 0xae, 0x27, 0x6c, 0x66, 0xe9, 0xa3, 0x64, 0x7a, 0x96, 0x78, 0x45,
 357     0xfe, 0x4b, 0x8c, 0x6f, 0x7f, 0x03, 0x47, 0x3c, 0xd7, 0xf7, 0x63, 0x92,
 358     0x58, 0x5b, 0x63, 0x83, 0x03, 0x05, 0xc3, 0x5d, 0x36, 0x62, 0x63, 0x5e,
 359     0xcf, 0xfe, 0x0a, 0x29, 0xfa, 0xeb, 0xc8, 0xaf, 0xce, 0x31, 0x07, 0x6a,
 360     0x09, 0x41, 0xc0, 0x2d, 0x98, 0x70, 0x05, 0x3b, 0x41, 0xfc, 0x7d, 0x61,
 361     0xe0, 0x41, 0x7d, 0x13, 0x41, 0x51, 0x52, 0xb4, 0x78, 0xd5, 0x46, 0x51,
 362     0x3b, 0xf1, 0xcd, 0xcc, 0x2e, 0x49, 0x30, 0x8b, 0x2a, 0xd2, 0xe6, 0x69,
 363     0xb5, 0x6b, 0x7a, 0xf4, 0xbb, 0xd1, 0xf8, 0x4a, 0xe8, 0x53, 0x10, 0x46,
 364     0x85, 0x8d, 0x66, 0x8e, 0x2b, 0xe8, 0x5d, 0xab, 0x7e, 0xfe, 0x5a, 0x79,
 365     0xcf, 0xc5, 0x0c, 0x30, 0x9e, 0x98, 0x02, 0xb3, 0xa6, 0xd5, 0xfa, 0x25,
 366     0xa8, 0xc8, 0xc1, 0xd9, 0x51, 0x60, 0x57, 0x5d, 0xfe, 0x75, 0x97, 0x05,
 367     0xda, 0xbb, 0xc6, 0x6a, 0xbe, 0x5c, 0xa5, 0x65, 0x0a, 0x12, 0x33, 0x1c,
 368     0xdf, 0xee, 0x08, 0xa9, 0x13, 0x13, 0x28, 0xce, 0x61, 0x59, 0xd1, 0x4e,
 369     0xc7, 0x74, 0xfd, 0x64, 0xde, 0x08, 0xce, 0xda, 0x3f, 0xec, 0xad, 0xc9,
 370     0xe1, 0xf9, 0x1f, 0x74, 0xf6, 0x86, 0x37, 0x6a, 0xa0, 0xc8, 0x0b, 0x1b,
 371     0x94, 0x98, 0x86, 0x81, 0x3b, 0xfc, 0x47, 0x6c, 0xc9, 0x3e, 0x3c, 0x30,
 372     0xc5, 0x9e, 0xb2, 0x32, 0x47, 0xf5, 0x0c, 0x6f,
 373
 374     /* Second Packet: Handshake */
 375     0xe6,                           /* Long, Handshake, PN Length=2 bytes */
 376     0x00, 0x00, 0x00, 0x01,         /* Version */
 377     0x00,                           /* DCID */
 378     0x04, 0x83, 0xd0, 0x0a, 0x27,   /* SCID */
 379     0x42, 0x9c,                     /* Length (668) */
 380     0x9c, 0x55,                     /* PN (0) */
 381     0x55, 0xd4, 0x50, 0x02, 0x1a, 0x57, 0x84, 0x22, 0xcd, 0x01, 0xe5, 0x42,
 382     0x1b, 0x1e, 0x06, 0xf1, 0x86, 0xe2, 0x90, 0xf8, 0x9c, 0x3d, 0xa2, 0x7c,
 383     0xde, 0x2b, 0xc9, 0x2e, 0xcd, 0xa8, 0x4f, 0x5a, 0x20, 0xca, 0x96, 0xb6,
 384     0x11, 0x4b, 0xc8, 0x71, 0x32, 0xb5, 0xc7, 0x1a, 0x69, 0x7f, 0x1e, 0x37,
 385     0x49, 0xfb, 0x08, 0xce, 0x83, 0x5f, 0x02, 0x6d, 0x8a, 0x8f, 0xe7, 0x5d,
 386     0xe1, 0x34, 0x31, 0x22, 0x53, 0x53, 0x32, 0xcb, 0x04, 0x21, 0xce, 0xbc,
 387     0xa5, 0x1b, 0xdd, 0x4d, 0xd5, 0x1c, 0xd6, 0x5d, 0x88, 0x29, 0x5a, 0x19,
 388     0x71, 0x6a, 0xc2, 0xfa, 0xb7, 0xb4, 0x7d, 0xd1, 0x72, 0x93, 0x8f, 0x7c,
 389     0xb5, 0x36, 0x1b, 0xea, 0xf3, 0xf1, 0xd7, 0x6e, 0xd3, 0x91, 0x96, 0x62,
 390     0x4d, 0xc6, 0xec, 0xb7, 0xb0, 0xb7, 0x9b, 0x95, 0x8b, 0x14, 0x8d, 0x1a,
 391     0x0d, 0xb6, 0x3e, 0xec, 0xfe, 0x3b, 0x51, 0xea, 0x1a, 0x05, 0x14, 0x12,
 392     0x93, 0x0e, 0x7e, 0xe6, 0xa2, 0xc5, 0x22, 0x87, 0x65, 0xf8, 0x5d, 0x3c,
 393     0x55, 0x18, 0xcb, 0xe9, 0xef, 0x23, 0x43, 0xfe, 0xe8, 0x0d, 0xb2, 0x0f,
 394     0xc5, 0xf4, 0xb3, 0xde, 0x0c, 0xea, 0xa4, 0x48, 0x8e, 0xbf, 0x1f, 0xc7,
 395     0x99, 0x53, 0x8c, 0xc1, 0x3d, 0xba, 0xf4, 0x8e, 0x8e, 0x02, 0x52, 0xf6,
 396     0x1f, 0xcf, 0x1d, 0xaa, 0xb3, 0xcb, 0x08, 0xc2, 0xe1, 0x70, 0x68, 0x74,
 397     0x78, 0xa9, 0x30, 0x67, 0xba, 0x2b, 0xea, 0x35, 0x63, 0x47, 0xff, 0x29,
 398     0x73, 0x29, 0xc6, 0xe8, 0x08, 0xa9, 0x1e, 0x8f, 0x28, 0x41, 0xa4, 0x24,
 399     0x54, 0x26, 0x5f, 0x42, 0x77, 0xb1, 0x2b, 0x3d, 0x65, 0x67, 0x60, 0xa7,
 400     0x23, 0x0d, 0xa7, 0xf4, 0xd6, 0xe9, 0x4e, 0x58, 0x43, 0x9f, 0x3c, 0x9e,
 401     0x77, 0x61, 0xe5, 0x04, 0x4f, 0x73, 0xc9, 0x10, 0x79, 0xd0, 0xda, 0x3b,
 402     0xc6, 0x19, 0x93, 0x9f, 0x48, 0x3b, 0x76, 0x38, 0xa1, 0x72, 0x49, 0x7d,
 403     0x86, 0x7f, 0xe8, 0x1b, 0xa9, 0x5b, 0xc0, 0x47, 0xa0, 0x9c, 0x3f, 0x65,
 404     0x60, 0x76, 0x59, 0xaf, 0x20, 0x2d, 0x40, 0xa6, 0x80, 0x49, 0x5a, 0x8f,
 405     0x09, 0xf8, 0xf6, 0x97, 0xc1, 0xbd, 0xe1, 0x9f, 0x9b, 0xa2, 0x4c, 0x7b,
 406     0x88, 0xac, 0xbe, 0x4b, 0x11, 0x28, 0xd7, 0x67, 0xe6, 0xad, 0xaf, 0xd0,
 407     0xad, 0x01, 0x29, 0xa4, 0x4a, 0xc4, 0xb8, 0x2e, 0x42, 0x79, 0x24, 0x9e,
 408     0xd5, 0x34, 0xae, 0x45, 0xf1, 0x0b, 0x38, 0x4a, 0x76, 0xfb, 0x50, 0xa2,
 409     0x99, 0xc9, 0x5b, 0x6d, 0xc0, 0xb7, 0x55, 0xd8, 0x8d, 0x49, 0xdd, 0x1b,
 410     0xb8, 0xec, 0x10, 0x57, 0x9e, 0x33, 0xb4, 0x10, 0x16, 0x19, 0xac, 0x69,
 411     0xa2, 0x19, 0x1b, 0xd0, 0x77, 0x45, 0xeb, 0x49, 0x5c, 0xc5, 0x7c, 0xbe,
 412     0x4b, 0x4a, 0x22, 0x5c, 0x3d, 0x0e, 0x6e, 0xe5, 0x4b, 0x36, 0x06, 0x63,
 413     0x03, 0x97, 0xab, 0xed, 0xdc, 0xea, 0x64, 0xc2, 0x70, 0xb6, 0x7e, 0x35,
 414     0xfb, 0x13, 0x66, 0x37, 0xa3, 0x3f, 0x28, 0x16, 0x6c, 0xe7, 0xd4, 0xe6,
 415     0xca, 0x26, 0x0f, 0x19, 0xdd, 0x02, 0xae, 0xc1, 0xcf, 0x18, 0x7d, 0x56,
 416     0xe6, 0x52, 0xf3, 0x37, 0xb5, 0x86, 0x9d, 0x1d, 0x55, 0xb3, 0x95, 0x19,
 417     0x19, 0xa5, 0x44, 0x95, 0x81, 0xed, 0x02, 0x18, 0xf1, 0x85, 0x57, 0x78,
 418     0x28, 0xc4, 0x9a, 0xba, 0xe8, 0x5e, 0x22, 0x8d, 0xc1, 0x7b, 0x2a, 0x8a,
 419     0xc8, 0xb9, 0xdd, 0x82, 0xb2, 0x7b, 0x9f, 0x3d, 0xf5, 0x27, 0x2a, 0x48,
 420     0x53, 0xc7, 0xa0, 0x70, 0x0e, 0x9d, 0x61, 0xaa, 0xe2, 0xad, 0x28, 0xf2,
 421     0xb4, 0xfc, 0x56, 0x6b, 0x89, 0xe7, 0xf9, 0x51, 0xc9, 0xe9, 0xd3, 0x8a,
 422     0x8c, 0x7e, 0x86, 0xdd, 0xba, 0x2f, 0x39, 0xbf, 0x26, 0x62, 0x23, 0xd6,
 423     0x98, 0x6d, 0x3e, 0x72, 0xd7, 0x1b, 0xe1, 0x62, 0x94, 0x35, 0xe2, 0x18,
 424     0x19, 0x46, 0xb8, 0x2c, 0xb5, 0x8f, 0x8f, 0xb0, 0x5b, 0x76, 0x7b, 0x7e,
 425     0xb8, 0xc6, 0xb7, 0xe9, 0x4e, 0x9d, 0x30, 0x68, 0x03, 0x1e, 0x19, 0x73,
 426     0xc5, 0x3e, 0x24, 0xe2, 0x95, 0x60, 0x1b, 0x27, 0x93, 0x7c, 0x17, 0xc2,
 427     0xc6, 0xa3, 0xbd, 0xbd, 0x70, 0xc6, 0x60, 0x59, 0xc8, 0x5c, 0xd7, 0x9a,
 428     0xc4, 0x29, 0xac, 0x0f, 0xaa, 0x0d, 0xa9, 0x92, 0xa3, 0x95, 0xd7, 0x0f,
 429     0x6f, 0x74, 0x99, 0x9b, 0xc1, 0xd3, 0x68, 0x6d, 0xac, 0x82, 0x2d, 0x32,
 430     0x41, 0x9e, 0x0c, 0xf7, 0x31, 0x59, 0x4c, 0x93, 0x1c, 0x3b, 0x71, 0x69,
 431     0xcf, 0xc5, 0xca, 0x2b, 0xdf, 0xe7, 0xaa, 0xfd, 0x1d, 0x71, 0x01, 0x7e,
 432     0x1c, 0x70, 0x62, 0x20, 0x61, 0xf8, 0x35, 0xc1, 0x71, 0xe7, 0x02, 0x0d,
 433     0x88, 0x44, 0xd9, 0x00, 0xc5, 0xcc, 0x63, 0xe4, 0xf0, 0x86, 0xa7, 0xd0,
 434     0xfe, 0xcc, 0xb7, 0x1d, 0xfc, 0x21, 0x61, 0x54, 0x15, 0xea, 0x81, 0x5e,
 435     0xc0, 0x31, 0xfa, 0xbf, 0x7d, 0xb9, 0x3b, 0xa2, 0x1e, 0x42, 0x73, 0x05,
 436     0x3c, 0xdb, 0x21, 0x59, 0x4f, 0x63,
 437
 438     /* Third Packet: 1-RTT */
 439     0x5f,               /* Short, 1-RTT, Spin=0, KP=0, PN Length=2 bytes */
 440     0x68, 0x47,         /* PN (0) */
 441     0xa3, 0x3c, 0xa5, 0x27, 0x5e, 0xf9, 0x8d, 0xec, 0xea, 0x6c, 0x09, 0x18,
 442     0x40, 0x80, 0xee, 0x9f, 0x6f, 0x73, 0x5c, 0x49, 0xe3, 0xec, 0xb7, 0x58,
 443     0x05, 0x66, 0x8f, 0xa3, 0x52, 0x37, 0xa1, 0x22, 0x1f, 0xc6, 0x92, 0xd6,
 444     0x59, 0x04, 0x99, 0xcb, 0x44, 0xef, 0x66, 0x05, 0x2d, 0xd0, 0x85, 0x24,
 445     0xbb, 0xe3, 0xa1, 0xd1, 0xbe, 0xf7, 0x54, 0xad, 0x65, 0xf4, 0xd4, 0x59,
 446     0x54, 0x87, 0x4e, 0x22, 0x4f, 0x06, 0x07, 0xa7, 0x8a, 0x14, 0x89, 0xd1,
 447     0x3f, 0xd3, 0xe4, 0x6f, 0x71, 0x8f, 0x9a, 0xd2, 0x3b, 0x61, 0x0a, 0xba,
 448     0x9a, 0x31, 0x56, 0xc7,
 449 };
 450
 451 static const QUIC_PKT_HDR rx_script_5a_expect_hdr = {
 452     QUIC_PKT_TYPE_INITIAL,
 453     0,          /* Spin Bit */
 454     0,          /* Key Phase */
 455     2,          /* PN Length */
 456     0,          /* Partial */
 457     1,          /* Fixed */
 458     1,          /* Version */
 459     {0, {0}},                           /* DCID */
 460     {4, {0x83, 0xd0, 0x0a, 0x27}},      /* SCID */
 461     {0},        /* PN */
 462     NULL, 0,    /* Token/Token Len */
 463     448, NULL
 464 };
 465
 466 static const unsigned char rx_script_5a_body[] = {
 467     0x02, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 468     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 469     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 470     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 471     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 472     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 473     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 474     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 475     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 476     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 477     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 478     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 479     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 480     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 481     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 482     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 483     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 484     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 485     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 486     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 487     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 488     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 489     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 490     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 491     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 492     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 493     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 494     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 495     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 496     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x40, 0x5a, 0x02, 0x00,
 497     0x00, 0x56, 0x03, 0x03, 0xe2, 0xd2, 0x0a, 0x3b, 0xa2, 0xc4, 0xd2, 0x29,
 498     0xc8, 0xe8, 0xba, 0x23, 0x31, 0x88, 0x2c, 0x71, 0xeb, 0xba, 0x42, 0x5f,
 499     0x94, 0xe9, 0x0a, 0x90, 0x35, 0x31, 0x1e, 0xca, 0xed, 0xf8, 0x8a, 0x8d,
 500     0x00, 0x13, 0x01, 0x00, 0x00, 0x2e, 0x00, 0x2b, 0x00, 0x02, 0x03, 0x04,
 501     0x00, 0x33, 0x00, 0x24, 0x00, 0x1d, 0x00, 0x20, 0x96, 0x0b, 0x4b, 0x30,
 502     0x66, 0x3a, 0x75, 0x01, 0x4a, 0xdc, 0x2a, 0x75, 0x1f, 0xce, 0x7a, 0x30,
 503     0x9d, 0x00, 0xca, 0x20, 0xb4, 0xe0, 0x6b, 0x81, 0x23, 0x18, 0x0b, 0x20,
 504     0x1f, 0x54, 0x86, 0x1d,
 505 };
 506
 507 static const QUIC_PKT_HDR rx_script_5b_expect_hdr = {
 508     QUIC_PKT_TYPE_HANDSHAKE,
 509     0,          /* Spin Bit */
 510     0,          /* Key Phase */
 511     2,          /* PN Length */
 512     0,          /* Partial */
 513     1,          /* Fixed */
 514     1,          /* Version */
 515     {0, {0}},                           /* DCID */
 516     {4, {0x83, 0xd0, 0x0a, 0x27}},      /* SCID */
 517     {0},        /* PN */
 518     NULL, 0,    /* Token/Token Len */
 519     650, NULL
 520 };
 521
 522 static const unsigned char rx_script_5b_body[] = {
 523     0x06, 0x00, 0x42, 0x86, 0x08, 0x00, 0x00, 0x7d, 0x00, 0x7b, 0x00, 0x10,
 524     0x00, 0x08, 0x00, 0x06, 0x05, 0x64, 0x75, 0x6d, 0x6d, 0x79, 0x00, 0x39,
 525     0x00, 0x6b, 0x4b, 0x20, 0x0b, 0x1b, 0xe1, 0x1f, 0xd0, 0x78, 0xc0, 0x69,
 526     0x72, 0x9c, 0xe2, 0xf7, 0x05, 0x04, 0x80, 0x08, 0x00, 0x00, 0x06, 0x04,
 527     0x80, 0x08, 0x00, 0x00, 0x07, 0x04, 0x80, 0x08, 0x00, 0x00, 0x04, 0x04,
 528     0x80, 0x0c, 0x00, 0x00, 0x08, 0x02, 0x40, 0x64, 0x09, 0x02, 0x40, 0x64,
 529     0x01, 0x04, 0x80, 0x00, 0x75, 0x30, 0x03, 0x02, 0x45, 0xac, 0x0b, 0x01,
 530     0x1a, 0x0c, 0x00, 0x02, 0x10, 0x41, 0x94, 0x41, 0x8d, 0x0d, 0xfb, 0x60,
 531     0x7b, 0xdc, 0xcc, 0xa2, 0x9c, 0x3e, 0xa5, 0xdf, 0x8d, 0x00, 0x08, 0x2d,
 532     0x71, 0x8a, 0x38, 0xdf, 0xdd, 0xe0, 0x03, 0x0e, 0x01, 0x04, 0x0f, 0x04,
 533     0x83, 0xd0, 0x0a, 0x27, 0x10, 0x04, 0xad, 0x15, 0x3f, 0xae, 0x20, 0x01,
 534     0x00, 0x0b, 0x00, 0x01, 0x8f, 0x00, 0x00, 0x01, 0x8b, 0x00, 0x01, 0x86,
 535     0x30, 0x82, 0x01, 0x82, 0x30, 0x82, 0x01, 0x29, 0xa0, 0x03, 0x02, 0x01,
 536     0x02, 0x02, 0x14, 0x0a, 0x73, 0x0f, 0x86, 0x18, 0xf2, 0xc3, 0x30, 0x01,
 537     0xd2, 0xc0, 0xc1, 0x62, 0x52, 0x13, 0xf1, 0x9c, 0x13, 0x39, 0xb5, 0x30,
 538     0x0a, 0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x04, 0x03, 0x02, 0x30,
 539     0x17, 0x31, 0x15, 0x30, 0x13, 0x06, 0x03, 0x55, 0x04, 0x03, 0x0c, 0x0c,
 540     0x6d, 0x61, 0x70, 0x61, 0x6b, 0x74, 0x2e, 0x6c, 0x6f, 0x63, 0x61, 0x6c,
 541     0x30, 0x1e, 0x17, 0x0d, 0x32, 0x32, 0x30, 0x38, 0x30, 0x32, 0x31, 0x32,
 542     0x30, 0x30, 0x31, 0x38, 0x5a, 0x17, 0x0d, 0x32, 0x32, 0x30, 0x39, 0x30,
 543     0x31, 0x31, 0x32, 0x30, 0x30, 0x31, 0x38, 0x5a, 0x30, 0x17, 0x31, 0x15,
 544     0x30, 0x13, 0x06, 0x03, 0x55, 0x04, 0x03, 0x0c, 0x0c, 0x6d, 0x61, 0x70,
 545     0x61, 0x6b, 0x74, 0x2e, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x30, 0x59, 0x30,
 546     0x13, 0x06, 0x07, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x02, 0x01, 0x06, 0x08,
 547     0x2a, 0x86, 0x48, 0xce, 0x3d, 0x03, 0x01, 0x07, 0x03, 0x42, 0x00, 0x04,
 548     0x67, 0xf4, 0xd3, 0x8f, 0x15, 0x6d, 0xee, 0x85, 0xcc, 0x2a, 0x77, 0xfc,
 549     0x0b, 0x8f, 0x9f, 0xcf, 0xa9, 0x95, 0x5d, 0x5b, 0xcd, 0xb7, 0x8b, 0xba,
 550     0x31, 0x0a, 0x73, 0x62, 0xc5, 0xd0, 0x0e, 0x07, 0x90, 0xae, 0x38, 0x43,
 551     0x79, 0xce, 0x5e, 0x33, 0xad, 0x31, 0xbf, 0x9f, 0x2a, 0x56, 0x83, 0xa5,
 552     0x24, 0x16, 0xab, 0x0c, 0xf1, 0x64, 0xbe, 0xe4, 0x93, 0xb5, 0x89, 0xd6,
 553     0x05, 0xe4, 0xf7, 0x7b, 0xa3, 0x53, 0x30, 0x51, 0x30, 0x1d, 0x06, 0x03,
 554     0x55, 0x1d, 0x0e, 0x04, 0x16, 0x04, 0x14, 0x02, 0x64, 0x0f, 0x55, 0x69,
 555     0x14, 0x91, 0x19, 0xed, 0xf9, 0x1a, 0xe9, 0x1d, 0xa5, 0x5a, 0xd0, 0x48,
 556     0x96, 0x9f, 0x60, 0x30, 0x1f, 0x06, 0x03, 0x55, 0x1d, 0x23, 0x04, 0x18,
 557     0x30, 0x16, 0x80, 0x14, 0x02, 0x64, 0x0f, 0x55, 0x69, 0x14, 0x91, 0x19,
 558     0xed, 0xf9, 0x1a, 0xe9, 0x1d, 0xa5, 0x5a, 0xd0, 0x48, 0x96, 0x9f, 0x60,
 559     0x30, 0x0f, 0x06, 0x03, 0x55, 0x1d, 0x13, 0x01, 0x01, 0xff, 0x04, 0x05,
 560     0x30, 0x03, 0x01, 0x01, 0xff, 0x30, 0x0a, 0x06, 0x08, 0x2a, 0x86, 0x48,
 561     0xce, 0x3d, 0x04, 0x03, 0x02, 0x03, 0x47, 0x00, 0x30, 0x44, 0x02, 0x20,
 562     0x0a, 0x82, 0x92, 0x6e, 0xd3, 0xc6, 0x66, 0xd9, 0xd3, 0x75, 0xff, 0x71,
 563     0x3b, 0x61, 0x46, 0x21, 0x00, 0xe6, 0x21, 0x5d, 0x9c, 0x86, 0xe9, 0x65,
 564     0x40, 0x4f, 0xeb, 0x70, 0x4f, 0x2c, 0xad, 0x00, 0x02, 0x20, 0x08, 0xc2,
 565     0x07, 0x5d, 0x16, 0xfc, 0x54, 0x34, 0x2b, 0xb4, 0x18, 0x67, 0x44, 0x81,
 566     0xc9, 0xa9, 0x67, 0x2e, 0xce, 0xa1, 0x02, 0x9f, 0x3b, 0xe5, 0x61, 0x16,
 567     0x0b, 0x50, 0xf6, 0xa1, 0x50, 0x94, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x4a,
 568     0x04, 0x03, 0x00, 0x46, 0x30, 0x44, 0x02, 0x20, 0x7d, 0x57, 0x17, 0x14,
 569     0x46, 0x09, 0x95, 0x70, 0x09, 0x45, 0xe8, 0x9e, 0x5c, 0x87, 0x55, 0xd9,
 570     0x08, 0xc6, 0x5e, 0x47, 0x73, 0x5e, 0xb1, 0xc9, 0xef, 0xcb, 0xe5, 0x7f,
 571     0xcc, 0xb0, 0x28, 0xbc, 0x02, 0x20, 0x5d, 0xe4, 0x2b, 0x83, 0xd9, 0x78,
 572     0x75, 0x45, 0xf3, 0x22, 0x2b, 0x38, 0xeb, 0x68, 0xe5, 0x71, 0x5d, 0xcb,
 573     0xc3, 0x68, 0xb3, 0x0e, 0x7d, 0x5e, 0x1d, 0xc2, 0x1b, 0x8a, 0x62, 0x80,
 574     0x48, 0x3e, 0x14, 0x00, 0x00, 0x20, 0x37, 0xcd, 0x55, 0xca, 0x3f, 0x4b,
 575     0xf0, 0x95, 0xf8, 0xe4, 0xfe, 0x59, 0xab, 0xbc, 0xc1, 0x8f, 0x0c, 0x3f,
 576     0x41, 0x59, 0xf6, 0x96, 0xdb, 0x75, 0xae, 0xe7, 0x86, 0x1a, 0x92, 0xa7,
 577     0x53, 0x0a,
 578 };
 579
 580 static const QUIC_PKT_HDR rx_script_5c_expect_hdr = {
 581     QUIC_PKT_TYPE_1RTT,
 582     0,          /* Spin Bit */
 583     0,          /* Key Phase */
 584     2,          /* PN Length */
 585     0,          /* Partial */
 586     1,          /* Fixed */
 587     0,          /* Version */
 588     {0, {0}},                           /* DCID */
 589     {0, {0}},                           /* SCID */
 590     {0},        /* PN */
 591     NULL, 0,    /* Token/Token Len */
 592     72, NULL
 593 };
 594
 595 static const unsigned char rx_script_5c_body[] = {
 596     0x18, 0x03, 0x00, 0x04, 0x92, 0xec, 0xaa, 0xd6, 0x47, 0xd8, 0x8b, 0x56,
 597     0x3b, 0x5f, 0x67, 0xe6, 0xb9, 0xb9, 0xca, 0x72, 0xca, 0xf2, 0x49, 0x7d,
 598     0x18, 0x02, 0x00, 0x04, 0xa9, 0x6e, 0x9b, 0x84, 0x26, 0x43, 0x00, 0xc7,
 599     0x55, 0x71, 0x67, 0x2e, 0x52, 0xdd, 0x47, 0xfd, 0x06, 0x51, 0x33, 0x08,
 600     0x18, 0x01, 0x00, 0x04, 0x36, 0xd5, 0x1f, 0x06, 0x4e, 0xbf, 0xb4, 0xc9,
 601     0xef, 0x97, 0x1e, 0x9a, 0x3c, 0xab, 0x1e, 0xfc, 0xb7, 0x90, 0xc3, 0x1a,
 602 };
 603
 604 static const struct rx_test_op rx_script_5[] = {
 605     RX_OP_ADD_RX_DCID(empty_conn_id)
 606     RX_OP_PROVIDE_SECRET_INITIAL(rx_script_5_c2s_init_dcid)
 607     RX_OP_INJECT_N(5)
 608     RX_OP_CHECK_PKT_FRAMES_OK_N(5a)
 609     RX_OP_CHECK_NO_PKT() /* not got secret for next packet yet */
 610     RX_OP_PROVIDE_SECRET(QUIC_ENC_LEVEL_HANDSHAKE,
 611                       QRL_SUITE_AES128GCM, rx_script_5_handshake_secret)
 612     RX_OP_CHECK_PKT_FRAMES_OK_N(5b)
 613     RX_OP_CHECK_NO_PKT() /* not got secret for next packet yet */
 614     RX_OP_PROVIDE_SECRET(QUIC_ENC_LEVEL_1RTT,
 615                       QRL_SUITE_AES128GCM, rx_script_5_1rtt_secret)
 616     RX_OP_CHECK_PKT_FRAMES_OK_N(5c)
 617     RX_OP_CHECK_NO_PKT()
 618
 619     /* Try injecting the packet again */
 620     RX_OP_INJECT_N(5)
 621     /*
 622      * Initial packet is not output due to receiving a Handshake packet causing
 623      * auto-discard of Initial keys
 624      */
 625     RX_OP_CHECK_PKT_FRAMES_OK_N(5b)
 626     RX_OP_CHECK_PKT_FRAMES_OK_N(5c)
 627     RX_OP_CHECK_NO_PKT()
 628     /* Try again with discarded keys */
 629     RX_OP_DISCARD_EL(QUIC_ENC_LEVEL_HANDSHAKE)
 630     RX_OP_INJECT_N(5)
 631     RX_OP_CHECK_PKT_FRAMES_OK_N(5c)
 632     RX_OP_CHECK_NO_PKT()
 633     /* Try again */
 634     RX_OP_INJECT_N(5)
 635     RX_OP_CHECK_PKT_FRAMES_OK_N(5c)
 636     RX_OP_CHECK_NO_PKT()
 637     /* Try again with discarded 1-RTT keys */
 638     RX_OP_DISCARD_EL(QUIC_ENC_LEVEL_1RTT)
 639     RX_OP_INJECT_N(5)
 640     RX_OP_CHECK_NO_PKT()
 641
 642     /* Recreate QRL, test reading packets received before key */
 643     RX_OP_SET_SCID_LEN(0)
 644     RX_OP_ADD_RX_DCID(empty_conn_id)
 645     RX_OP_INJECT_N(5)
 646     RX_OP_CHECK_NO_PKT()
 647     RX_OP_PROVIDE_SECRET_INITIAL(rx_script_5_c2s_init_dcid)
 648     RX_OP_CHECK_PKT_FRAMES_OK_N(5a)
 649     RX_OP_CHECK_NO_PKT()
 650     RX_OP_PROVIDE_SECRET(QUIC_ENC_LEVEL_HANDSHAKE,
 651                       QRL_SUITE_AES128GCM, rx_script_5_handshake_secret)
 652     RX_OP_CHECK_PKT_FRAMES_OK_N(5b)
 653     RX_OP_CHECK_NO_PKT()
 654     RX_OP_PROVIDE_SECRET(QUIC_ENC_LEVEL_1RTT,
 655                       QRL_SUITE_AES128GCM, rx_script_5_1rtt_secret)
 656     RX_OP_CHECK_PKT_FRAMES_OK_N(5c)
 657     RX_OP_CHECK_NO_PKT()
 658
 659     RX_OP_DISCARD_EL(QUIC_ENC_LEVEL_HANDSHAKE)
 660     RX_OP_DISCARD_EL(QUIC_ENC_LEVEL_1RTT)
 661     RX_OP_INJECT_N(5)
 662     RX_OP_CHECK_NO_PKT()
 663
 664     RX_OP_END
 665 };
 666
 667 /*
 668  * 6. Real World - S2C Multiple Packets
 669  *      - Initial, Handshake, 1-RTT (AES-256-GCM/SHA384)
 670  */
 671 static const QUIC_CONN_ID rx_script_6_c2s_init_dcid = {
 672     4, {0xac, 0x88, 0x95, 0xbd}
 673 };
 674
 675 static const unsigned char rx_script_6_handshake_secret[48] = {
 676     0xd1, 0x41, 0xb0, 0xf6, 0x0d, 0x8b, 0xbd, 0xe8, 0x5b, 0xa8, 0xff, 0xd7,
 677     0x18, 0x9a, 0x23, 0x7b, 0x13, 0x5c, 0x1e, 0x90, 0x1d, 0x08, 0x95, 0xcc,
 678     0xc5, 0x8e, 0x73, 0x4e, 0x02, 0x6f, 0x3c, 0xb6, 0x26, 0x77, 0x8d, 0x53,
 679     0xc5, 0x62, 0x9f, 0xb5, 0xf0, 0x88, 0xfb, 0xe5, 0x14, 0x71, 0xab, 0xe6,
 680 };
 681
 682 static const unsigned char rx_script_6_1rtt_secret[48] = {
 683     0x2d, 0x6b, 0x9d, 0xd4, 0x39, 0xa0, 0xe7, 0xff, 0x17, 0xe2, 0xcb, 0x5c,
 684     0x0d, 0x4a, 0xf6, 0x3f, 0xf4, 0xfe, 0xfc, 0xe5, 0x22, 0xfa, 0xf5, 0x5b,
 685     0xc0, 0xb2, 0x18, 0xbb, 0x92, 0x4d, 0x35, 0xea, 0x67, 0xa6, 0xe7, 0xc1,
 686     0x90, 0x10, 0xc9, 0x14, 0x46, 0xf5, 0x95, 0x57, 0x8b, 0x90, 0x88, 0x5d,
 687 };
 688
 689 static const unsigned char rx_script_6_in[] = {
 690     /* First Packet: Initial */
 691     0xc5,                           /* Long, Initial, PN Length=2 bytes */
 692     0x00, 0x00, 0x00, 0x01,         /* Version */
 693     0x00,                           /* DCID */
 694     0x04, 0x36, 0xf4, 0x75, 0x2d,   /* SCID */
 695     0x00,                           /* Token Length */
 696     0x41, 0xbe,                     /* Length (446) */
 697     0xa9, 0xe2,                     /* PN (0) */
 698     0x83, 0x39, 0x95, 0x8f, 0x8f, 0x8c, 0xa9, 0xaf, 0x10, 0x29, 0x3d, 0xfc,
 699     0x56, 0x4a, 0x1c, 0x4b, 0xc9, 0x48, 0xb1, 0xaf, 0x36, 0xd5, 0xac, 0x95,
 700     0xbf, 0xfd, 0x2c, 0x4d, 0x70, 0x2e, 0x5b, 0x7c, 0x22, 0x5f, 0x5f, 0xee,
 701     0x10, 0x8f, 0xfb, 0x0b, 0x5f, 0x9d, 0x7e, 0x68, 0x2f, 0x94, 0x0b, 0xdb,
 702     0xed, 0xef, 0xfa, 0x4e, 0xc6, 0xd5, 0xe7, 0xef, 0xe0, 0x78, 0x3c, 0xdc,
 703     0xe9, 0xd8, 0xe8, 0x56, 0x71, 0xd7, 0xe7, 0x6c, 0x7f, 0x5d, 0xaa, 0x7a,
 704     0x52, 0x1d, 0x95, 0x7a, 0x80, 0x70, 0x38, 0xc0, 0x8b, 0xa1, 0x2f, 0x09,
 705     0x16, 0xd2, 0xec, 0xa3, 0x23, 0x72, 0x45, 0x3c, 0xbd, 0x8c, 0xda, 0xbb,
 706     0x37, 0x5a, 0x8d, 0xb2, 0x00, 0x7e, 0x67, 0x0c, 0xa0, 0x32, 0xdd, 0x80,
 707     0x07, 0x71, 0xb0, 0x95, 0x21, 0xbc, 0x1e, 0xbd, 0x63, 0x0a, 0x10, 0xe7,
 708     0x4b, 0x6e, 0x2e, 0x85, 0x3a, 0x65, 0xf7, 0x06, 0x6e, 0x7e, 0x8f, 0x65,
 709     0x8c, 0xb1, 0x93, 0xe9, 0x0d, 0xe8, 0x46, 0xe7, 0xcf, 0xa7, 0xd2, 0x8b,
 710     0x15, 0x23, 0xec, 0xc3, 0xec, 0x44, 0xda, 0x62, 0x15, 0x35, 0x34, 0x2f,
 711     0x62, 0x77, 0xc8, 0x1f, 0x83, 0x22, 0x00, 0xe5, 0xc0, 0x89, 0xb8, 0x97,
 712     0xd2, 0x37, 0x02, 0xea, 0xa2, 0x35, 0xbf, 0x19, 0xf0, 0xba, 0x1d, 0xb7,
 713     0xaa, 0x36, 0xbb, 0x11, 0x60, 0xc3, 0x45, 0x1f, 0xe5, 0x18, 0xde, 0x4c,
 714     0x01, 0x23, 0x2d, 0x17, 0x78, 0xdd, 0x4c, 0x8a, 0x1e, 0x1b, 0xd4, 0xda,
 715     0x56, 0x43, 0x13, 0xa4, 0x4f, 0xfd, 0xd5, 0x92, 0x6a, 0x05, 0x5f, 0x14,
 716     0x63, 0x85, 0x7d, 0xf1, 0x31, 0xb8, 0x27, 0x0b, 0xa6, 0xb5, 0x50, 0xca,
 717     0x8b, 0x0e, 0xa1, 0x0d, 0xf9, 0xc4, 0xea, 0x6a, 0x6e, 0x4b, 0x6d, 0xdf,
 718     0x49, 0xe8, 0x32, 0xf6, 0x85, 0xc4, 0x29, 0x26, 0x32, 0xfb, 0x5e, 0xa8,
 719     0x55, 0x6b, 0x67, 0xe9, 0xaa, 0x35, 0x33, 0x90, 0xd8, 0x2a, 0x71, 0x0b,
 720     0x6a, 0x48, 0xc4, 0xa3, 0x8b, 0xe0, 0xe7, 0x00, 0x3d, 0xee, 0x30, 0x70,
 721     0x84, 0xbd, 0xa3, 0x3c, 0x9e, 0xa3, 0x5c, 0x69, 0xab, 0x55, 0x7b, 0xe2,
 722     0xe5, 0x86, 0x13, 0xcb, 0x93, 0x3f, 0xcb, 0x3e, 0x6d, 0xc9, 0xc2, 0x10,
 723     0x2b, 0x00, 0x9b, 0x3f, 0x14, 0x4e, 0x04, 0x27, 0xc0, 0xae, 0x1d, 0x48,
 724     0x89, 0x3a, 0xf4, 0xac, 0xe0, 0x05, 0x07, 0xc9, 0x74, 0x6e, 0x21, 0x01,
 725     0xe9, 0x26, 0xfd, 0xb4, 0xb2, 0x2a, 0xda, 0x72, 0xda, 0xbf, 0x63, 0x9d,
 726     0x37, 0xaf, 0x90, 0x05, 0xd6, 0x89, 0xc7, 0xa6, 0x81, 0x4e, 0x2a, 0x30,
 727     0xe3, 0x05, 0x88, 0x9f, 0xd0, 0xba, 0x8d, 0xc4, 0x21, 0x52, 0x5a, 0x7a,
 728     0xe1, 0xad, 0xd3, 0x88, 0xc2, 0x18, 0xad, 0x4c, 0xb1, 0x66, 0x73, 0x1b,
 729     0xf2, 0xd1, 0xb9, 0x43, 0xaa, 0xc4, 0x66, 0xcd, 0x42, 0xfa, 0x80, 0xec,
 730     0xa1, 0x7c, 0x45, 0x02, 0x53, 0x45, 0xd5, 0x07, 0xd4, 0x70, 0x12, 0x1b,
 731     0x08, 0x05, 0x6e, 0x99, 0x0a, 0xd3, 0x5b, 0x99, 0x6b, 0x65, 0xc4, 0xc0,
 732     0x04, 0x1b, 0x75, 0xf2, 0x86, 0x99, 0x09, 0x4a, 0x50, 0x70, 0x00, 0x7a,
 733     0x93, 0xaa, 0xe6, 0xf4, 0x03, 0x29, 0x06, 0xa4, 0x30, 0x6d, 0x52, 0xbd,
 734     0x60, 0xd1, 0x7e, 0xd6, 0x07, 0xc0, 0x41, 0x01, 0x12, 0x3e, 0x16, 0x94,
 735
 736     /* Second Packet: Handshake */
 737     0xea,                           /* Long, Handshake, PN Length=2 bytes */
 738     0x00, 0x00, 0x00, 0x01,         /* Version */
 739     0x00,                           /* DCID */
 740     0x04, 0x36, 0xf4, 0x75, 0x2d,   /* SCID */
 741     0x42, 0xb0,                     /* Length (688) */
 742     0x3a, 0xc5,                     /* PN (0) */
 743     0x3b, 0x8e, 0x4c, 0x01, 0x72, 0x6b, 0xfa, 0xbb, 0xad, 0xf9, 0x9e, 0x21,
 744     0xb1, 0xd0, 0x01, 0xf1, 0xd4, 0x67, 0x8d, 0x2c, 0xee, 0x04, 0x60, 0x4a,
 745     0xe2, 0xe4, 0xc6, 0x89, 0x01, 0xae, 0x3c, 0x1f, 0xf7, 0xe6, 0xf7, 0xac,
 746     0x26, 0xcf, 0x3c, 0x6d, 0x1d, 0xfd, 0x11, 0x02, 0x51, 0x73, 0xb5, 0xe1,
 747     0xb2, 0x44, 0x42, 0x32, 0x0f, 0xf5, 0x3d, 0x55, 0x2d, 0x1f, 0x02, 0x29,
 748     0x51, 0x35, 0xdb, 0xc7, 0x7a, 0x34, 0x4b, 0xec, 0x60, 0x49, 0xa2, 0x90,
 749     0x11, 0xef, 0x5a, 0xa9, 0x1c, 0xf7, 0xd9, 0x21, 0x68, 0x1c, 0x2b, 0xc6,
 750     0x57, 0xde, 0xb1, 0x0b, 0x31, 0xed, 0xef, 0x16, 0xba, 0x08, 0xb9, 0xe2,
 751     0xd9, 0xd0, 0xd8, 0x1f, 0xc4, 0x32, 0xe8, 0x45, 0x2a, 0x86, 0xe4, 0xd3,
 752     0xaf, 0x72, 0x4f, 0x30, 0x01, 0x71, 0x15, 0x9b, 0xa9, 0x55, 0x35, 0xf7,
 753     0x39, 0x7e, 0x6a, 0x59, 0x18, 0x4f, 0xe6, 0xdf, 0xb5, 0x0d, 0xc2, 0xe7,
 754     0xb2, 0xa1, 0xa6, 0xa3, 0x9c, 0xf0, 0x0d, 0x59, 0x05, 0x49, 0x95, 0xfa,
 755     0xcc, 0x72, 0xd7, 0xc0, 0x84, 0x2e, 0xc4, 0x1c, 0xd4, 0xa0, 0xe3, 0x6c,
 756     0x5a, 0x8c, 0x94, 0x4d, 0x37, 0x1a, 0x1c, 0x68, 0x93, 0x5f, 0xe5, 0x99,
 757     0x27, 0xc6, 0x06, 0xaa, 0x1f, 0x29, 0x17, 0xc5, 0x8c, 0x3d, 0x53, 0xa7,
 758     0x05, 0x3a, 0x44, 0x53, 0x86, 0xed, 0x56, 0x99, 0x4c, 0xe2, 0x7b, 0x3a,
 759     0x1e, 0x5d, 0x6d, 0xac, 0x78, 0x1e, 0xfa, 0x55, 0x58, 0x6e, 0x72, 0xee,
 760     0xf9, 0x33, 0x64, 0x7f, 0x93, 0x3c, 0xfe, 0x18, 0x97, 0x6b, 0x02, 0x74,
 761     0x90, 0x0d, 0xba, 0x89, 0xc0, 0x22, 0x0a, 0x0a, 0x37, 0x4c, 0x28, 0x74,
 762     0xa7, 0x3a, 0x44, 0x74, 0x42, 0xff, 0xf1, 0xd2, 0x8d, 0x0c, 0xc1, 0xed,
 763     0x98, 0x98, 0x8e, 0xa8, 0x6b, 0x95, 0x6a, 0x86, 0x0b, 0xb4, 0x95, 0x58,
 764     0x34, 0x12, 0xb0, 0xc0, 0xf8, 0x2d, 0x5b, 0x40, 0x51, 0x80, 0x07, 0x91,
 765     0x31, 0x77, 0xd3, 0x06, 0xa5, 0xe5, 0x1f, 0xe2, 0xf8, 0x92, 0xe4, 0x23,
 766     0x2b, 0xf0, 0x4c, 0xa9, 0xa5, 0x6c, 0x6f, 0xaf, 0xaf, 0xbf, 0x97, 0xcf,
 767     0x46, 0xf2, 0x8d, 0x61, 0x0e, 0x73, 0xcd, 0xc5, 0xde, 0xda, 0x50, 0x82,
 768     0x61, 0x6d, 0xb1, 0xa2, 0xbe, 0x6b, 0x99, 0xcd, 0x5b, 0x99, 0x8f, 0x66,
 769     0xab, 0x11, 0x78, 0xcc, 0xdb, 0x66, 0x98, 0xca, 0x19, 0x92, 0xf4, 0x05,
 770     0xae, 0xe6, 0xf3, 0xe7, 0xf0, 0x30, 0x28, 0x31, 0x74, 0xff, 0xe2, 0xb3,
 771     0x3a, 0x4f, 0x79, 0xe7, 0x2a, 0x9f, 0xe3, 0x41, 0xb2, 0x88, 0xc8, 0x8f,
 772     0x77, 0x57, 0x42, 0x65, 0xdb, 0x07, 0xf6, 0x5f, 0xb8, 0x34, 0x17, 0xe3,
 773     0x8d, 0x22, 0x5b, 0x88, 0x94, 0x60, 0x97, 0x32, 0x3d, 0x8a, 0x51, 0x9d,
 774     0xb5, 0xac, 0xd7, 0x99, 0x96, 0x23, 0x6d, 0xc9, 0xab, 0x61, 0x41, 0x8f,
 775     0x72, 0x1b, 0xf8, 0x84, 0xd9, 0x57, 0x88, 0x68, 0x3d, 0x73, 0x5f, 0xb1,
 776     0x18, 0x5c, 0x3a, 0x35, 0xd2, 0xc5, 0xb7, 0x29, 0xc7, 0x95, 0xdd, 0x21,
 777     0xc0, 0x78, 0x49, 0xf3, 0x24, 0xe0, 0x4c, 0x5c, 0x32, 0x08, 0xb7, 0x00,
 778     0x43, 0x70, 0x5a, 0x95, 0x23, 0x91, 0xf5, 0xb7, 0x61, 0x85, 0x6f, 0xb3,
 779     0xa4, 0x6b, 0x05, 0x9d, 0x39, 0xa3, 0xb1, 0x1c, 0x61, 0xc5, 0xa5, 0xe7,
 780     0x9a, 0xe9, 0x5d, 0xaa, 0xca, 0x11, 0xd8, 0x4b, 0xa4, 0x9c, 0x18, 0x4e,
 781     0x2b, 0x2d, 0x75, 0xc1, 0x12, 0x20, 0xe4, 0x66, 0xa5, 0x59, 0x67, 0x4b,
 782     0xcc, 0x52, 0x2d, 0xfa, 0xaa, 0xa4, 0xe9, 0xfc, 0x79, 0xd7, 0xff, 0x03,
 783     0x3e, 0xec, 0xba, 0x97, 0x37, 0x52, 0xc1, 0x57, 0x31, 0x8e, 0x57, 0x0c,
 784     0x54, 0x92, 0x9c, 0x25, 0x5c, 0xfa, 0x9f, 0xa5, 0x36, 0x18, 0xd0, 0xaa,
 785     0xf3, 0x3b, 0x5b, 0x59, 0xbd, 0x33, 0x5e, 0x7d, 0x74, 0x7c, 0xaf, 0xe9,
 786     0x54, 0x80, 0xc4, 0xb4, 0xa1, 0x24, 0x9e, 0x23, 0x0d, 0xbf, 0x4e, 0x0f,
 787     0xaf, 0xa5, 0x16, 0xcb, 0x3b, 0xfa, 0x33, 0xa5, 0x68, 0xa6, 0x64, 0x48,
 788     0x2f, 0x5e, 0xfa, 0x64, 0x4e, 0xe3, 0x27, 0x4f, 0x13, 0xe6, 0x37, 0xf6,
 789     0xb9, 0x63, 0x4b, 0xdc, 0x49, 0x3c, 0x5e, 0x9e, 0x06, 0xea, 0xac, 0xa3,
 790     0xdf, 0x6c, 0x49, 0xfb, 0xa1, 0x01, 0x4f, 0x6f, 0x74, 0x1f, 0xd3, 0x26,
 791     0xa1, 0x92, 0x3e, 0xe0, 0x73, 0xd6, 0x3b, 0x67, 0x13, 0x53, 0x2e, 0xcb,
 792     0xbc, 0x83, 0xd0, 0x6e, 0x28, 0xb1, 0xcb, 0xd9, 0x66, 0xe0, 0x33, 0x59,
 793     0x45, 0xd3, 0x13, 0xc2, 0x48, 0xd5, 0x9e, 0x88, 0xba, 0x75, 0x7b, 0xb1,
 794     0xfe, 0x6f, 0xec, 0xde, 0xff, 0x14, 0x59, 0x75, 0xbf, 0x1a, 0x74, 0x47,
 795     0xc5, 0xd8, 0xe8, 0x1b, 0x3c, 0x86, 0xd7, 0x1f, 0x99, 0x11, 0xd3, 0x29,
 796     0xfd, 0x5d, 0x22, 0x7e, 0x03, 0x78, 0xed, 0x62, 0x0e, 0xbe, 0x6d, 0x75,
 797     0xf4, 0xa8, 0x6e, 0xc7, 0x21, 0x76, 0xc5, 0xa0, 0x0c, 0xaa, 0x58, 0x78,
 798     0x7e, 0x6e, 0xfc, 0x1e, 0x2a, 0x1c, 0xdd, 0xe5, 0x78, 0x08, 0xbd, 0xdb,
 799     0xea, 0x8f, 0x8a, 0xa5, 0xbf, 0x93, 0xfe, 0x0f, 0x03, 0xa1, 0xc8, 0x64,
 800     0x9f, 0x4a,
 801
 802     /* Third Packet: 1-RTT */
 803     0x48,               /* Short, 1-RTT, Spin=0, KP=0, PN Length=2 bytes */
 804     0x3e, 0x28,         /* PN (0) */
 805     0xb9, 0xdb, 0x61, 0xf8, 0x8b, 0x3a, 0xef, 0x26, 0x69, 0xf2, 0x57, 0xc6,
 806     0x84, 0x25, 0x6b, 0x77, 0xbe, 0x8c, 0x43, 0x32, 0xf3, 0x9a, 0xd1, 0x85,
 807     0x14, 0xbc, 0x89, 0x3b, 0x9c, 0xf3, 0xfc, 0x00, 0xa1, 0x3a, 0xc3, 0xc4,
 808     0x1e, 0xdf, 0xd0, 0x11, 0x70, 0xd9, 0x02, 0x7a, 0xd4, 0xef, 0x86, 0x67,
 809     0xb1, 0x1e, 0x5d, 0xe3, 0x7f, 0x82, 0x14, 0x52, 0xa5, 0x8a, 0x89, 0xa7,
 810     0x98, 0x75, 0x2f, 0x8a, 0x00, 0xf3, 0xbd, 0x49, 0x26, 0x4d, 0x0c, 0xc7,
 811     0x38, 0xe7, 0x91, 0x85, 0xc9, 0x21, 0x6a, 0x1c, 0xc4, 0xa3, 0x0e, 0xd8,
 812     0xfe, 0xb1, 0x25, 0x1a,
 813 };
 814
 815 static const QUIC_PKT_HDR rx_script_6a_expect_hdr = {
 816     QUIC_PKT_TYPE_INITIAL,
 817     0,          /* Spin Bit */
 818     0,          /* Key Phase */
 819     2,          /* PN Length */
 820     0,          /* Partial */
 821     1,          /* Fixed */
 822     1,          /* Version */
 823     {0, {0}},                           /* DCID */
 824     {4, {0x36, 0xf4, 0x75, 0x2d}},      /* SCID */
 825     {0},        /* PN */
 826     NULL, 0,    /* Token/Token Len */
 827     428, NULL
 828 };
 829
 830 static const unsigned char rx_script_6a_body[] = {
 831     0x02, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 832     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 833     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 834     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 835     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 836     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 837     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 838     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 839     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 840     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 841     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 842     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 843     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 844     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 845     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 846     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 847     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 848     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 849     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 850     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 851     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 852     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 853     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 854     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 855     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 856     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 857     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 858     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00,
 859     0x40, 0x5a, 0x02, 0x00, 0x00, 0x56, 0x03, 0x03, 0xc3, 0x45, 0xe8, 0xb8,
 860     0xf9, 0x7c, 0x9f, 0x5d, 0xcf, 0x66, 0x25, 0xe4, 0x91, 0x0e, 0xb0, 0x5a,
 861     0x14, 0xce, 0xaf, 0xea, 0x83, 0x12, 0xde, 0x68, 0xd9, 0x31, 0xf2, 0x23,
 862     0x11, 0x3a, 0x15, 0xcb, 0x00, 0x13, 0x02, 0x00, 0x00, 0x2e, 0x00, 0x2b,
 863     0x00, 0x02, 0x03, 0x04, 0x00, 0x33, 0x00, 0x24, 0x00, 0x1d, 0x00, 0x20,
 864     0xab, 0xd3, 0xc6, 0x9f, 0x36, 0xd3, 0x52, 0x93, 0x87, 0xee, 0x92, 0x01,
 865     0xa2, 0xd6, 0x9a, 0x5e, 0x61, 0x43, 0xcc, 0x4a, 0xcc, 0x7a, 0xcd, 0x83,
 866     0xb2, 0xd9, 0xad, 0xd1, 0x14, 0xdc, 0x84, 0x61,
 867 };
 868
 869 static const QUIC_PKT_HDR rx_script_6b_expect_hdr = {
 870     QUIC_PKT_TYPE_HANDSHAKE,
 871     0,          /* Spin Bit */
 872     0,          /* Key Phase */
 873     2,          /* PN Length */
 874     0,          /* Partial */
 875     1,          /* Fixed */
 876     1,          /* Version */
 877     {0, {0}},                           /* DCID */
 878     {4, {0x36, 0xf4, 0x75, 0x2d}},      /* SCID */
 879     {0},        /* PN */
 880     NULL, 0,    /* Token/Token Len */
 881     670, NULL
 882 };
 883
 884 static const unsigned char rx_script_6b_body[] = {
 885     0x06, 0x00, 0x42, 0x9a, 0x08, 0x00, 0x00, 0x80, 0x00, 0x7e, 0x00, 0x10,
 886     0x00, 0x08, 0x00, 0x06, 0x05, 0x64, 0x75, 0x6d, 0x6d, 0x79, 0x00, 0x39,
 887     0x00, 0x6e, 0x47, 0xfa, 0x05, 0x5a, 0xe0, 0xec, 0x4a, 0xf3, 0x05, 0x04,
 888     0x80, 0x08, 0x00, 0x00, 0x06, 0x04, 0x80, 0x08, 0x00, 0x00, 0x07, 0x04,
 889     0x80, 0x08, 0x00, 0x00, 0x04, 0x04, 0x80, 0x0c, 0x00, 0x00, 0x08, 0x02,
 890     0x40, 0x64, 0x09, 0x02, 0x40, 0x64, 0x01, 0x04, 0x80, 0x00, 0x75, 0x30,
 891     0x03, 0x02, 0x45, 0xac, 0x0b, 0x01, 0x1a, 0x0c, 0x00, 0x02, 0x10, 0x35,
 892     0xd7, 0x7d, 0x8b, 0xc5, 0xb1, 0x89, 0xb1, 0x5c, 0x23, 0x74, 0x50, 0xfd,
 893     0x47, 0xfe, 0xd2, 0x00, 0x11, 0x96, 0x38, 0x27, 0xde, 0x7d, 0xfb, 0x2b,
 894     0x38, 0x56, 0xe5, 0x2a, 0xb8, 0x6b, 0xfa, 0xaa, 0xde, 0x81, 0x0e, 0x01,
 895     0x04, 0x0f, 0x04, 0x36, 0xf4, 0x75, 0x2d, 0x10, 0x04, 0xac, 0x88, 0x95,
 896     0xbd, 0x20, 0x01, 0x00, 0x0b, 0x00, 0x01, 0x8f, 0x00, 0x00, 0x01, 0x8b,
 897     0x00, 0x01, 0x86, 0x30, 0x82, 0x01, 0x82, 0x30, 0x82, 0x01, 0x29, 0xa0,
 898     0x03, 0x02, 0x01, 0x02, 0x02, 0x14, 0x0a, 0x73, 0x0f, 0x86, 0x18, 0xf2,
 899     0xc3, 0x30, 0x01, 0xd2, 0xc0, 0xc1, 0x62, 0x52, 0x13, 0xf1, 0x9c, 0x13,
 900     0x39, 0xb5, 0x30, 0x0a, 0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x04,
 901     0x03, 0x02, 0x30, 0x17, 0x31, 0x15, 0x30, 0x13, 0x06, 0x03, 0x55, 0x04,
 902     0x03, 0x0c, 0x0c, 0x6d, 0x61, 0x70, 0x61, 0x6b, 0x74, 0x2e, 0x6c, 0x6f,
 903     0x63, 0x61, 0x6c, 0x30, 0x1e, 0x17, 0x0d, 0x32, 0x32, 0x30, 0x38, 0x30,
 904     0x32, 0x31, 0x32, 0x30, 0x30, 0x31, 0x38, 0x5a, 0x17, 0x0d, 0x32, 0x32,
 905     0x30, 0x39, 0x30, 0x31, 0x31, 0x32, 0x30, 0x30, 0x31, 0x38, 0x5a, 0x30,
 906     0x17, 0x31, 0x15, 0x30, 0x13, 0x06, 0x03, 0x55, 0x04, 0x03, 0x0c, 0x0c,
 907     0x6d, 0x61, 0x70, 0x61, 0x6b, 0x74, 0x2e, 0x6c, 0x6f, 0x63, 0x61, 0x6c,
 908     0x30, 0x59, 0x30, 0x13, 0x06, 0x07, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x02,
 909     0x01, 0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x03, 0x01, 0x07, 0x03,
 910     0x42, 0x00, 0x04, 0x67, 0xf4, 0xd3, 0x8f, 0x15, 0x6d, 0xee, 0x85, 0xcc,
 911     0x2a, 0x77, 0xfc, 0x0b, 0x8f, 0x9f, 0xcf, 0xa9, 0x95, 0x5d, 0x5b, 0xcd,
 912     0xb7, 0x8b, 0xba, 0x31, 0x0a, 0x73, 0x62, 0xc5, 0xd0, 0x0e, 0x07, 0x90,
 913     0xae, 0x38, 0x43, 0x79, 0xce, 0x5e, 0x33, 0xad, 0x31, 0xbf, 0x9f, 0x2a,
 914     0x56, 0x83, 0xa5, 0x24, 0x16, 0xab, 0x0c, 0xf1, 0x64, 0xbe, 0xe4, 0x93,
 915     0xb5, 0x89, 0xd6, 0x05, 0xe4, 0xf7, 0x7b, 0xa3, 0x53, 0x30, 0x51, 0x30,
 916     0x1d, 0x06, 0x03, 0x55, 0x1d, 0x0e, 0x04, 0x16, 0x04, 0x14, 0x02, 0x64,
 917     0x0f, 0x55, 0x69, 0x14, 0x91, 0x19, 0xed, 0xf9, 0x1a, 0xe9, 0x1d, 0xa5,
 918     0x5a, 0xd0, 0x48, 0x96, 0x9f, 0x60, 0x30, 0x1f, 0x06, 0x03, 0x55, 0x1d,
 919     0x23, 0x04, 0x18, 0x30, 0x16, 0x80, 0x14, 0x02, 0x64, 0x0f, 0x55, 0x69,
 920     0x14, 0x91, 0x19, 0xed, 0xf9, 0x1a, 0xe9, 0x1d, 0xa5, 0x5a, 0xd0, 0x48,
 921     0x96, 0x9f, 0x60, 0x30, 0x0f, 0x06, 0x03, 0x55, 0x1d, 0x13, 0x01, 0x01,
 922     0xff, 0x04, 0x05, 0x30, 0x03, 0x01, 0x01, 0xff, 0x30, 0x0a, 0x06, 0x08,
 923     0x2a, 0x86, 0x48, 0xce, 0x3d, 0x04, 0x03, 0x02, 0x03, 0x47, 0x00, 0x30,
 924     0x44, 0x02, 0x20, 0x0a, 0x82, 0x92, 0x6e, 0xd3, 0xc6, 0x66, 0xd9, 0xd3,
 925     0x75, 0xff, 0x71, 0x3b, 0x61, 0x46, 0x21, 0x00, 0xe6, 0x21, 0x5d, 0x9c,
 926     0x86, 0xe9, 0x65, 0x40, 0x4f, 0xeb, 0x70, 0x4f, 0x2c, 0xad, 0x00, 0x02,
 927     0x20, 0x08, 0xc2, 0x07, 0x5d, 0x16, 0xfc, 0x54, 0x34, 0x2b, 0xb4, 0x18,
 928     0x67, 0x44, 0x81, 0xc9, 0xa9, 0x67, 0x2e, 0xce, 0xa1, 0x02, 0x9f, 0x3b,
 929     0xe5, 0x61, 0x16, 0x0b, 0x50, 0xf6, 0xa1, 0x50, 0x94, 0x00, 0x00, 0x0f,
 930     0x00, 0x00, 0x4b, 0x04, 0x03, 0x00, 0x47, 0x30, 0x45, 0x02, 0x20, 0x78,
 931     0x9e, 0xe0, 0x6a, 0x7a, 0xbd, 0xc3, 0x84, 0x3d, 0x25, 0x6a, 0x59, 0x23,
 932     0x97, 0x52, 0x64, 0x4e, 0xb6, 0x9f, 0xcc, 0xd3, 0xd7, 0xa9, 0x29, 0x44,
 933     0x75, 0x6d, 0x50, 0xfc, 0x22, 0xde, 0xd3, 0x02, 0x21, 0x00, 0xe5, 0x28,
 934     0xd6, 0x5a, 0xd1, 0xec, 0x4a, 0xcc, 0x20, 0xb4, 0xea, 0x15, 0xfb, 0x8e,
 935     0x73, 0xa8, 0x6b, 0xbb, 0x42, 0x70, 0x90, 0x08, 0x6e, 0x74, 0x6f, 0x5a,
 936     0x05, 0xb5, 0x39, 0xee, 0x01, 0x04, 0x14, 0x00, 0x00, 0x30, 0xff, 0x9f,
 937     0xb2, 0x1d, 0xcb, 0x4f, 0xfc, 0x7a, 0xac, 0xf4, 0x75, 0x24, 0x83, 0x5f,
 938     0x8d, 0xa3, 0x3e, 0x9d, 0xef, 0x43, 0x67, 0x89, 0x5d, 0x55, 0xc7, 0xce,
 939     0x80, 0xab, 0xc3, 0xc7, 0x74, 0xc7, 0xb2, 0x91, 0x27, 0xce, 0xd8, 0x5e,
 940     0xc4, 0x4e, 0x96, 0x19, 0x68, 0x2d, 0xbe, 0x6f, 0x49, 0xfa,
 941 };
 942
 943 static const QUIC_PKT_HDR rx_script_6c_expect_hdr = {
 944     QUIC_PKT_TYPE_1RTT,
 945     0,          /* Spin Bit */
 946     0,          /* Key Phase */
 947     2,          /* PN Length */
 948     0,          /* Partial */
 949     1,          /* Fixed */
 950     0,          /* Version */
 951     {0, {0}},                           /* DCID */
 952     {0, {0}},                           /* SCID */
 953     {0},        /* PN */
 954     NULL, 0,    /* Token/Token Len */
 955     72, NULL
 956 };
 957
 958 static const unsigned char rx_script_6c_body[] = {
 959     0x18, 0x03, 0x00, 0x04, 0xf2, 0x94, 0x49, 0xc3, 0x34, 0xa1, 0xf4, 0x0f,
 960     0xcb, 0xb8, 0x03, 0x04, 0x1f, 0xc8, 0x69, 0xb9, 0x3b, 0xd5, 0xc6, 0x93,
 961     0x18, 0x02, 0x00, 0x04, 0x9a, 0x4f, 0xec, 0x52, 0xde, 0xd2, 0xc8, 0xb7,
 962     0x1c, 0x0c, 0xf3, 0x4e, 0x46, 0xf0, 0x6c, 0x54, 0x34, 0x1b, 0x0d, 0x98,
 963     0x18, 0x01, 0x00, 0x04, 0xe3, 0x33, 0x9e, 0x59, 0x00, 0x69, 0xc3, 0xac,
 964     0xfc, 0x58, 0x0e, 0xa4, 0xf4, 0xf3, 0x23, 0x1b, 0xd6, 0x8e, 0x5b, 0x08,
 965 };
 966
 967 static const struct rx_test_op rx_script_6[] = {
 968     RX_OP_ADD_RX_DCID(empty_conn_id)
 969     RX_OP_PROVIDE_SECRET_INITIAL(rx_script_6_c2s_init_dcid)
 970     RX_OP_INJECT_N(6)
 971     RX_OP_CHECK_PKT_FRAMES_OK_N(6a)
 972     RX_OP_CHECK_NO_PKT() /* not got secret for next packet yet */
 973     RX_OP_PROVIDE_SECRET(QUIC_ENC_LEVEL_HANDSHAKE,
 974                       QRL_SUITE_AES256GCM, rx_script_6_handshake_secret)
 975     RX_OP_CHECK_PKT_FRAMES_OK_N(6b)
 976     RX_OP_CHECK_NO_PKT() /* not got secret for next packet yet */
 977     RX_OP_PROVIDE_SECRET(QUIC_ENC_LEVEL_1RTT,
 978                       QRL_SUITE_AES256GCM, rx_script_6_1rtt_secret)
 979     RX_OP_CHECK_PKT_FRAMES_OK_N(6c)
 980     RX_OP_CHECK_NO_PKT()
 981
 982     /* Try injecting the packet again */
 983     RX_OP_INJECT_N(6)
 984     /*
 985      * Initial packet is not output due to receiving a Handshake packet causing
 986      * auto-discard of Initial keys
 987      */
 988     RX_OP_CHECK_PKT_FRAMES_OK_N(6b)
 989     RX_OP_CHECK_PKT_FRAMES_OK_N(6c)
 990     RX_OP_CHECK_NO_PKT()
 991     /* Try again with discarded keys */
 992     RX_OP_DISCARD_EL(QUIC_ENC_LEVEL_HANDSHAKE)
 993     RX_OP_INJECT_N(6)
 994     RX_OP_CHECK_PKT_FRAMES_OK_N(6c)
 995     RX_OP_CHECK_NO_PKT()
 996     /* Try again */
 997     RX_OP_INJECT_N(6)
 998     RX_OP_CHECK_PKT_FRAMES_OK_N(6c)
 999     RX_OP_CHECK_NO_PKT()
1000     /* Try again with discarded 1-RTT keys */
1001     RX_OP_DISCARD_EL(QUIC_ENC_LEVEL_1RTT)
1002     RX_OP_INJECT_N(6)
1003     RX_OP_CHECK_NO_PKT()
1004
1005     /* Recreate QRL, test reading packets received before key */
1006     RX_OP_SET_SCID_LEN(0)
1007     RX_OP_ADD_RX_DCID(empty_conn_id)
1008     RX_OP_INJECT_N(6)
1009     RX_OP_CHECK_NO_PKT()
1010     RX_OP_PROVIDE_SECRET_INITIAL(rx_script_6_c2s_init_dcid)
1011     RX_OP_CHECK_PKT_FRAMES_OK_N(6a)
1012     RX_OP_CHECK_NO_PKT()
1013     RX_OP_PROVIDE_SECRET(QUIC_ENC_LEVEL_HANDSHAKE,
1014                       QRL_SUITE_AES256GCM, rx_script_6_handshake_secret)
1015     RX_OP_CHECK_PKT_FRAMES_OK_N(6b)
1016     RX_OP_CHECK_NO_PKT()
1017     RX_OP_PROVIDE_SECRET(QUIC_ENC_LEVEL_1RTT,
1018                       QRL_SUITE_AES256GCM, rx_script_6_1rtt_secret)
1019     RX_OP_CHECK_PKT_FRAMES_OK_N(6c)
1020     RX_OP_CHECK_NO_PKT()
1021
1022     RX_OP_END
1023 };
1024
1025 /*
1026  * 7. Real World - S2C Multiple Packets
1027  *      - Initial, Handshake, 1-RTT (ChaCha20-Poly1305)
1028  */
1029 #ifndef OPENSSL_NO_CHACHA
1030 static const QUIC_CONN_ID rx_script_7_c2s_init_dcid = {
1031     4, {0xfa, 0x5d, 0xd6, 0x80}
1032 };
1033
1034 static const unsigned char rx_script_7_handshake_secret[32] = {
1035     0x85, 0x44, 0xa4, 0x02, 0x46, 0x5b, 0x2a, 0x92, 0x80, 0x71, 0xfd, 0x11,
1036     0x89, 0x73, 0x84, 0xeb, 0x3e, 0x0d, 0x89, 0x4f, 0x71, 0xdc, 0x9c, 0xdd,
1037     0x55, 0x77, 0x9e, 0x79, 0x7b, 0xeb, 0xfa, 0x86,
1038 };
1039
1040 static const unsigned char rx_script_7_1rtt_secret[32] = {
1041     0x4a, 0x77, 0xb6, 0x0e, 0xfd, 0x90, 0xca, 0xbf, 0xc0, 0x1a, 0x64, 0x9f,
1042     0xc0, 0x03, 0xd3, 0x8d, 0xc5, 0x41, 0x04, 0x50, 0xb1, 0x5b, 0x74, 0xe7,
1043     0xe3, 0x99, 0x0c, 0xdf, 0x74, 0x61, 0x35, 0xe6,
1044 };
1045
1046 static const unsigned char rx_script_7_in[] = {
1047     /* First Packet: Initial */
1048     0xc2,                           /* Long, Initial, PN Length=2 bytes */
1049     0x00, 0x00, 0x00, 0x01,         /* Version */
1050     0x00,                           /* DCID */
1051     0x04, 0x03, 0x45, 0x0c, 0x7a,   /* SCID */
1052     0x00,                           /* Token Length */
1053     0x41, 0xcb,                     /* Length (459) */
1054     0x3c, 0xe0,                     /* PN (0) */
1055     0x85, 0x05, 0xc2, 0x4d, 0x0f, 0xf3, 0x62, 0x51, 0x04, 0x33, 0xfa, 0xb5,
1056     0xa3, 0x02, 0xbd, 0x5c, 0x22, 0x0c, 0x1d, 0xda, 0x06, 0xf1, 0xd7, 0xe0,
1057     0xc8, 0x56, 0xb0, 0x3d, 0xc1, 0x49, 0x8c, 0xc2, 0x88, 0x5a, 0x0e, 0xd5,
1058     0x67, 0x72, 0xec, 0xcc, 0x7a, 0x2b, 0x46, 0x17, 0x49, 0x4b, 0x28, 0x6a,
1059     0x89, 0x71, 0xfd, 0x31, 0x9a, 0xa1, 0x97, 0x64, 0xe2, 0xbf, 0xa0, 0x6d,
1060     0xf6, 0x76, 0x83, 0x28, 0xc4, 0xd5, 0x39, 0x87, 0x22, 0x7c, 0x11, 0x9a,
1061     0x53, 0x66, 0xb4, 0x27, 0xf1, 0xab, 0x6f, 0x49, 0x43, 0x3f, 0x9a, 0x23,
1062     0xd3, 0x53, 0x06, 0xe8, 0x14, 0xfd, 0xc0, 0x67, 0x1f, 0x88, 0x2a, 0xa8,
1063     0xae, 0x5f, 0x05, 0x0a, 0xeb, 0x66, 0x72, 0x8c, 0x46, 0xcc, 0x54, 0x21,
1064     0x5e, 0x14, 0xfe, 0x68, 0xc7, 0xf7, 0x60, 0x67, 0xb5, 0xa7, 0x0d, 0xf4,
1065     0xe1, 0xff, 0x60, 0xe3, 0x11, 0x38, 0x92, 0x90, 0xc2, 0x48, 0x28, 0xbf,
1066     0xf3, 0x85, 0x27, 0xfe, 0xbf, 0x42, 0x26, 0x1a, 0x4e, 0x78, 0xf1, 0xf0,
1067     0x88, 0x16, 0x1b, 0x64, 0x5f, 0x66, 0x02, 0x0b, 0x45, 0x3d, 0x38, 0xd9,
1068     0x09, 0xd5, 0xff, 0xc2, 0x68, 0x02, 0x2c, 0xc4, 0x3f, 0x60, 0x6e, 0x2f,
1069     0x7f, 0x43, 0xf7, 0x1a, 0x37, 0xcc, 0xe0, 0xe0, 0x4b, 0x96, 0xc1, 0xb1,
1070     0x8b, 0x1c, 0x7c, 0x6e, 0x80, 0xe3, 0x92, 0x9b, 0x86, 0x87, 0x1f, 0x9a,
1071     0x6a, 0x62, 0x18, 0xf4, 0x86, 0xc2, 0x3e, 0x33, 0xa3, 0xbf, 0x43, 0x96,
1072     0x6e, 0xff, 0x94, 0xaf, 0x6d, 0x23, 0x5c, 0x42, 0xed, 0xe7, 0xb9, 0x2c,
1073     0x33, 0xb0, 0xc6, 0x3d, 0x44, 0x00, 0x0b, 0xa3, 0x39, 0xa8, 0xeb, 0x8c,
1074     0x81, 0x1a, 0x99, 0x20, 0xbd, 0xfa, 0xf3, 0xf4, 0xf0, 0x11, 0xd8, 0x41,
1075     0x31, 0x8d, 0xdc, 0x0d, 0x00, 0xa6, 0x31, 0x40, 0xc6, 0xc6, 0xad, 0x74,
1076     0x93, 0x62, 0x1c, 0x55, 0xce, 0x5f, 0x8c, 0x5b, 0x3c, 0xcb, 0x25, 0x5e,
1077     0xbf, 0xed, 0xbb, 0x3c, 0x97, 0x4b, 0x62, 0xe0, 0xba, 0xf1, 0xb0, 0x30,
1078     0xbf, 0x35, 0x89, 0x7e, 0x25, 0x61, 0x54, 0x86, 0x52, 0x11, 0x86, 0x90,
1079     0xc3, 0xf5, 0xad, 0xa0, 0x96, 0x30, 0xb2, 0xf0, 0xa6, 0x79, 0x39, 0x1c,
1080     0x51, 0x42, 0xa1, 0x00, 0x6f, 0x55, 0x7d, 0xdc, 0xd0, 0x7c, 0xcf, 0x01,
1081     0x88, 0x03, 0xd7, 0x2d, 0x65, 0x2b, 0x40, 0xee, 0xba, 0x10, 0xd8, 0x0c,
1082     0x85, 0x14, 0xb7, 0x4d, 0x9e, 0x7d, 0x7c, 0xde, 0x7f, 0x0d, 0x0e, 0x3b,
1083     0x3d, 0xe3, 0xd3, 0x63, 0xc2, 0xed, 0xc7, 0x41, 0xaf, 0x05, 0x85, 0x87,
1084     0x46, 0x55, 0x7e, 0xbe, 0x14, 0x5b, 0x98, 0xae, 0x6e, 0x67, 0x1a, 0x65,
1085     0xc6, 0xcf, 0xe1, 0x28, 0x50, 0x6b, 0xb4, 0xf6, 0xba, 0x63, 0xbc, 0xf1,
1086     0xd7, 0xa4, 0x97, 0x2d, 0x4d, 0x04, 0x26, 0x96, 0xec, 0x0c, 0xd4, 0xae,
1087     0x6a, 0xca, 0x7e, 0x65, 0xc5, 0x43, 0x7e, 0xf8, 0x77, 0x61, 0xd0, 0x2c,
1088     0xe5, 0x37, 0x0a, 0xb3, 0x7a, 0x8c, 0x2a, 0xa1, 0xdc, 0x29, 0xdb, 0xec,
1089     0xca, 0xdc, 0xfe, 0xdd, 0x38, 0xd2, 0x13, 0x9f, 0x94, 0x6d, 0x5b, 0x87,
1090     0xf3, 0x15, 0xa8, 0xe5, 0xe9, 0x65, 0x1d, 0x4f, 0x92, 0x1b, 0xf4, 0xa6,
1091     0xa4, 0xd6, 0x22, 0xfc, 0x26, 0x1b, 0x35, 0xa4, 0x1c, 0x88, 0x9f, 0x7d,
1092     0xe0, 0x9a, 0x89, 0x0f, 0x6c, 0xc1, 0xda, 0x6e, 0x45, 0xce, 0x74, 0xb1,
1093     0xff,
1094
1095     /* Second Packet: Handshake */
1096     0xeb,                           /* Long, Handshake, PN Length=2 bytes */
1097     0x00, 0x00, 0x00, 0x01,         /* Version */
1098     0x00,                           /* DCID */
1099     0x04, 0x03, 0x45, 0x0c, 0x7a,   /* SCID */
1100     0x42, 0xa3,                     /* Length (675) */
1101     0x43, 0x29,                     /* PN (0) */
1102     0xff, 0xdb, 0xcf, 0x3c, 0x17, 0xcf, 0xdc, 0x42, 0x3a, 0x59, 0x88, 0xdb,
1103     0x13, 0xef, 0x09, 0x3d, 0xf2, 0x24, 0xf3, 0xeb, 0xca, 0xb0, 0xe1, 0xa4,
1104     0x67, 0x64, 0x65, 0x80, 0x5f, 0x73, 0x29, 0x69, 0x29, 0xba, 0x03, 0x77,
1105     0x22, 0xc8, 0xa8, 0xd5, 0x21, 0xf2, 0xa2, 0x30, 0x7f, 0x86, 0x3a, 0x8a,
1106     0xdd, 0x92, 0x33, 0xa6, 0x57, 0x21, 0x39, 0xdd, 0x34, 0xb4, 0x39, 0xa7,
1107     0x6f, 0x0a, 0x14, 0xba, 0x9e, 0x3b, 0x3a, 0x6a, 0x4b, 0xc5, 0xda, 0x44,
1108     0x82, 0xca, 0x52, 0x86, 0x68, 0x8a, 0x0c, 0x5e, 0xeb, 0x1e, 0x81, 0x43,
1109     0x3a, 0x59, 0x2c, 0x26, 0x63, 0xa3, 0x89, 0x92, 0x80, 0xe9, 0x75, 0xc2,
1110     0xdb, 0xb9, 0x58, 0x6d, 0xab, 0xfd, 0x21, 0xe0, 0x35, 0x79, 0x2e, 0x56,
1111     0x7b, 0xfb, 0xb3, 0x7a, 0x05, 0x33, 0x0f, 0x13, 0xe5, 0xef, 0x04, 0x41,
1112     0x69, 0x85, 0x91, 0x24, 0xce, 0xb5, 0x21, 0x8d, 0x0a, 0x13, 0xda, 0xae,
1113     0x86, 0x2f, 0x25, 0x1f, 0x9c, 0x70, 0x8a, 0xaa, 0x05, 0xeb, 0x30, 0x93,
1114     0x50, 0xc1, 0x39, 0xab, 0x99, 0x8a, 0x31, 0xc1, 0xc1, 0x5e, 0x39, 0xcf,
1115     0x64, 0x3f, 0x9f, 0x5c, 0xa5, 0xa1, 0x88, 0xb2, 0x5f, 0x23, 0xcb, 0x76,
1116     0xe5, 0xf3, 0x2d, 0xa0, 0xed, 0xad, 0xcf, 0x30, 0x05, 0x44, 0xdc, 0xa5,
1117     0x81, 0xb1, 0x7f, 0x78, 0x0d, 0x4d, 0x96, 0xa3, 0xcb, 0xcb, 0x45, 0xcf,
1118     0x5f, 0x22, 0xb8, 0x93, 0x2b, 0x16, 0xe0, 0x1c, 0x53, 0x34, 0x76, 0x3b,
1119     0x7b, 0x78, 0xa1, 0x46, 0x40, 0x43, 0x4b, 0x0e, 0x1c, 0xfd, 0xcf, 0x01,
1120     0xf1, 0x2c, 0xee, 0xd0, 0xbd, 0x9f, 0x44, 0xd2, 0xd7, 0x13, 0xf9, 0x65,
1121     0x82, 0xf5, 0x42, 0xec, 0x9f, 0x5d, 0x51, 0x5a, 0x7b, 0xf2, 0x39, 0xbb,
1122     0xa6, 0x19, 0x5c, 0x73, 0x95, 0x65, 0x5b, 0x64, 0x2f, 0xda, 0x50, 0xd0,
1123     0x02, 0x34, 0x3f, 0x35, 0xc1, 0xd6, 0x31, 0x3b, 0xcf, 0x3f, 0x81, 0x8d,
1124     0xe0, 0x40, 0xfd, 0x6d, 0x32, 0x68, 0xa4, 0xf2, 0x4e, 0x3a, 0x4a, 0x42,
1125     0x2c, 0x07, 0x2d, 0x27, 0xa3, 0x34, 0xe7, 0x27, 0x87, 0x80, 0x76, 0xc0,
1126     0xa0, 0x72, 0x05, 0xf2, 0x88, 0x81, 0xe3, 0x32, 0x00, 0x76, 0x8d, 0x24,
1127     0x5c, 0x97, 0x2d, 0xd6, 0xb8, 0x34, 0xf8, 0x1c, 0x1a, 0x6d, 0xc7, 0x3f,
1128     0xcf, 0x56, 0xae, 0xec, 0x26, 0x74, 0x53, 0x69, 0xcd, 0x7a, 0x97, 0x29,
1129     0xab, 0x12, 0x7d, 0x75, 0xf8, 0x8d, 0x5b, 0xc0, 0x77, 0x20, 0xb6, 0x6a,
1130     0x0b, 0xce, 0x98, 0x50, 0xca, 0x47, 0x42, 0x1e, 0x5d, 0xc3, 0x24, 0x5a,
1131     0x47, 0x48, 0x3b, 0xa0, 0x9e, 0x43, 0xe9, 0x8d, 0x18, 0x23, 0xda, 0x6f,
1132     0x8c, 0xda, 0xd0, 0x3e, 0xdb, 0x37, 0xff, 0xfc, 0x7e, 0x17, 0xbe, 0x42,
1133     0xfd, 0xdb, 0x51, 0xb1, 0xa4, 0xfd, 0x9a, 0x20, 0x27, 0x24, 0x17, 0x04,
1134     0x70, 0xb6, 0x21, 0x87, 0x88, 0xe9, 0xda, 0x63, 0xcb, 0xcb, 0x1d, 0xaf,
1135     0x4a, 0x46, 0x76, 0x88, 0xa1, 0xf8, 0x48, 0x6c, 0x06, 0xb4, 0x62, 0x1a,
1136     0x67, 0x18, 0xb0, 0x1d, 0x58, 0x6a, 0xfe, 0x1f, 0xf1, 0x48, 0xff, 0xcb,
1137     0xa4, 0xd1, 0xa8, 0x12, 0x1f, 0x45, 0x94, 0x2f, 0x55, 0x80, 0x6a, 0x06,
1138     0xcc, 0x7b, 0xb0, 0xcc, 0xb8, 0x06, 0x52, 0x16, 0xe3, 0x6e, 0x7e, 0xb0,
1139     0x42, 0xfd, 0x3b, 0x7e, 0x0a, 0x42, 0x7b, 0x73, 0xaf, 0x2c, 0xf3, 0xbd,
1140     0xe5, 0x72, 0x8c, 0x16, 0xb2, 0xd7, 0x7a, 0x11, 0xb6, 0x9f, 0xd1, 0x69,
1141     0xc1, 0x1a, 0xe0, 0x26, 0x26, 0x13, 0xe2, 0x75, 0xf5, 0x74, 0xae, 0x3f,
1142     0xee, 0x1e, 0x09, 0x63, 0x5a, 0x30, 0x19, 0xa5, 0x59, 0x48, 0x90, 0x9b,
1143     0x46, 0x56, 0xd8, 0x6f, 0x6b, 0x76, 0x82, 0x32, 0xc7, 0x29, 0x76, 0x2e,
1144     0x32, 0xb6, 0x23, 0x99, 0xeb, 0x92, 0x5d, 0xc4, 0x4c, 0xa1, 0xe9, 0x26,
1145     0x37, 0x9a, 0x7d, 0x4c, 0x16, 0x9c, 0x18, 0xe9, 0xc0, 0xff, 0x48, 0x79,
1146     0xb1, 0x7b, 0x0b, 0x1e, 0x6f, 0xb1, 0x77, 0xa5, 0xd2, 0xc6, 0x9a, 0xa9,
1147     0xfc, 0xd1, 0x0f, 0x69, 0xf3, 0xe0, 0x49, 0x70, 0x57, 0x80, 0x86, 0xa7,
1148     0x3f, 0x54, 0xa8, 0x60, 0xfb, 0xe4, 0x06, 0xa3, 0x13, 0xb9, 0x2f, 0xa7,
1149     0x37, 0x80, 0x0c, 0x43, 0xac, 0x2f, 0xae, 0x6e, 0x62, 0x2b, 0x53, 0xe4,
1150     0xfe, 0x58, 0xd7, 0x8b, 0x96, 0xdc, 0xe6, 0xd3, 0x86, 0xb8, 0xd6, 0x42,
1151     0x5b, 0x68, 0x03, 0x48, 0x3f, 0xcd, 0xee, 0x39, 0x8b, 0xc4, 0x53, 0x30,
1152     0x87, 0x48, 0x2a, 0x01, 0x9d, 0x6f, 0x8e, 0x36, 0x75, 0x73, 0xef, 0x77,
1153     0x3a, 0x82, 0xd8, 0x4c, 0x0e, 0x7f, 0xb3, 0x8f, 0x16, 0xd1, 0x10, 0xcf,
1154     0x2f, 0xa3, 0xdf, 0x65, 0xba, 0x91, 0x79, 0xf6, 0x93, 0x60, 0x08, 0xe5,
1155     0xdb, 0x73, 0x02, 0x7a, 0x0b, 0x0e, 0xcc, 0x3b, 0x1f, 0x08, 0x2d, 0x51,
1156     0x3e, 0x87, 0x48, 0xd3, 0xd3, 0x75, 0xc2, 0x28, 0xa3, 0xf3, 0x02, 0xde,
1157     0x8f, 0xa6, 0xbd, 0xb3, 0x19, 0xa0, 0xdb, 0x48, 0x51, 0x03, 0x5f, 0x98,
1158     0xbe,
1159
1160     /* Third Packet: 1-RTT */
1161     0x5c,               /* Short, 1-RTT, Spin=0, KP=0, PN Length=2 bytes */
1162     0x4f, 0x33,         /* PN (0) */
1163     0x16, 0x75, 0x98, 0x67, 0x04, 0x16, 0x61, 0xe3, 0x00, 0xb7, 0x9d, 0x5c,
1164     0x53, 0x4c, 0x26, 0x90, 0x92, 0x8e, 0x0e, 0xc0, 0x9c, 0x6d, 0x8b, 0xac,
1165     0x15, 0x6d, 0x89, 0x74, 0x2f, 0xe7, 0x84, 0xe3, 0x46, 0x46, 0x8c, 0xc1,
1166     0x21, 0x7c, 0x44, 0xa5, 0x00, 0x29, 0xca, 0xf2, 0x11, 0x18, 0xe0, 0x04,
1167     0x40, 0x55, 0xd2, 0xa7, 0xe5, 0x9d, 0x22, 0xa2, 0x2a, 0x6c, 0x03, 0x87,
1168     0xa3, 0xa3, 0xfa, 0xf5, 0x6c, 0xd7, 0x7d, 0xae, 0x3f, 0x28, 0x01, 0xae,
1169     0x06, 0x11, 0x69, 0x67, 0x90, 0x57, 0x5a, 0xd0, 0xeb, 0xdd, 0xac, 0xbd,
1170     0x7f, 0x33, 0x86, 0xbb,
1171 };
1172
1173 static const QUIC_PKT_HDR rx_script_7a_expect_hdr = {
1174     QUIC_PKT_TYPE_INITIAL,
1175     0,          /* Spin Bit */
1176     0,          /* Key Phase */
1177     2,          /* PN Length */
1178     0,          /* Partial */
1179     1,          /* Fixed */
1180     1,          /* Version */
1181     {0, {0}},                           /* DCID */
1182     {4, {0x03, 0x45, 0x0c, 0x7a}},      /* SCID */
1183     {0},        /* PN */
1184     NULL, 0,    /* Token/Token Len */
1185     441, NULL
1186 };
1187
1188 static const unsigned char rx_script_7a_body[] = {
1189     0x02, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1190     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1191     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1192     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1193     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1194     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1195     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1196     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1197     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1198     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1199     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1200     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1201     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1202     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1203     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1204     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1205     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1206     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1207     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1208     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1209     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1210     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1211     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1212     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1213     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1214     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1215     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1216     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1217     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06,
1218     0x00, 0x40, 0x5a, 0x02, 0x00, 0x00, 0x56, 0x03, 0x03, 0xd5, 0xfb, 0x6a,
1219     0x81, 0x1c, 0xdb, 0xa2, 0x5c, 0x11, 0x31, 0xda, 0x15, 0x28, 0x97, 0x94,
1220     0x83, 0xfd, 0x9d, 0x91, 0x0e, 0x87, 0x71, 0x46, 0x64, 0xb4, 0xd9, 0x9e,
1221     0xbd, 0xa8, 0x48, 0x32, 0xbf, 0x00, 0x13, 0x03, 0x00, 0x00, 0x2e, 0x00,
1222     0x2b, 0x00, 0x02, 0x03, 0x04, 0x00, 0x33, 0x00, 0x24, 0x00, 0x1d, 0x00,
1223     0x20, 0xef, 0xbb, 0x46, 0xe9, 0xb4, 0xf6, 0x54, 0xc4, 0x07, 0x71, 0xdc,
1224     0x50, 0xd5, 0x69, 0x40, 0xbc, 0x85, 0x7f, 0xf9, 0x48, 0x14, 0xe3, 0xd6,
1225     0x08, 0xa9, 0x0b, 0xfd, 0xbe, 0xf1, 0x57, 0x21, 0x34,
1226 };
1227
1228 static const QUIC_PKT_HDR rx_script_7b_expect_hdr = {
1229     QUIC_PKT_TYPE_HANDSHAKE,
1230     0,          /* Spin Bit */
1231     0,          /* Key Phase */
1232     2,          /* PN Length */
1233     0,          /* Partial */
1234     1,          /* Fixed */
1235     1,          /* Version */
1236     {0, {0}},                           /* DCID */
1237     {4, {0x03, 0x45, 0x0c, 0x7a}},      /* SCID */
1238     {0},        /* PN */
1239     NULL, 0,    /* Token/Token Len */
1240     657, NULL
1241 };
1242
1243 static const unsigned char rx_script_7b_body[] = {
1244     0x06, 0x00, 0x42, 0x8d, 0x08, 0x00, 0x00, 0x82, 0x00, 0x80, 0x00, 0x10,
1245     0x00, 0x08, 0x00, 0x06, 0x05, 0x64, 0x75, 0x6d, 0x6d, 0x79, 0x00, 0x39,
1246     0x00, 0x70, 0x46, 0x0a, 0x0d, 0xdc, 0x59, 0xf0, 0x4e, 0xb2, 0x2c, 0xac,
1247     0x69, 0x6a, 0xc9, 0x77, 0xa9, 0x99, 0x05, 0x04, 0x80, 0x08, 0x00, 0x00,
1248     0x06, 0x04, 0x80, 0x08, 0x00, 0x00, 0x07, 0x04, 0x80, 0x08, 0x00, 0x00,
1249     0x04, 0x04, 0x80, 0x0c, 0x00, 0x00, 0x08, 0x02, 0x40, 0x64, 0x09, 0x02,
1250     0x40, 0x64, 0x01, 0x04, 0x80, 0x00, 0x75, 0x30, 0x03, 0x02, 0x45, 0xac,
1251     0x0b, 0x01, 0x1a, 0x0c, 0x00, 0x02, 0x10, 0x42, 0xf0, 0xed, 0x09, 0x07,
1252     0x5b, 0xd9, 0x5a, 0xb2, 0x39, 0x5d, 0x73, 0x2c, 0x57, 0x1f, 0x50, 0x00,
1253     0x0b, 0xe0, 0x3e, 0xf3, 0xd6, 0x91, 0x6f, 0x9c, 0xcc, 0x31, 0xf7, 0xa5,
1254     0x0e, 0x01, 0x04, 0x0f, 0x04, 0x03, 0x45, 0x0c, 0x7a, 0x10, 0x04, 0xfa,
1255     0x5d, 0xd6, 0x80, 0x20, 0x01, 0x00, 0x0b, 0x00, 0x01, 0x8f, 0x00, 0x00,
1256     0x01, 0x8b, 0x00, 0x01, 0x86, 0x30, 0x82, 0x01, 0x82, 0x30, 0x82, 0x01,
1257     0x29, 0xa0, 0x03, 0x02, 0x01, 0x02, 0x02, 0x14, 0x0a, 0x73, 0x0f, 0x86,
1258     0x18, 0xf2, 0xc3, 0x30, 0x01, 0xd2, 0xc0, 0xc1, 0x62, 0x52, 0x13, 0xf1,
1259     0x9c, 0x13, 0x39, 0xb5, 0x30, 0x0a, 0x06, 0x08, 0x2a, 0x86, 0x48, 0xce,
1260     0x3d, 0x04, 0x03, 0x02, 0x30, 0x17, 0x31, 0x15, 0x30, 0x13, 0x06, 0x03,
1261     0x55, 0x04, 0x03, 0x0c, 0x0c, 0x6d, 0x61, 0x70, 0x61, 0x6b, 0x74, 0x2e,
1262     0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x30, 0x1e, 0x17, 0x0d, 0x32, 0x32, 0x30,
1263     0x38, 0x30, 0x32, 0x31, 0x32, 0x30, 0x30, 0x31, 0x38, 0x5a, 0x17, 0x0d,
1264     0x32, 0x32, 0x30, 0x39, 0x30, 0x31, 0x31, 0x32, 0x30, 0x30, 0x31, 0x38,
1265     0x5a, 0x30, 0x17, 0x31, 0x15, 0x30, 0x13, 0x06, 0x03, 0x55, 0x04, 0x03,
1266     0x0c, 0x0c, 0x6d, 0x61, 0x70, 0x61, 0x6b, 0x74, 0x2e, 0x6c, 0x6f, 0x63,
1267     0x61, 0x6c, 0x30, 0x59, 0x30, 0x13, 0x06, 0x07, 0x2a, 0x86, 0x48, 0xce,
1268     0x3d, 0x02, 0x01, 0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x03, 0x01,
1269     0x07, 0x03, 0x42, 0x00, 0x04, 0x67, 0xf4, 0xd3, 0x8f, 0x15, 0x6d, 0xee,
1270     0x85, 0xcc, 0x2a, 0x77, 0xfc, 0x0b, 0x8f, 0x9f, 0xcf, 0xa9, 0x95, 0x5d,
1271     0x5b, 0xcd, 0xb7, 0x8b, 0xba, 0x31, 0x0a, 0x73, 0x62, 0xc5, 0xd0, 0x0e,
1272     0x07, 0x90, 0xae, 0x38, 0x43, 0x79, 0xce, 0x5e, 0x33, 0xad, 0x31, 0xbf,
1273     0x9f, 0x2a, 0x56, 0x83, 0xa5, 0x24, 0x16, 0xab, 0x0c, 0xf1, 0x64, 0xbe,
1274     0xe4, 0x93, 0xb5, 0x89, 0xd6, 0x05, 0xe4, 0xf7, 0x7b, 0xa3, 0x53, 0x30,
1275     0x51, 0x30, 0x1d, 0x06, 0x03, 0x55, 0x1d, 0x0e, 0x04, 0x16, 0x04, 0x14,
1276     0x02, 0x64, 0x0f, 0x55, 0x69, 0x14, 0x91, 0x19, 0xed, 0xf9, 0x1a, 0xe9,
1277     0x1d, 0xa5, 0x5a, 0xd0, 0x48, 0x96, 0x9f, 0x60, 0x30, 0x1f, 0x06, 0x03,
1278     0x55, 0x1d, 0x23, 0x04, 0x18, 0x30, 0x16, 0x80, 0x14, 0x02, 0x64, 0x0f,
1279     0x55, 0x69, 0x14, 0x91, 0x19, 0xed, 0xf9, 0x1a, 0xe9, 0x1d, 0xa5, 0x5a,
1280     0xd0, 0x48, 0x96, 0x9f, 0x60, 0x30, 0x0f, 0x06, 0x03, 0x55, 0x1d, 0x13,
1281     0x01, 0x01, 0xff, 0x04, 0x05, 0x30, 0x03, 0x01, 0x01, 0xff, 0x30, 0x0a,
1282     0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x04, 0x03, 0x02, 0x03, 0x47,
1283     0x00, 0x30, 0x44, 0x02, 0x20, 0x0a, 0x82, 0x92, 0x6e, 0xd3, 0xc6, 0x66,
1284     0xd9, 0xd3, 0x75, 0xff, 0x71, 0x3b, 0x61, 0x46, 0x21, 0x00, 0xe6, 0x21,
1285     0x5d, 0x9c, 0x86, 0xe9, 0x65, 0x40, 0x4f, 0xeb, 0x70, 0x4f, 0x2c, 0xad,
1286     0x00, 0x02, 0x20, 0x08, 0xc2, 0x07, 0x5d, 0x16, 0xfc, 0x54, 0x34, 0x2b,
1287     0xb4, 0x18, 0x67, 0x44, 0x81, 0xc9, 0xa9, 0x67, 0x2e, 0xce, 0xa1, 0x02,
1288     0x9f, 0x3b, 0xe5, 0x61, 0x16, 0x0b, 0x50, 0xf6, 0xa1, 0x50, 0x94, 0x00,
1289     0x00, 0x0f, 0x00, 0x00, 0x4c, 0x04, 0x03, 0x00, 0x48, 0x30, 0x46, 0x02,
1290     0x21, 0x00, 0xaa, 0x18, 0x61, 0x93, 0xdf, 0xbb, 0x79, 0xe7, 0x34, 0x7e,
1291     0x2e, 0x61, 0x13, 0x8c, 0xa0, 0x33, 0xfb, 0x33, 0xca, 0xfc, 0xd2, 0x45,
1292     0xb0, 0xc7, 0x89, 0x3d, 0xf1, 0xd6, 0x54, 0x94, 0x05, 0xb6, 0x02, 0x21,
1293     0x00, 0xef, 0x6c, 0xb6, 0xf2, 0x00, 0xb2, 0x32, 0xb1, 0xf3, 0x3f, 0x59,
1294     0xf5, 0xc8, 0x18, 0xbe, 0x39, 0xbb, 0x27, 0xf8, 0x67, 0xac, 0xcb, 0x63,
1295     0xa4, 0x29, 0xfb, 0x8e, 0x88, 0x0f, 0xe5, 0xe9, 0x7e, 0x14, 0x00, 0x00,
1296     0x20, 0xfc, 0x2c, 0x4c, 0xa7, 0x77, 0x24, 0x79, 0x29, 0xa8, 0x82, 0x1a,
1297     0x4d, 0x58, 0x9d, 0x82, 0xe2, 0x09, 0x36, 0x63, 0x0e, 0x0b, 0x55, 0x51,
1298     0x80, 0x93, 0x40, 0xda, 0x41, 0x33, 0x08, 0x10, 0x2c,
1299 };
1300
1301 static const QUIC_PKT_HDR rx_script_7c_expect_hdr = {
1302     QUIC_PKT_TYPE_1RTT,
1303     0,          /* Spin Bit */
1304     0,          /* Key Phase */
1305     2,          /* PN Length */
1306     0,          /* Partial */
1307     1,          /* Fixed */
1308     0,          /* Version */
1309     {0, {0}},                           /* DCID */
1310     {0, {0}},                           /* SCID */
1311     {0},        /* PN */
1312     NULL, 0,    /* Token/Token Len */
1313     72, NULL
1314 };
1315
1316 static const unsigned char rx_script_7c_body[] = {
1317     0x18, 0x03, 0x00, 0x04, 0xf7, 0x75, 0x72, 0xa2, 0xfd, 0x17, 0xd4, 0x82,
1318     0x8e, 0xe9, 0x5b, 0xce, 0xed, 0xec, 0x88, 0xb9, 0x73, 0xbf, 0x36, 0x9f,
1319     0x18, 0x02, 0x00, 0x04, 0x5f, 0x43, 0x96, 0xe4, 0x15, 0xdc, 0x56, 0x6b,
1320     0x67, 0x4c, 0x36, 0xb2, 0xe2, 0x77, 0xdc, 0x6e, 0xb9, 0x2c, 0x0d, 0x79,
1321     0x18, 0x01, 0x00, 0x04, 0xcb, 0x83, 0x4a, 0xf4, 0x8d, 0x7b, 0x69, 0x90,
1322     0xaf, 0x0d, 0xd2, 0x38, 0xa4, 0xf1, 0x94, 0xff, 0x63, 0x24, 0xd3, 0x7a,
1323 };
1324
1325 static const struct rx_test_op rx_script_7[] = {
1326     RX_OP_ADD_RX_DCID(empty_conn_id)
1327     RX_OP_PROVIDE_SECRET_INITIAL(rx_script_7_c2s_init_dcid)
1328     RX_OP_INJECT_N(7)
1329     RX_OP_CHECK_PKT_FRAMES_OK_N(7a)
1330     RX_OP_CHECK_NO_PKT() /* not got secret for next packet yet */
1331     RX_OP_PROVIDE_SECRET(QUIC_ENC_LEVEL_HANDSHAKE,
1332                       QRL_SUITE_CHACHA20POLY1305, rx_script_7_handshake_secret)
1333     RX_OP_CHECK_PKT_FRAMES_OK_N(7b)
1334     RX_OP_CHECK_NO_PKT() /* not got secret for next packet yet */
1335     RX_OP_PROVIDE_SECRET(QUIC_ENC_LEVEL_1RTT,
1336                       QRL_SUITE_CHACHA20POLY1305, rx_script_7_1rtt_secret)
1337     RX_OP_CHECK_PKT_FRAMES_OK_N(7c)
1338     RX_OP_CHECK_NO_PKT()
1339
1340     /* Try injecting the packet again */
1341     RX_OP_INJECT_N(7)
1342     /*
1343      * Initial packet is not output due to receiving a Handshake packet causing
1344      * auto-discard of Initial keys
1345      */
1346     RX_OP_CHECK_PKT_FRAMES_OK_N(7b)
1347     RX_OP_CHECK_PKT_FRAMES_OK_N(7c)
1348     RX_OP_CHECK_NO_PKT()
1349     /* Try again with discarded keys */
1350     RX_OP_DISCARD_EL(QUIC_ENC_LEVEL_HANDSHAKE)
1351     RX_OP_INJECT_N(7)
1352     RX_OP_CHECK_PKT_FRAMES_OK_N(7c)
1353     RX_OP_CHECK_NO_PKT()
1354     /* Try again */
1355     RX_OP_INJECT_N(7)
1356     RX_OP_CHECK_PKT_FRAMES_OK_N(7c)
1357     RX_OP_CHECK_NO_PKT()
1358     /* Try again with discarded 1-RTT keys */
1359     RX_OP_DISCARD_EL(QUIC_ENC_LEVEL_1RTT)
1360     RX_OP_INJECT_N(7)
1361     RX_OP_CHECK_NO_PKT()
1362
1363     /* Recreate QRL, test reading packets received before key */
1364     RX_OP_SET_SCID_LEN(0)
1365     RX_OP_ADD_RX_DCID(empty_conn_id)
1366     RX_OP_INJECT_N(7)
1367     RX_OP_CHECK_NO_PKT()
1368     RX_OP_PROVIDE_SECRET_INITIAL(rx_script_7_c2s_init_dcid)
1369     RX_OP_CHECK_PKT_FRAMES_OK_N(7a)
1370     RX_OP_CHECK_NO_PKT()
1371     RX_OP_PROVIDE_SECRET(QUIC_ENC_LEVEL_HANDSHAKE,
1372                       QRL_SUITE_CHACHA20POLY1305, rx_script_7_handshake_secret)
1373     RX_OP_CHECK_PKT_FRAMES_OK_N(7b)
1374     RX_OP_CHECK_NO_PKT()
1375     RX_OP_PROVIDE_SECRET(QUIC_ENC_LEVEL_1RTT,
1376                       QRL_SUITE_CHACHA20POLY1305, rx_script_7_1rtt_secret)
1377     RX_OP_CHECK_PKT_FRAMES_OK_N(7c)
1378     RX_OP_CHECK_NO_PKT()
1379
1380     RX_OP_END
1381 };
1382 #endif /* !defined(OPENSSL_NO_CHACHA) */
1383
1384 /*
1385  * 8. Real World - S2C Multiple Packets with Peer Initiated Key Phase Update
1386  */
1387 static const unsigned char rx_script_8_1rtt_secret[32] = {
1388     0x5f, 0x1f, 0x47, 0xea, 0xc3, 0xb2, 0xce, 0x73, 0xfb, 0xa2, 0x9f, 0xac,
1389     0xc3, 0xa0, 0xfe, 0x9b, 0xf3, 0xc0, 0xde, 0x5d, 0x33, 0x11, 0x1c, 0x70,
1390     0xdd, 0xb4, 0x06, 0xcc, 0xdf, 0x7d, 0xe9, 0x9a
1391 };
1392
1393 static const unsigned char rx_script_8a_in[] = {
1394     0x51,                           /* Short, 1-RTT, PN Length=2 bytes, KP=0 */
1395     0xcb, 0xf4,                     /* PN (4) */
1396     0x3f, 0x68, 0x7b, 0xa8, 0x2b, 0xb9, 0xfa, 0x7d, 0xe4, 0x6b, 0x20, 0x48,
1397     0xd1, 0x3c, 0xcb, 0x4b, 0xef, 0xb1, 0xfd, 0x5e, 0x1b, 0x19, 0x83, 0xa9,
1398     0x47, 0x62, 0xc1, 0x6e, 0xef, 0x27, 0xc3, 0x9b, 0x8f, 0x3f, 0xce, 0x11,
1399     0x68, 0xf5, 0x73, 0x0d, 0xf2, 0xdc, 0xe0, 0x28, 0x28, 0x79, 0xa6, 0x39,
1400     0xc3, 0xb9, 0xd3,
1401 };
1402
1403 static const QUIC_PKT_HDR rx_script_8a_expect_hdr = {
1404     QUIC_PKT_TYPE_1RTT,
1405     0,          /* Spin Bit */
1406     0,          /* Key Phase */
1407     2,          /* PN Length */
1408     0,          /* Partial */
1409     1,          /* Fixed */
1410     0,          /* Version */
1411     {0, {0}},   /* DCID */
1412     {0, {0}},   /* SCID */
1413     {0, 4},     /* PN */
1414     NULL, 0,    /* Token/Token Len */
1415     35, NULL
1416 };
1417
1418 static const unsigned char rx_script_8a_body[] = {
1419     0x02, 0x03, 0x06, 0x00, 0x03, 0x0c, 0x00, 0x1b, 0x49, 0x27, 0x6d, 0x20,
1420     0x68, 0x61, 0x76, 0x69, 0x6e, 0x67, 0x20, 0x61, 0x20, 0x77, 0x6f, 0x6e,
1421     0x64, 0x65, 0x72, 0x66, 0x75, 0x6c, 0x20, 0x74, 0x69, 0x6d, 0x65
1422 };
1423
1424 static const unsigned char rx_script_8b_in[] = {
1425     0x52,                           /* Short, 1-RTT, PN Length=2 bytes, KP=1 */
1426     0x21, 0x8e,                     /* PN (5) */
1427     0xa2, 0x6a, 0x9c, 0x83, 0x24, 0x48, 0xae, 0x60, 0x1e, 0xc2, 0xa5, 0x91,
1428     0xfa, 0xe5, 0xf2, 0x05, 0x14, 0x37, 0x04, 0x6a, 0xa8, 0xae, 0x06, 0x58,
1429     0xd7, 0x85, 0x48, 0xd7, 0x3b, 0x85, 0x9e, 0x5a, 0xb3, 0x46, 0x89, 0x1b,
1430     0x4b, 0x6e, 0x1d, 0xd1, 0xfc, 0xb7, 0x47, 0xda, 0x6a, 0x64, 0x4b, 0x8e,
1431     0xf2, 0x69, 0x16,
1432 };
1433
1434 static const QUIC_PKT_HDR rx_script_8b_expect_hdr = {
1435     QUIC_PKT_TYPE_1RTT,
1436     0,          /* Spin Bit */
1437     1,          /* Key Phase */
1438     2,          /* PN Length */
1439     0,          /* Partial */
1440     1,          /* Fixed */
1441     0,          /* Version */
1442     {0, {0}},   /* DCID */
1443     {0, {0}},   /* SCID */
1444     {0, 5},     /* PN */
1445     NULL, 0,    /* Token/Token Len */
1446     35, NULL
1447 };
1448
1449 static const unsigned char rx_script_8b_body[] = {
1450     0x02, 0x04, 0x03, 0x00, 0x00, 0x0c, 0x00, 0x36, 0x49, 0x27, 0x6d, 0x20,
1451     0x68, 0x61, 0x76, 0x69, 0x6e, 0x67, 0x20, 0x61, 0x20, 0x77, 0x6f, 0x6e,
1452     0x64, 0x65, 0x72, 0x66, 0x75, 0x6c, 0x20, 0x74, 0x69, 0x6d, 0x65,
1453 };
1454
1455 static const unsigned char rx_script_8c_in[] = {
1456     0x5b,                           /* Short, 1-RTT, PN Length=2 bytes, KP=0 */
1457     0x98, 0xd6,                     /* PN (3) */
1458     0x3c, 0x6f, 0x94, 0x20, 0x5e, 0xfc, 0x5b, 0x3a, 0x4a, 0x65, 0x1a, 0x9a,
1459     0x6c, 0x00, 0x52, 0xb6, 0x0c, 0x9b, 0x07, 0xf9, 0x6f, 0xbc, 0x3d, 0xb4,
1460     0x57, 0xe0, 0x15, 0x74, 0xfe, 0x76, 0xea, 0x1f, 0x23, 0xae, 0x22, 0x62,
1461     0xb7, 0x90, 0x94, 0x89, 0x38, 0x9b, 0x5b, 0x47, 0xed,
1462 };
1463
1464 static const QUIC_PKT_HDR rx_script_8c_expect_hdr = {
1465     QUIC_PKT_TYPE_1RTT,
1466     0,          /* Spin Bit */
1467     0,          /* Key Phase */
1468     2,          /* PN Length */
1469     0,          /* Partial */
1470     1,          /* Fixed */
1471     0,          /* Version */
1472     {0, {0}},   /* DCID */
1473     {0, {0}},   /* SCID */
1474     {0, 3},     /* PN */
1475     NULL, 0,    /* Token/Token Len */
1476     29, NULL
1477 };
1478
1479 static const unsigned char rx_script_8c_body[] = {
1480     0x08, 0x00, 0x49, 0x27, 0x6d, 0x20, 0x68, 0x61, 0x76, 0x69, 0x6e, 0x67,
1481     0x20, 0x61, 0x20, 0x77, 0x6f, 0x6e, 0x64, 0x65, 0x72, 0x66, 0x75, 0x6c,
1482     0x20, 0x74, 0x69, 0x6d, 0x65,
1483 };
1484
1485 static const unsigned char rx_script_8d_in[] = {
1486     0x55,                           /* Short, 1-RTT, PN Length=2 bytes, KP=1 */
1487     0x98, 0x20,                     /* PN (6) */
1488     0x45, 0x53, 0x05, 0x29, 0x30, 0x42, 0x29, 0x02, 0xf2, 0xa7, 0x27, 0xd6,
1489     0xb0, 0xb7, 0x30, 0xad, 0x45, 0xd8, 0x73, 0xd7, 0xe3, 0x65, 0xee, 0xd9,
1490     0x35, 0x33, 0x03, 0x3a, 0x35, 0x0b, 0x59, 0xa7, 0xbc, 0x23, 0x37, 0xc2,
1491     0x5e, 0x13, 0x88, 0x18, 0x79, 0x94, 0x6c, 0x15, 0xe3, 0x1f, 0x0d, 0xd1,
1492     0xc3, 0xfa, 0x40, 0xff,
1493 };
1494
1495 static const QUIC_PKT_HDR rx_script_8d_expect_hdr = {
1496     QUIC_PKT_TYPE_1RTT,
1497     0,          /* Spin Bit */
1498     1,          /* Key Phase */
1499     2,          /* PN Length */
1500     0,          /* Partial */
1501     1,          /* Fixed */
1502     0,          /* Version */
1503     {0, {0}},   /* DCID */
1504     {0, {0}},   /* SCID */
1505     {0, 6},     /* PN */
1506     NULL, 0,    /* Token/Token Len */
1507     36, NULL
1508 };
1509
1510 static const unsigned char rx_script_8d_body[] = {
1511     0x02, 0x05, 0x03, 0x00, 0x00, 0x0c, 0x00, 0x40, 0x51, 0x49, 0x27, 0x6d,
1512     0x20, 0x68, 0x61, 0x76, 0x69, 0x6e, 0x67, 0x20, 0x61, 0x20, 0x77, 0x6f,
1513     0x6e, 0x64, 0x65, 0x72, 0x66, 0x75, 0x6c, 0x20, 0x74, 0x69, 0x6d, 0x65,
1514 };
1515
1516 static const unsigned char rx_script_8e_in[] = {
1517     0x55,                           /* Short, 1-RTTT, PN Length=2 bytes, KP=0 */
1518     0x76, 0x25,                     /* PN (10) */
1519     0x1c, 0x0d, 0x70, 0x4c, 0x2b, 0xc5, 0x7d, 0x7b, 0x77, 0x64, 0x03, 0x27,
1520     0xb3, 0x5d, 0x83, 0x9e, 0x35, 0x05, 0x10, 0xd2, 0xa4, 0x5c, 0x83, 0xd6,
1521     0x94, 0x12, 0x18, 0xc5, 0xb3, 0x0f, 0x0a, 0xb1, 0x8a, 0x82, 0x9f, 0xd6,
1522     0xa9, 0xab, 0x40, 0xc1, 0x05, 0xe8, 0x1b, 0x74, 0xaa, 0x8e, 0xd6, 0x8b,
1523     0xa5, 0xa3, 0x77, 0x79,
1524 };
1525
1526 static const QUIC_PKT_HDR rx_script_8e_expect_hdr = {
1527     QUIC_PKT_TYPE_1RTT,
1528     0,          /* Spin Bit */
1529     0,          /* Key Phase */
1530     2,          /* PN Length */
1531     0,          /* Partial */
1532     1,          /* Fixed */
1533     0,          /* Version */
1534     {0, {0}},   /* DCID */
1535     {0, {0}},   /* SCID */
1536     {0, 10},    /* PN */
1537     NULL, 0,    /* Token/Token Len */
1538     36, NULL
1539 };
1540
1541 static const unsigned char rx_script_8e_body[] = {
1542     0x02, 0x09, 0x04, 0x00, 0x00, 0x0c, 0x00, 0x40, 0xbd, 0x49, 0x27, 0x6d,
1543     0x20, 0x68, 0x61, 0x76, 0x69, 0x6e, 0x67, 0x20, 0x61, 0x20, 0x77, 0x6f,
1544     0x6e, 0x64, 0x65, 0x72, 0x66, 0x75, 0x6c, 0x20, 0x74, 0x69, 0x6d, 0x65,
1545 };
1546
1547 static const unsigned char rx_script_8f_in[] = {
1548     0x48,                           /* Short, 1-RTT, PN Length=2 Bytes, KP=1 */
1549     0x4d, 0xf6,                     /* PN (15) */
1550     0x42, 0x86, 0xa1, 0xfa, 0x69, 0x6b, 0x1a, 0x45, 0xf2, 0xcd, 0xf6, 0x92,
1551     0xe1, 0xe6, 0x1a, 0x49, 0x37, 0xd7, 0x10, 0xae, 0x09, 0xbd
1552 };
1553
1554 static const QUIC_PKT_HDR rx_script_8f_expect_hdr = {
1555     QUIC_PKT_TYPE_1RTT,
1556     0,          /* Spin Bit */
1557     1,          /* Key Phase */
1558     2,          /* PN Length */
1559     0,          /* Partial */
1560     1,          /* Fixed */
1561     0,          /* Version */
1562     {0, {0}},   /* DCID */
1563     {0, {0}},   /* SCID */
1564     {0, 15},    /* PN */
1565     NULL, 0,    /* Token/Token Len */
1566     6, NULL
1567 };
1568
1569 static const unsigned char rx_script_8f_body[] = {
1570     0x02, 0x0e, 0x4c, 0x54, 0x00, 0x02
1571 };
1572
1573 static const struct rx_test_op rx_script_8[] = {
1574     RX_OP_ADD_RX_DCID(empty_conn_id)
1575     /* Inject before we get the keys */
1576     RX_OP_INJECT_N(8a)
1577     /* Nothing yet */
1578     RX_OP_CHECK_NO_PKT()
1579     /* Provide keys */
1580     RX_OP_PROVIDE_SECRET(QUIC_ENC_LEVEL_1RTT,
1581                          QRL_SUITE_AES128GCM, rx_script_8_1rtt_secret)
1582     /* Now the injected packet is successfully returned */
1583     RX_OP_CHECK_PKT_FRAMES_OK_N(8a)
1584     RX_OP_CHECK_NO_PKT()
1585     RX_OP_CHECK_KEY_EPOCH(0)
1586
1587     /* Packet with new key phase */
1588     RX_OP_INJECT_N(8b)
1589     /* Packet is successfully decrypted and returned */
1590     RX_OP_CHECK_PKT_FRAMES_OK_N(8b)
1591     RX_OP_CHECK_NO_PKT()
1592     /* Key epoch has increased */
1593     RX_OP_CHECK_KEY_EPOCH(1)
1594
1595     /*
1596      * Now inject an old packet with the old keys (perhaps reordered in
1597      * network).
1598      */
1599     RX_OP_INJECT_N(8c)
1600     /* Should still be decrypted OK */
1601     RX_OP_CHECK_PKT_FRAMES_OK_N(8c)
1602     RX_OP_CHECK_NO_PKT()
1603     /* Epoch has not changed */
1604     RX_OP_CHECK_KEY_EPOCH(1)
1605
1606     /* Another packet with the new keys. */
1607     RX_OP_INJECT_N(8d)
1608     RX_OP_CHECK_PKT_FRAMES_OK_N(8d)
1609     RX_OP_CHECK_NO_PKT()
1610     RX_OP_CHECK_KEY_EPOCH(1)
1611
1612     /* We can inject the old packet multiple times and it still works */
1613     RX_OP_INJECT_N(8c)
1614     RX_OP_CHECK_PKT_FRAMES_OK_N(8c)
1615     RX_OP_CHECK_NO_PKT()
1616     RX_OP_CHECK_KEY_EPOCH(1)
1617
1618     /* Until we move from UPDATING to COOLDOWN */
1619     RX_OP_KEY_UPDATE_TIMEOUT(0)
1620     RX_OP_INJECT_N(8c)
1621     RX_OP_CHECK_NO_PKT()
1622     RX_OP_CHECK_KEY_EPOCH(1)
1623
1624     /*
1625      * Injecting a packet from the next epoch (epoch 2) while in COOLDOWN
1626      * doesn't work
1627      */
1628     RX_OP_INJECT_N(8e)
1629     RX_OP_CHECK_NO_PKT()
1630     RX_OP_CHECK_KEY_EPOCH(1)
1631
1632     /* Move from COOLDOWN to NORMAL and try again */
1633     RX_OP_KEY_UPDATE_TIMEOUT(1)
1634     RX_OP_INJECT_N(8e)
1635     RX_OP_CHECK_PKT_FRAMES_OK_N(8e)
1636     RX_OP_CHECK_NO_PKT()
1637     RX_OP_CHECK_KEY_EPOCH(2)
1638
1639     /* Can still receive old packet */
1640     RX_OP_INJECT_N(8d)
1641     RX_OP_CHECK_PKT_FRAMES_OK_N(8d)
1642     RX_OP_CHECK_NO_PKT()
1643     RX_OP_CHECK_KEY_EPOCH(2)
1644
1645     /* Move straight from UPDATING to NORMAL */
1646     RX_OP_KEY_UPDATE_TIMEOUT(1)
1647
1648     /* Try a packet from epoch 3 */
1649     RX_OP_INJECT_N(8f)
1650     RX_OP_CHECK_PKT_FRAMES_OK_N(8f)
1651     RX_OP_CHECK_NO_PKT()
1652     RX_OP_CHECK_KEY_EPOCH(3)
1653
1654     RX_OP_END
1655 };
1656
1657 static const struct rx_test_op *rx_scripts[] = {
1658     rx_script_1,
1659 #ifndef OPENSSL_NO_CHACHA
1660     rx_script_2,
1661 #endif
1662     rx_script_3,
1663     rx_script_4,
1664     rx_script_5,
1665     rx_script_6,
1666 #ifndef OPENSSL_NO_CHACHA
1667     rx_script_7,
1668 #endif
1669     rx_script_8
1670 };
1671
1672 struct rx_state {
1673     QUIC_DEMUX         *demux;
1674
1675     /* OSSL_QRX with necessary data */
1676     OSSL_QRX           *qrx;
1677     OSSL_QRX_ARGS       args;
1678
1679     /* OSSL_ACKM with necessary data */
1680     OSSL_ACKM          *ackm;
1681     OSSL_CC_DATA       *ccdata;
1682     OSSL_STATM          statm;       /* NOT the state machine! */
1683
1684     /* Used for the RX depacketizer, and wraps the |qrx| and |ackm| */
1685     SSL_CTX            *quic_ssl_ctx;
1686     QUIC_CONNECTION    *quic_conn;
1687 };
1688
1689 static void rx_state_teardown(struct rx_state *s)
1690 {
1691     if (s->ackm != NULL) {
1692         ossl_ackm_free(s->ackm);
1693         ossl_quic_conn_set_ackm(s->quic_conn, NULL);
1694         s->ackm = NULL;
1695     }
1696     if (s->ccdata != NULL) {
1697         ossl_cc_dummy_method.free(s->ccdata);
1698         s->ccdata = NULL;
1699     }
1700
1701     if (s->qrx != NULL) {
1702         ossl_qrx_free(s->qrx);
1703         ossl_quic_conn_set_qrx(s->quic_conn, NULL);
1704         s->qrx = NULL;
1705     }
1706
1707     if (s->quic_conn != NULL) {
1708         SSL_free((SSL *)s->quic_conn);
1709         s->quic_conn = NULL;
1710     }
1711     if (s->quic_ssl_ctx != NULL) {
1712         SSL_CTX_free(s->quic_ssl_ctx);
1713         s->quic_ssl_ctx = NULL;
1714     }
1715
1716     if (s->demux != NULL) {
1717         ossl_quic_demux_free(s->demux);
1718         s->demux = NULL;
1719     }
1720 }
1721
1722 static uint64_t time_counter = 0;
1723
1724 static OSSL_TIME fake_now(void *ignored)
1725 {
1726     OSSL_TIME f = {0};
1727
1728     return f;
1729 }
1730
1731 static OSSL_TIME expected_time(uint64_t counter)
1732 {
1733     return ossl_time_multiply(ossl_ticks2time(OSSL_TIME_MS), counter);
1734 }
1735
1736 static OSSL_TIME fake_time(void *arg)
1737 {
1738     return expected_time(++time_counter);
1739 }
1740
1741 static int rx_state_ensure(struct rx_state *s)
1742 {
1743     if (s->demux == NULL
1744         && !TEST_ptr(s->demux = ossl_quic_demux_new(NULL,
1745                                                     s->args.short_conn_id_len,
1746                                                     1500,
1747                                                     fake_time,
1748                                                     NULL)))
1749         return 0;
1750
1751     s->args.demux           = s->demux;
1752     s->args.max_deferred    = 32;
1753
1754     /* Initialise OSSL_QRX */
1755     if (s->qrx == NULL
1756         && !TEST_ptr(s->qrx = ossl_qrx_new(&s->args)))
1757         return 0;
1758
1759     return 1;
1760 }
1761
1762 static int rx_state_ensure_for_frames(struct rx_state *s)
1763 {
1764     SSL *qs;
1765
1766     if (!rx_state_ensure(s))
1767         return 0;
1768
1769     /* Initialise ACK manager and congestion controller. */
1770     if ((s->ccdata == NULL
1771          && !TEST_ptr(s->ccdata = ossl_cc_dummy_method.new(NULL, NULL, NULL)))
1772         || (s->ackm == NULL
1773             && !TEST_ptr(s->ackm = ossl_ackm_new(fake_now, NULL, &s->statm,
1774                                                  &ossl_cc_dummy_method,
1775                                                  s->ccdata))))
1776         return 0;
1777
1778     if (s->quic_conn == NULL
1779         && (!TEST_ptr(s->quic_ssl_ctx
1780                       = SSL_CTX_new_ex(NULL, NULL, OSSL_QUIC_client_method()))
1781             || !TEST_ptr(qs = SSL_new(s->quic_ssl_ctx))
1782             || !TEST_ptr(s->quic_conn = ossl_quic_conn_from_ssl(qs))
1783             || !TEST_true(ossl_quic_conn_set_qrx(s->quic_conn, s->qrx))
1784             || !TEST_true(ossl_quic_conn_set_ackm(s->quic_conn, s->ackm))))
1785         return 0;
1786     return 1;
1787 }
1788
1789 static int rx_run_script(const struct rx_test_op *script)
1790 {
1791     int testresult = 0, pkt_outstanding = 0;
1792     struct rx_state s = {0};
1793     size_t i;
1794     OSSL_QRX_PKT pkt = {0};
1795     const struct rx_test_op *op = script;
1796
1797     for (; op->op != RX_TEST_OP_END; ++op)
1798         switch (op->op) {
1799             case RX_TEST_OP_SET_SCID_LEN:
1800                 rx_state_teardown(&s);
1801                 s.args.short_conn_id_len = op->enc_level;
1802                 break;
1803             case RX_TEST_OP_SET_INIT_LARGEST_PN:
1804                 rx_state_teardown(&s);
1805                 for (i = 0; i < QUIC_PN_SPACE_NUM; ++i)
1806                     s.args.init_largest_pn[i] = op->largest_pn;
1807                 break;
1808             case RX_TEST_OP_ADD_RX_DCID:
1809                 if (!TEST_true(rx_state_ensure(&s)))
1810                     goto err;
1811                 if (!TEST_true(ossl_qrx_add_dst_conn_id(s.qrx, op->dcid)))
1812                     goto err;
1813                 break;
1814             case RX_TEST_OP_PROVIDE_SECRET:
1815                 if (!TEST_true(rx_state_ensure(&s)))
1816                     goto err;
1817                 if (!TEST_true(ossl_qrx_provide_secret(s.qrx, op->enc_level,
1818                                                        op->suite_id, NULL,
1819                                                        op->buf,
1820                                                        op->buf_len)))
1821                     goto err;
1822                 break;
1823             case RX_TEST_OP_PROVIDE_SECRET_INITIAL:
1824                 if (!TEST_true(rx_state_ensure(&s)))
1825                     goto err;
1826                 if (!TEST_true(ossl_quic_provide_initial_secret(NULL, NULL,
1827                                                                 op->dcid, 0,
1828                                                                 s.qrx, NULL)))
1829                     goto err;
1830                 break;
1831             case RX_TEST_OP_DISCARD_EL:
1832                 if (!TEST_true(rx_state_ensure(&s)))
1833                     goto err;
1834                 if (!TEST_true(ossl_qrx_discard_enc_level(s.qrx, op->enc_level)))
1835                     goto err;
1836                 break;
1837             case RX_TEST_OP_INJECT:
1838                 if (!TEST_true(rx_state_ensure(&s)))
1839                     goto err;
1840                 if (!TEST_true(ossl_quic_demux_inject(s.demux,
1841                                                       op->buf, op->buf_len,
1842                                                       NULL, NULL)))
1843                     goto err;
1844                 break;
1845             case RX_TEST_OP_CHECK_PKT:
1846                 if (!TEST_true(rx_state_ensure(&s)))
1847                     goto err;
1848
1849                 if (!TEST_true(ossl_qrx_read_pkt(s.qrx, &pkt)))
1850                     goto err;
1851
1852                 pkt_outstanding = 1;
1853                 if (!TEST_ptr(pkt.hdr))
1854                     goto err;
1855
1856                 if (!TEST_mem_eq(pkt.hdr->data, pkt.hdr->len,
1857                                  op->buf, op->buf_len))
1858                     goto err;
1859
1860                 if (!TEST_true(cmp_pkt_hdr(pkt.hdr, op->hdr,
1861                                            op->buf, op->buf_len, 1)))
1862                     goto err;
1863
1864                 switch (op->subop) {
1865                 case RX_TEST_OP_CHECK_PKT_FRAMES_OK:
1866                     if (!TEST_true(rx_state_ensure_for_frames(&s)))
1867                         goto err;
1868                     pkt_outstanding = 0;
1869                     if (!TEST_true(ossl_quic_handle_frames(s.quic_conn, &pkt)))
1870                         goto err;
1871                     break;
1872                 case RX_TEST_OP_CHECK_PKT_FRAMES_INVALID:
1873                     if (!TEST_true(rx_state_ensure_for_frames(&s)))
1874                         goto err;
1875                     pkt_outstanding = 0;
1876                     if (!TEST_false(ossl_quic_handle_frames(s.quic_conn, &pkt)))
1877                         goto err;
1878                     break;
1879                 default:
1880                     pkt_outstanding = 0;
1881                     ossl_qrx_release_pkt(s.qrx, pkt.handle);
1882                     break;
1883                 }
1884                 break;
1885             case RX_TEST_OP_CHECK_NO_PKT:
1886                 if (!TEST_true(rx_state_ensure(&s)))
1887                     goto err;
1888
1889                 if (!TEST_false(ossl_qrx_read_pkt(s.qrx, &pkt)))
1890                     goto err;
1891
1892                 break;
1893             case RX_TEST_OP_CHECK_KEY_EPOCH:
1894                 if (!TEST_true(rx_state_ensure(&s)))
1895                     goto err;
1896
1897                 if (!TEST_uint64_t_eq(ossl_qrx_get_key_epoch(s.qrx),
1898                                       op->largest_pn))
1899                     goto err;
1900
1901                 break;
1902             case RX_TEST_OP_KEY_UPDATE_TIMEOUT:
1903                 if (!TEST_true(rx_state_ensure(&s)))
1904                     goto err;
1905
1906                 if (!TEST_true(ossl_qrx_key_update_timeout(s.qrx,
1907                                                            op->enc_level)))
1908                     goto err;
1909
1910                 break;
1911             case RX_TEST_OP_SET_INIT_KEY_PHASE:
1912                 rx_state_teardown(&s);
1913                 s.args.init_key_phase_bit = (unsigned char)op->enc_level;
1914                 break;
1915             default:
1916                 OPENSSL_assert(0);
1917                 goto err;
1918         }
1919
1920     testresult = 1;
1921 err:
1922     if (pkt_outstanding)
1923         ossl_qrx_release_pkt(s.qrx, pkt.handle);
1924     rx_state_teardown(&s);
1925     return testresult;
1926 }
1927
1928 static int test_rx_script(int idx)
1929 {
1930     return rx_run_script(rx_scripts[idx]);
1931 }
1932
1933 /* Packet Header Tests */
1934 struct pkt_hdr_test {
1935     QUIC_PKT_HDR hdr;
1936     const unsigned char *expected;
1937     size_t expected_len;
1938     const unsigned char *payload;
1939     size_t payload_len;
1940     size_t short_conn_id_len;
1941     /*
1942      * Minimum number of bytes which should be required for a successful decode.
1943      * SIZE_MAX if should never decode successfully.
1944      */
1945     size_t min_success_len;
1946     size_t pn_offset, sample_offset;
1947 };
1948
1949 /* Packet Header Test 1: INITIAL With SCID */
1950 static const unsigned char pkt_hdr_test_1_expected[] = {
1951     0xc1,                     /* Long|Fixed, Type=Initial, PN Len=2 */
1952     0x00, 0x00, 0x00, 0x01,   /* Version */
1953     0x00,                     /* DCID Length */
1954     0x08, 0xf0, 0x67, 0xa5, 0x50, 0x2a, 0x42, 0x62, 0xb5, /* SCID Length, SCID */
1955     0x00,                     /* Token Length */
1956     0x15,                     /* Length=21 */
1957     0x33, 0x44,               /* Encoded PN */
1958     0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, /* Payload */
1959     0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
1960     0x20, 0x21, 0x22
1961 };
1962
1963 static const unsigned char pkt_hdr_test_1_payload[] = {
1964     0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
1965     0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
1966     0x20, 0x21, 0x22
1967 };
1968
1969 static const struct pkt_hdr_test pkt_hdr_test_1 = {
1970     {
1971         QUIC_PKT_TYPE_INITIAL,  /* type */
1972         0,                      /* spin bit */
1973         0,                      /* key phase */
1974         2,                      /* PN length */
1975         0,                      /* partial */
1976         1,                      /* fixed */
1977         1,                      /* version */
1978         { 0, {0} },             /* DCID */
1979         { 8, {0xf0, 0x67, 0xa5, 0x50, 0x2a, 0x42, 0x62, 0xb5 } }, /* SCID */
1980         { 0x33, 0x44 },         /* PN */
1981         NULL, 0,                /* Token/Token Len */
1982         19, NULL                /* Len/Data */
1983     },
1984     pkt_hdr_test_1_expected, OSSL_NELEM(pkt_hdr_test_1_expected),
1985     pkt_hdr_test_1_payload,  OSSL_NELEM(pkt_hdr_test_1_payload),
1986     0, sizeof(pkt_hdr_test_1_expected),
1987     17, 21
1988 };
1989
1990 /* Packet Header Test 2: INITIAL With SCID and Token */
1991 static const unsigned char pkt_hdr_test_2_expected[] = {
1992     0xc1,                     /* Long|Fixed, Type=Initial, PN Len=2 */
1993     0x00, 0x00, 0x00, 0x01,   /* Version */
1994     0x00,                     /* DCID Length */
1995     0x08, 0xf0, 0x67, 0xa5, 0x50, 0x2a, 0x42, 0x62, 0xb5, /* SCID Length, SCID */
1996     0x07,                     /* Token Length */
1997     0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96,
1998     0x15,                     /* Length=21 */
1999     0x33, 0x44,               /* Encoded PN */
2000     0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, /* Payload */
2001     0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
2002     0x20, 0x21, 0x22
2003 };
2004
2005 static const unsigned char pkt_hdr_test_2_payload[] = {
2006     0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
2007     0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
2008     0x20, 0x21, 0x22
2009 };
2010
2011 static const unsigned char pkt_hdr_test_2_token[] = {
2012     0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96
2013 };
2014
2015 static const struct pkt_hdr_test pkt_hdr_test_2 = {
2016     {
2017         QUIC_PKT_TYPE_INITIAL,  /* type */
2018         0,                      /* spin bit */
2019         0,                      /* key phase */
2020         2,                      /* PN length */
2021         0,                      /* partial */
2022         1,                      /* fixed */
2023         1,                      /* version */
2024         { 0, {0} },             /* DCID */
2025         { 8, {0xf0, 0x67, 0xa5, 0x50, 0x2a, 0x42, 0x62, 0xb5 } }, /* SCID */
2026         { 0x33, 0x44 },         /* PN */
2027         pkt_hdr_test_2_token, sizeof(pkt_hdr_test_2_token), /* Token */
2028         19, NULL                /* Len/Data */
2029     },
2030     pkt_hdr_test_2_expected, OSSL_NELEM(pkt_hdr_test_2_expected),
2031     pkt_hdr_test_2_payload,  OSSL_NELEM(pkt_hdr_test_2_payload),
2032     0, sizeof(pkt_hdr_test_2_expected),
2033     24, 28
2034 };
2035
2036 /* Packet Header Test 3: INITIAL With DCID and SCID and Token */
2037 static const unsigned char pkt_hdr_test_3_expected[] = {
2038     0xc1,                     /* Long|Fixed, Type=Initial, PN Len=2 */
2039     0x00, 0x00, 0x00, 0x01,   /* Version */
2040     0x03,                     /* DCID Length */
2041     0x70, 0x71, 0x72,         /* DCID */
2042     0x08, 0xf0, 0x67, 0xa5, 0x50, 0x2a, 0x42, 0x62, 0xb5, /* SCID Length, SCID */
2043     0x06,                     /* Token Length */
2044     0x91, 0x92, 0x93, 0x94, 0x95, 0x96,
2045     0x15,                     /* Length=21 */
2046     0x33, 0x44,               /* Encoded PN */
2047     0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, /* Payload */
2048     0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
2049     0x20, 0x21, 0x22
2050 };
2051
2052 static const unsigned char pkt_hdr_test_3_payload[] = {
2053     0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
2054     0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
2055     0x20, 0x21, 0x22
2056 };
2057
2058 static const unsigned char pkt_hdr_test_3_token[] = {
2059     0x91, 0x92, 0x93, 0x94, 0x95, 0x96
2060 };
2061
2062 static const struct pkt_hdr_test pkt_hdr_test_3 = {
2063     {
2064         QUIC_PKT_TYPE_INITIAL,  /* type */
2065         0,                      /* spin bit */
2066         0,                      /* key phase */
2067         2,                      /* PN length */
2068         0,                      /* partial */
2069         1,                      /* fixed */
2070         1,                      /* version */
2071         { 3, {0x70, 0x71, 0x72} },                                /* DCID */
2072         { 8, {0xf0, 0x67, 0xa5, 0x50, 0x2a, 0x42, 0x62, 0xb5 } }, /* SCID */
2073         { 0x33, 0x44 },         /* PN */
2074         pkt_hdr_test_3_token, sizeof(pkt_hdr_test_3_token), /* Token */
2075         19, NULL                /* Len/Data */
2076     },
2077     pkt_hdr_test_3_expected, OSSL_NELEM(pkt_hdr_test_3_expected),
2078     pkt_hdr_test_3_payload,  OSSL_NELEM(pkt_hdr_test_3_payload),
2079     0, sizeof(pkt_hdr_test_3_expected),
2080     26, 30
2081 };
2082
2083 /* Packet Header Test 4: 0-RTT */
2084 static const unsigned char pkt_hdr_test_4_expected[] = {
2085     0xd0,                     /* Long|Fixed, Type=0-RTT, PN Len=1 */
2086     0x00, 0x00, 0x00, 0x01,   /* Version */
2087     0x03,                     /* DCID Length */
2088     0x70, 0x71, 0x72,         /* DCID */
2089     0x08, 0xf0, 0x67, 0xa5, 0x50, 0x2a, 0x42, 0x62, 0xb5, /* SCID Length, SCID */
2090     0x14,                     /* Length=20 */
2091     0x33,                     /* Encoded PN */
2092     0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, /* Payload */
2093     0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
2094     0x20, 0x21, 0x22
2095 };
2096
2097 static const unsigned char pkt_hdr_test_4_payload[] = {
2098     0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
2099     0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
2100     0x20, 0x21, 0x22
2101 };
2102
2103 static const struct pkt_hdr_test pkt_hdr_test_4 = {
2104     {
2105         QUIC_PKT_TYPE_0RTT,     /* type */
2106         0,                      /* spin bit */
2107         0,                      /* key phase */
2108         1,                      /* PN length */
2109         0,                      /* partial */
2110         1,                      /* fixed */
2111         1,                      /* version */
2112         { 3, {0x70, 0x71, 0x72} },                                /* DCID */
2113         { 8, {0xf0, 0x67, 0xa5, 0x50, 0x2a, 0x42, 0x62, 0xb5 } }, /* SCID */
2114         { 0x33 },               /* PN */
2115         NULL, 0,                /* Token */
2116         19, NULL                /* Len/Data */
2117     },
2118     pkt_hdr_test_4_expected, OSSL_NELEM(pkt_hdr_test_4_expected),
2119     pkt_hdr_test_4_payload,  OSSL_NELEM(pkt_hdr_test_4_payload),
2120     0, sizeof(pkt_hdr_test_4_expected),
2121     19, 23
2122 };
2123
2124 /* Packet Header Test 5: Handshake */
2125 static const unsigned char pkt_hdr_test_5_expected[] = {
2126     0xe0,                     /* Long|Fixed, Type=Handshake, PN Len=1 */
2127     0x00, 0x00, 0x00, 0x01,   /* Version */
2128     0x03,                     /* DCID Length */
2129     0x70, 0x71, 0x72,         /* DCID */
2130     0x08, 0xf0, 0x67, 0xa5, 0x50, 0x2a, 0x42, 0x62, 0xb5, /* SCID Length, SCID */
2131     0x14,                     /* Length=20 */
2132     0x33,                     /* Encoded PN */
2133     0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, /* Payload */
2134     0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
2135     0x20, 0x21, 0x22
2136 };
2137
2138 static const unsigned char pkt_hdr_test_5_payload[] = {
2139     0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
2140     0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
2141     0x20, 0x21, 0x22
2142 };
2143
2144 static const struct pkt_hdr_test pkt_hdr_test_5 = {
2145     {
2146         QUIC_PKT_TYPE_HANDSHAKE,    /* type */
2147         0,                          /* spin bit */
2148         0,                          /* key phase */
2149         1,                          /* PN length */
2150         0,                          /* partial */
2151         1,                      /* fixed */
2152         1,                          /* version */
2153         { 3, {0x70, 0x71, 0x72} },                                /* DCID */
2154         { 8, {0xf0, 0x67, 0xa5, 0x50, 0x2a, 0x42, 0x62, 0xb5 } }, /* SCID */
2155         { 0x33 },                   /* PN */
2156         NULL, 0,                    /* Token */
2157         19, NULL                    /* Len/Data */
2158     },
2159     pkt_hdr_test_5_expected, OSSL_NELEM(pkt_hdr_test_5_expected),
2160     pkt_hdr_test_5_payload,  OSSL_NELEM(pkt_hdr_test_5_payload),
2161     0, sizeof(pkt_hdr_test_5_expected),
2162     19, 23
2163 };
2164
2165 /* Packet Header Test 6: Retry */
2166 static const unsigned char pkt_hdr_test_6_expected[] = {
2167     0xf0,                     /* Long|Fixed, Type=Retry */
2168     0x00, 0x00, 0x00, 0x01,   /* Version */
2169     0x03,                     /* DCID Length */
2170     0x70, 0x71, 0x72,         /* DCID */
2171     0x08, 0xf0, 0x67, 0xa5, 0x50, 0x2a, 0x42, 0x62, 0xb5, /* SCID Length, SCID */
2172     0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,       /* Retry Token */
2173     0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
2174     0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f              /* Retry Integrity Tag */
2175 };
2176
2177 static const unsigned char pkt_hdr_test_6_payload[] = {
2178     0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,       /* Retry Token */
2179     0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
2180     0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f              /* Retry Integrity Tag */
2181 };
2182
2183 static const struct pkt_hdr_test pkt_hdr_test_6 = {
2184     {
2185         QUIC_PKT_TYPE_RETRY,        /* type */
2186         0,                          /* spin bit */
2187         0,                          /* key phase */
2188         0,                          /* PN length */
2189         0,                          /* partial */
2190         1,                          /* fixed */
2191         1,                          /* version */
2192         { 3, {0x70, 0x71, 0x72} },                                /* DCID */
2193         { 8, {0xf0, 0x67, 0xa5, 0x50, 0x2a, 0x42, 0x62, 0xb5 } }, /* SCID */
2194         { 0 },                      /* PN */
2195         NULL, 0,                    /* Token */
2196         24, NULL                    /* Len/Data */
2197     },
2198     pkt_hdr_test_6_expected, OSSL_NELEM(pkt_hdr_test_6_expected),
2199     pkt_hdr_test_6_payload,  OSSL_NELEM(pkt_hdr_test_6_payload),
2200     0, 21,
2201     SIZE_MAX, SIZE_MAX
2202 };
2203
2204 /* Packet Header Test 7: 1-RTT */
2205 static const unsigned char pkt_hdr_test_7_expected[] = {
2206     0x42,                     /* Short|Fixed, Type=1-RTT, PN Len=3 */
2207     0x70, 0x71, 0x72,         /* DCID */
2208     0x50, 0x51, 0x52,         /* PN */
2209     0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99,
2210     0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f, 0xa0, 0xa1
2211 };
2212
2213 static const unsigned char pkt_hdr_test_7_payload[] = {
2214     0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99,
2215     0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f, 0xa0, 0xa1
2216 };
2217
2218 static const struct pkt_hdr_test pkt_hdr_test_7 = {
2219     {
2220         QUIC_PKT_TYPE_1RTT,         /* type */
2221         0,                          /* spin bit */
2222         0,                          /* key phase */
2223         3,                          /* PN length */
2224         0,                          /* partial */
2225         1,                          /* fixed */
2226         0,                          /* version */
2227         { 3, {0x70, 0x71, 0x72} },  /* DCID */
2228         { 0, {0} },                 /* SCID */
2229         { 0x50, 0x51, 0x52 },       /* PN */
2230         NULL, 0,                    /* Token */
2231         18, NULL                    /* Len/Data */
2232     },
2233     pkt_hdr_test_7_expected, OSSL_NELEM(pkt_hdr_test_7_expected),
2234     pkt_hdr_test_7_payload,  OSSL_NELEM(pkt_hdr_test_7_payload),
2235     3, 21,
2236     4, 8
2237 };
2238
2239 /* Packet Header Test 8: 1-RTT with Spin Bit */
2240 static const unsigned char pkt_hdr_test_8_expected[] = {
2241     0x62,                     /* Short|Fixed, Type=1-RTT, PN Len=3, Spin=1 */
2242     0x70, 0x71, 0x72,         /* DCID */
2243     0x50, 0x51, 0x52,         /* PN */
2244     0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99,
2245     0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f, 0xa0, 0xa1
2246 };
2247
2248 static const unsigned char pkt_hdr_test_8_payload[] = {
2249     0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99,
2250     0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f, 0xa0, 0xa1
2251 };
2252
2253 static const struct pkt_hdr_test pkt_hdr_test_8 = {
2254     {
2255         QUIC_PKT_TYPE_1RTT,         /* type */
2256         1,                          /* spin bit */
2257         0,                          /* key phase */
2258         3,                          /* PN length */
2259         0,                          /* partial */
2260         1,                          /* fixed */
2261         0,                          /* version */
2262         { 3, {0x70, 0x71, 0x72} },  /* DCID */
2263         { 0, {0} },                 /* SCID */
2264         { 0x50, 0x51, 0x52 },       /* PN */
2265         NULL, 0,                    /* Token */
2266         18, NULL                    /* Len/Data */
2267     },
2268     pkt_hdr_test_8_expected, OSSL_NELEM(pkt_hdr_test_8_expected),
2269     pkt_hdr_test_8_payload,  OSSL_NELEM(pkt_hdr_test_8_payload),
2270     3, 21,
2271     4, 8
2272 };
2273
2274 /* Packet Header Test 9: 1-RTT with Key Phase Bit */
2275 static const unsigned char pkt_hdr_test_9_expected[] = {
2276     0x46,                     /* Short|Fixed, Type=1-RTT, PN Len=3, Key Phase=1 */
2277     0x70, 0x71, 0x72,         /* DCID */
2278     0x50, 0x51, 0x52,         /* PN */
2279     0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99,
2280     0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f, 0xa0, 0xa1
2281 };
2282
2283 static const unsigned char pkt_hdr_test_9_payload[] = {
2284     0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99,
2285     0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f, 0xa0, 0xa1
2286 };
2287
2288 static const struct pkt_hdr_test pkt_hdr_test_9 = {
2289     {
2290         QUIC_PKT_TYPE_1RTT,         /* type */
2291         0,                          /* spin bit */
2292         1,                          /* key phase */
2293         3,                          /* PN length */
2294         0,                          /* partial */
2295         1,                          /* fixed */
2296         0,                          /* version */
2297         { 3, {0x70, 0x71, 0x72} },  /* DCID */
2298         { 0, {0} },                 /* SCID */
2299         { 0x50, 0x51, 0x52 },       /* PN */
2300         NULL, 0,                    /* Token */
2301         18, NULL                    /* Len/Data */
2302     },
2303     pkt_hdr_test_9_expected, OSSL_NELEM(pkt_hdr_test_9_expected),
2304     pkt_hdr_test_9_payload,  OSSL_NELEM(pkt_hdr_test_9_payload),
2305     3, 21,
2306     4, 8
2307 };
2308
2309 /* Packet Header Test 10: Handshake with 4-Byte PN */
2310 static const unsigned char pkt_hdr_test_10_expected[] = {
2311     0xe3,                     /* Long|Fixed, Type=Handshake, PN Len=4 */
2312     0x00, 0x00, 0x00, 0x01,   /* Version */
2313     0x03,                     /* DCID Length */
2314     0x70, 0x71, 0x72,         /* DCID */
2315     0x08, 0xf0, 0x67, 0xa5, 0x50, 0x2a, 0x42, 0x62, 0xb5, /* SCID Length, SCID */
2316     0x17,                     /* Length=20 */
2317     0x33, 0x44, 0x55, 0x66,   /* Encoded PN */
2318     0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, /* Payload */
2319     0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
2320     0x20, 0x21, 0x22
2321 };
2322
2323 static const unsigned char pkt_hdr_test_10_payload[] = {
2324     0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
2325     0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
2326     0x20, 0x21, 0x22
2327 };
2328
2329 static const struct pkt_hdr_test pkt_hdr_test_10 = {
2330     {
2331         QUIC_PKT_TYPE_HANDSHAKE,    /* type */
2332         0,                          /* spin bit */
2333         0,                          /* key phase */
2334         4,                          /* PN length */
2335         0,                          /* partial */
2336         1,                          /* fixed */
2337         1,                          /* version */
2338         { 3, {0x70, 0x71, 0x72} },                                /* DCID */
2339         { 8, {0xf0, 0x67, 0xa5, 0x50, 0x2a, 0x42, 0x62, 0xb5 } }, /* SCID */
2340         { 0x33, 0x44, 0x55, 0x66 }, /* PN */
2341         NULL, 0,                    /* Token */
2342         19, NULL                    /* Len/Data */
2343     },
2344     pkt_hdr_test_10_expected, OSSL_NELEM(pkt_hdr_test_10_expected),
2345     pkt_hdr_test_10_payload,  OSSL_NELEM(pkt_hdr_test_10_payload),
2346     0, sizeof(pkt_hdr_test_10_expected),
2347     19, 23
2348 };
2349
2350 /* Packet Header Test 11: 1-RTT with 4-Byte PN */
2351 static const unsigned char pkt_hdr_test_11_expected[] = {
2352     0x43,                     /* Short|Fixed, Type=1-RTT, PN Len=4 */
2353     0x70, 0x71, 0x72,         /* DCID */
2354     0x50, 0x51, 0x52, 0x53,   /* PN */
2355     0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99,
2356     0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f, 0xa0, 0xa1
2357 };
2358
2359 static const unsigned char pkt_hdr_test_11_payload[] = {
2360     0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99,
2361     0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f, 0xa0, 0xa1
2362 };
2363
2364 static const struct pkt_hdr_test pkt_hdr_test_11 = {
2365     {
2366         QUIC_PKT_TYPE_1RTT,         /* type */
2367         0,                          /* spin bit */
2368         0,                          /* key phase */
2369         4,                          /* PN length */
2370         0,                          /* partial */
2371         1,                          /* fixed */
2372         0,                          /* version */
2373         { 3, {0x70, 0x71, 0x72} },  /* DCID */
2374         { 0, {0} },                 /* SCID */
2375         { 0x50, 0x51, 0x52, 0x53 }, /* PN */
2376         NULL, 0,                    /* Token */
2377         18, NULL                    /* Len/Data */
2378     },
2379     pkt_hdr_test_11_expected, OSSL_NELEM(pkt_hdr_test_11_expected),
2380     pkt_hdr_test_11_payload,  OSSL_NELEM(pkt_hdr_test_11_payload),
2381     3, 21,
2382     4, 8
2383 };
2384
2385 /* Packet Header Test 12: Version Negotiation */
2386 static const unsigned char pkt_hdr_test_12_expected[] = {
2387     0xc0,                       /* Long|Fixed, Type=Version Neg */
2388     0x00, 0x00, 0x00, 0x00,     /* Version (0) */
2389     0x03, 0x70, 0x71, 0x72,     /* DCID */
2390     0x02, 0x81, 0x82,           /* SCID */
2391     0x11, 0x22, 0x33, 0x44      /* One Version */
2392 };
2393
2394 static const unsigned char pkt_hdr_test_12_payload[] = {
2395     0x11, 0x22, 0x33, 0x44
2396 };
2397
2398 static const struct pkt_hdr_test pkt_hdr_test_12 = {
2399     {
2400         QUIC_PKT_TYPE_VERSION_NEG,  /* type */
2401         0,                          /* spin bit */
2402         0,                          /* key phase */
2403         0,                          /* PN length */
2404         0,                          /* partial */
2405         1,                          /* fixed */
2406         0,                          /* version */
2407         { 3, {0x70, 0x71, 0x72} },  /* DCID */
2408         { 2, {0x81, 0x82} },        /* SCID */
2409         { 0 },                      /* PN */
2410         NULL, 0,                    /* Token */
2411         4, NULL                     /* Len/Data */
2412     },
2413     pkt_hdr_test_12_expected, OSSL_NELEM(pkt_hdr_test_12_expected),
2414     pkt_hdr_test_12_payload,  OSSL_NELEM(pkt_hdr_test_12_payload),
2415     0, 12,
2416     SIZE_MAX, SIZE_MAX
2417 };
2418
2419 /* Packet Header Test 13: Version Negotiation without Fixed Bit */
2420 static const unsigned char pkt_hdr_test_13_expected[] = {
2421     0x80,                       /* Long|Fixed, Type=Version Neg */
2422     0x00, 0x00, 0x00, 0x00,     /* Version (0) */
2423     0x03, 0x70, 0x71, 0x72,     /* DCID */
2424     0x02, 0x81, 0x82,           /* SCID */
2425     0x11, 0x22, 0x33, 0x44      /* One Version */
2426 };
2427
2428 static const unsigned char pkt_hdr_test_13_payload[] = {
2429     0x11, 0x22, 0x33, 0x44
2430 };
2431
2432 static const struct pkt_hdr_test pkt_hdr_test_13 = {
2433     {
2434         QUIC_PKT_TYPE_VERSION_NEG,  /* type */
2435         0,                          /* spin bit */
2436         0,                          /* key phase */
2437         0,                          /* PN length */
2438         0,                          /* partial */
2439         0,                          /* fixed */
2440         0,                          /* version */
2441         { 3, {0x70, 0x71, 0x72} },  /* DCID */
2442         { 2, {0x81, 0x82} },        /* SCID */
2443         { 0 },                      /* PN */
2444         NULL, 0,                    /* Token */
2445         4, NULL                     /* Len/Data */
2446     },
2447     pkt_hdr_test_13_expected, OSSL_NELEM(pkt_hdr_test_13_expected),
2448     pkt_hdr_test_13_payload,  OSSL_NELEM(pkt_hdr_test_13_payload),
2449     0, 12,
2450     SIZE_MAX, SIZE_MAX
2451 };
2452
2453 /* Packet Header Test 14: 1-RTT - Malformed - No Fixed Bit */
2454 static const unsigned char pkt_hdr_test_14_expected[] = {
2455     0x02,                     /* Fixed, Type=1-RTT, PN Len=3 */
2456     0x70, 0x71, 0x72,         /* DCID */
2457     0x50, 0x51, 0x52,         /* PN */
2458     0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99,
2459     0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f, 0xa0, 0xa1
2460 };
2461
2462 static const struct pkt_hdr_test pkt_hdr_test_14 = {
2463     { 0 },
2464     pkt_hdr_test_14_expected, OSSL_NELEM(pkt_hdr_test_14_expected),
2465     NULL, 0,
2466     3, SIZE_MAX,
2467     4, 8
2468 };
2469
2470 /* Packet Header Test 15: Handshake - Malformed - No Fixed Bit */
2471 static const unsigned char pkt_hdr_test_15_expected[] = {
2472     0xa0,                     /* Long, Type=Handshake, PN Len=1 */
2473     0x00, 0x00, 0x00, 0x01,   /* Version */
2474     0x03,                     /* DCID Length */
2475     0x70, 0x71, 0x72,         /* DCID */
2476     0x08, 0xf0, 0x67, 0xa5, 0x50, 0x2a, 0x42, 0x62, 0xb5, /* SCID Length, SCID */
2477     0x14,                     /* Length=20 */
2478     0x33,                     /* Encoded PN */
2479     0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, /* Payload */
2480     0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
2481     0x20, 0x21, 0x22
2482 };
2483
2484 static const struct pkt_hdr_test pkt_hdr_test_15 = {
2485     { 0 },
2486     pkt_hdr_test_15_expected, OSSL_NELEM(pkt_hdr_test_15_expected),
2487     NULL, 0,
2488     0, SIZE_MAX,
2489     19, 23
2490 };
2491
2492 /* Packet Header Test 16: Handshake - Malformed - Wrong Version */
2493 static const unsigned char pkt_hdr_test_16_expected[] = {
2494     0xe0,                     /* Long|Fixed, Type=Handshake, PN Len=1 */
2495     0x00, 0x00, 0x00, 0x02,   /* Version */
2496     0x03,                     /* DCID Length */
2497     0x70, 0x71, 0x72,         /* DCID */
2498     0x08, 0xf0, 0x67, 0xa5, 0x50, 0x2a, 0x42, 0x62, 0xb5, /* SCID Length, SCID */
2499     0x14,                     /* Length=20 */
2500     0x33,                     /* Encoded PN */
2501     0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, /* Payload */
2502     0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
2503     0x20, 0x21, 0x22
2504 };
2505
2506 static const struct pkt_hdr_test pkt_hdr_test_16 = {
2507     { 0 },
2508     pkt_hdr_test_16_expected, OSSL_NELEM(pkt_hdr_test_16_expected),
2509     NULL, 0,
2510     0, SIZE_MAX,
2511     19, 23
2512 };
2513
2514 static const struct pkt_hdr_test *const pkt_hdr_tests[] = {
2515     &pkt_hdr_test_1,
2516     &pkt_hdr_test_2,
2517     &pkt_hdr_test_3,
2518     &pkt_hdr_test_4,
2519     &pkt_hdr_test_5,
2520     &pkt_hdr_test_6,
2521     &pkt_hdr_test_7,
2522     &pkt_hdr_test_8,
2523     &pkt_hdr_test_9,
2524     &pkt_hdr_test_10,
2525     &pkt_hdr_test_11,
2526     &pkt_hdr_test_12,
2527     &pkt_hdr_test_13,
2528     &pkt_hdr_test_14,
2529     &pkt_hdr_test_15,
2530     &pkt_hdr_test_16
2531 };
2532
2533 #define HPR_REPEAT_COUNT 4
2534 #define HPR_CIPHER_COUNT 3
2535
2536 /*
2537  * Count of number of times we observed an unchanged (u) or changed (c) bit in
2538  * each header-protectable bit over all test suites.
2539  */
2540 static unsigned int counts_u[HPR_CIPHER_COUNT][37] = {0};
2541 static unsigned int counts_c[HPR_CIPHER_COUNT][37] = {0};
2542
2543 static int test_wire_pkt_hdr_actual(int tidx, int repeat, int cipher,
2544                                     size_t trunc_len)
2545 {
2546     int testresult = 0;
2547     const struct pkt_hdr_test *t = pkt_hdr_tests[tidx];
2548     QUIC_PKT_HDR hdr = {0};
2549     QUIC_PKT_HDR_PTRS ptrs = {0}, wptrs = {0};
2550     PACKET pkt = {0};
2551     WPACKET wpkt = {0};
2552     BUF_MEM *buf = NULL;
2553     size_t l = 0, i, j;
2554     QUIC_HDR_PROTECTOR hpr = {0};
2555     unsigned char hpr_key[32] = {0,1,2,3,4,5,6,7};
2556     int have_hpr = 0, hpr_cipher_id, hpr_key_len;
2557     unsigned char *hbuf = NULL;
2558     int is_trunc = trunc_len < t->expected_len;
2559     int expect_fail = trunc_len < t->min_success_len;
2560     hpr_key[8] = (unsigned char)tidx;
2561     hpr_key[9] = (unsigned char)repeat;
2562
2563     switch (cipher) {
2564         case 0:
2565             hpr_cipher_id = QUIC_HDR_PROT_CIPHER_AES_128;
2566             hpr_key_len   = 16;
2567             break;
2568         case 1:
2569             hpr_cipher_id = QUIC_HDR_PROT_CIPHER_AES_256;
2570             hpr_key_len   = 32;
2571             break;
2572         case 2:
2573             /*
2574              * In a build without CHACHA, we rerun the AES 256 tests.
2575              * Removing all dependence on CHACHA is more difficult and these
2576              * tests are fast enough.
2577              */
2578 #ifndef OPENSSL_NO_CHACHA
2579             hpr_cipher_id = QUIC_HDR_PROT_CIPHER_CHACHA;
2580 #else
2581             hpr_cipher_id = QUIC_HDR_PROT_CIPHER_AES_256;
2582 #endif
2583             hpr_key_len   = 32;
2584             break;
2585         default:
2586             goto err;
2587     }
2588
2589     if (!TEST_ptr(buf = BUF_MEM_new()))
2590         goto err;
2591
2592     if (!TEST_true(WPACKET_init(&wpkt, buf)))
2593         goto err;
2594
2595     if (!TEST_true(PACKET_buf_init(&pkt, t->expected, trunc_len)))
2596         goto err;
2597
2598     if (!TEST_int_eq(ossl_quic_wire_decode_pkt_hdr(&pkt, t->short_conn_id_len,
2599                                                    0, &hdr, &ptrs),
2600                      !expect_fail))
2601         goto err;
2602
2603     if (!expect_fail && !is_trunc) {
2604         if (!TEST_true(cmp_pkt_hdr(&hdr, &t->hdr, t->payload, t->payload_len, 1)))
2605             goto err;
2606
2607         if (!TEST_ptr_eq(ptrs.raw_start, t->expected))
2608             goto err;
2609
2610         if (t->pn_offset == SIZE_MAX) {
2611             if (!TEST_ptr_null(ptrs.raw_pn))
2612                 goto err;
2613         } else {
2614             if (!TEST_ptr_eq(ptrs.raw_pn, t->expected + t->pn_offset))
2615                 goto err;
2616         }
2617
2618         if (t->sample_offset != SIZE_MAX) {
2619             if (!TEST_ptr_eq(ptrs.raw_sample, t->expected + t->sample_offset))
2620                 goto err;
2621             if (!TEST_size_t_eq(ptrs.raw_sample_len,
2622                                 t->expected_len - t->sample_offset))
2623                 goto err;
2624         }
2625
2626         if (!TEST_true(ossl_quic_wire_encode_pkt_hdr(&wpkt, t->short_conn_id_len, &hdr, &wptrs)))
2627             goto err;
2628
2629         if (!TEST_true(WPACKET_memcpy(&wpkt, t->payload, t->payload_len)))
2630             goto err;
2631
2632         if (!TEST_true(WPACKET_get_total_written(&wpkt, &l)))
2633             goto err;
2634
2635         if (!TEST_mem_eq(buf->data, l, t->expected, t->expected_len))
2636             goto err;
2637
2638         /* Test header protection. */
2639         if (t->sample_offset != SIZE_MAX) { /* if packet type has protection */
2640             if (!TEST_true(ossl_quic_hdr_protector_init(&hpr, NULL, NULL,
2641                                                         hpr_cipher_id,
2642                                                         hpr_key,
2643                                                         hpr_key_len)))
2644                 goto err;
2645
2646             have_hpr = 1;
2647
2648             /*
2649              * Copy into a duplicate buffer to test header protection by
2650              * comparing it against the original.
2651              */
2652             hbuf = OPENSSL_malloc(t->expected_len);
2653             if (!TEST_ptr(hbuf))
2654                 goto err;
2655
2656             memcpy(hbuf, t->expected, t->expected_len);
2657
2658             /* Fixup pointers to new buffer and encrypt. */
2659             ptrs.raw_pn         = hbuf + (ptrs.raw_pn     - ptrs.raw_start);
2660             ptrs.raw_sample     = hbuf + (ptrs.raw_sample - ptrs.raw_start);
2661             ptrs.raw_start      = hbuf;
2662             if (!TEST_true(ossl_quic_hdr_protector_encrypt(&hpr, &ptrs)))
2663                 goto err;
2664
2665             /* Ensure that bytes which should not have changed did not change */
2666             for (i = 0; i < t->expected_len; ++i) {
2667                 unsigned char d = t->expected[i] ^ hbuf[i], rej_mask = 0xff;
2668                 size_t jrel = 0;
2669                 if (i == 0) {
2670                     /* Bits in first byte which must not change */
2671                     rej_mask = (t->hdr.type == QUIC_PKT_TYPE_1RTT) ? ~0x1f : ~0xf;
2672                 } else if (i >= t->pn_offset && i < t->pn_offset + t->hdr.pn_len) {
2673                     /* PN bytes change */
2674                     rej_mask = 0;
2675                     jrel = 5 + (i - t->pn_offset) * 8;
2676                 }
2677
2678                 if (rej_mask != 0xff)
2679                     for (j = 0; j < 8; ++j) {
2680                         if (((1U << j) & rej_mask) != 0)
2681                             /*
2682                              * Bit unrelated to header protection, do not record
2683                              * stats about it.
2684                              */
2685                             continue;
2686
2687                         OPENSSL_assert(jrel + j < OSSL_NELEM(counts_u[cipher]));
2688                         if ((d & (1U << j)) != 0)
2689                             ++counts_c[cipher][jrel + j]; /* bit did change */
2690                         else
2691                             ++counts_u[cipher][jrel + j]; /* bit did not change */
2692                     }
2693
2694                 /* Bits in rej_mask must not change */
2695                 if (!TEST_int_eq(d & rej_mask, 0))
2696                     goto err;
2697             }
2698
2699             /* Decrypt and check matches original. */
2700             if (!TEST_true(ossl_quic_hdr_protector_decrypt(&hpr, &ptrs)))
2701                 goto err;
2702
2703             if (!TEST_mem_eq(hbuf, t->expected_len, t->expected, t->expected_len))
2704                 goto err;
2705         }
2706     }
2707
2708     testresult = 1;
2709 err:
2710     if (have_hpr)
2711         ossl_quic_hdr_protector_cleanup(&hpr);
2712     WPACKET_finish(&wpkt);
2713     BUF_MEM_free(buf);
2714     OPENSSL_free(hbuf);
2715     return testresult;
2716 }
2717
2718 static int test_wire_pkt_hdr_inner(int tidx, int repeat, int cipher)
2719 {
2720     int testresult = 0;
2721     const struct pkt_hdr_test *t = pkt_hdr_tests[tidx];
2722     size_t i;
2723
2724     /* Test with entire packet */
2725     if (!TEST_true(test_wire_pkt_hdr_actual(tidx, repeat, cipher,
2726                                             t->expected_len)))
2727         goto err;
2728
2729     /* Now repeat for every possible truncation of the packet */
2730     for (i = 0; i < t->expected_len; ++i)
2731         if (!TEST_true(test_wire_pkt_hdr_actual(tidx, repeat, cipher, i)))
2732             goto err;
2733
2734     testresult = 1;
2735 err:
2736     return testresult;
2737 }
2738
2739 static int test_hdr_prot_stats(void)
2740 {
2741     int testresult = 0;
2742     size_t i, cipher;
2743
2744     /*
2745      * Test that, across all previously executed tests for each header
2746      * protection cipher, every bit which can have header protection applied a)
2747      * was changed in at least one test of applying header protection, and b)
2748      * was unchanged in at least one test of applying header protection.
2749      */
2750     for (cipher = 0; cipher < HPR_CIPHER_COUNT; ++cipher)
2751         for (i = 0; i < OSSL_NELEM(counts_u[0]); ++i) {
2752             if (!TEST_uint_gt(counts_u[cipher][i], 0))
2753                 goto err;
2754             if (!TEST_uint_gt(counts_c[cipher][i], 0))
2755                 goto err;
2756         }
2757
2758     testresult = 1;
2759 err:
2760     return testresult;
2761 }
2762
2763 #define NUM_WIRE_PKT_HDR_TESTS \
2764     (OSSL_NELEM(pkt_hdr_tests) * HPR_REPEAT_COUNT * HPR_CIPHER_COUNT)
2765
2766 static int test_wire_pkt_hdr(int idx)
2767 {
2768     int tidx, repeat, cipher;
2769
2770     if (idx == NUM_WIRE_PKT_HDR_TESTS)
2771         return test_hdr_prot_stats();
2772
2773     cipher = idx % HPR_CIPHER_COUNT;
2774     idx /= HPR_CIPHER_COUNT;
2775
2776     repeat = idx % HPR_REPEAT_COUNT;
2777     idx /= HPR_REPEAT_COUNT;
2778
2779     tidx = idx;
2780
2781     return test_wire_pkt_hdr_inner(tidx, repeat, cipher);
2782 }
2783
2784 /* TX Tests */
2785 #define TX_TEST_OP_END                     0 /* end of script */
2786 #define TX_TEST_OP_WRITE                   1 /* write packet */
2787 #define TX_TEST_OP_PROVIDE_SECRET          2 /* provide TX secret */
2788 #define TX_TEST_OP_PROVIDE_SECRET_INITIAL  3 /* provide TX secret for initial */
2789 #define TX_TEST_OP_DISCARD_EL              4 /* discard an encryption level */
2790 #define TX_TEST_OP_CHECK_DGRAM             5 /* read datagram, compare to expected */
2791 #define TX_TEST_OP_CHECK_NO_DGRAM          6 /* check no datagram is in queue */
2792 #define TX_TEST_OP_KEY_UPDATE              7 /* perform key update for 1-RTT */
2793
2794 struct tx_test_op {
2795     unsigned char op;
2796     const unsigned char *buf;
2797     size_t buf_len;
2798     const OSSL_QTX_PKT *pkt;
2799     uint32_t enc_level, suite_id;
2800     const QUIC_CONN_ID *dcid;
2801 };
2802
2803 #define TX_OP_END                                                       \
2804     { TX_TEST_OP_END }
2805 #define TX_OP_WRITE(pkt)                                                \
2806     { TX_TEST_OP_WRITE, NULL, 0, &(pkt), 0, 0, NULL },
2807 #define TX_OP_PROVIDE_SECRET(el, suite, key)                            \
2808     {                                                                   \
2809         TX_TEST_OP_PROVIDE_SECRET, (key), sizeof(key),                  \
2810         NULL, (el), (suite), NULL                                       \
2811     },
2812 #define TX_OP_PROVIDE_SECRET_INITIAL(dcid, is_server)                   \
2813     { TX_TEST_OP_PROVIDE_SECRET_INITIAL,                                \
2814       NULL, 0, NULL, 0, (is_server), &(dcid) },
2815 #define TX_OP_DISCARD_EL(el)                                            \
2816     { TX_TEST_OP_DISCARD_EL, NULL, 0, NULL, (el), 0, NULL },
2817 #define TX_OP_CHECK_DGRAM(expect_dgram)                                 \
2818     {                                                                   \
2819         TX_TEST_OP_CHECK_DGRAM, (expect_dgram), sizeof(expect_dgram),   \
2820         NULL, 0, 0, NULL                                                \
2821     },
2822 #define TX_OP_CHECK_NO_DGRAM() \
2823     { TX_TEST_OP_CHECK_NO_PKT, NULL, 0, NULL, 0, 0, NULL },
2824
2825 #define TX_OP_WRITE_N(n)                                                \
2826     TX_OP_WRITE(tx_script_##n##_pkt)
2827 #define TX_OP_CHECK_DGRAM_N(n)                                          \
2828     TX_OP_CHECK_DGRAM(tx_script_##n##_dgram)
2829
2830 #define TX_OP_WRITE_CHECK(n)                                            \
2831     TX_OP_WRITE_N(n)                                                    \
2832     TX_OP_CHECK_DGRAM_N(n)
2833
2834 #define TX_OP_KEY_UPDATE()                                              \
2835     { TX_TEST_OP_KEY_UPDATE, NULL, 0, NULL, 0, 0, NULL },
2836
2837 /* 1. RFC 9001 - A.2 Client Initial */
2838 static const unsigned char tx_script_1_body[1162] = {
2839     0x06, 0x00, 0x40, 0xf1, 0x01, 0x00, 0x00, 0xed, 0x03, 0x03, 0xeb, 0xf8,
2840     0xfa, 0x56, 0xf1, 0x29, 0x39, 0xb9, 0x58, 0x4a, 0x38, 0x96, 0x47, 0x2e,
2841     0xc4, 0x0b, 0xb8, 0x63, 0xcf, 0xd3, 0xe8, 0x68, 0x04, 0xfe, 0x3a, 0x47,
2842     0xf0, 0x6a, 0x2b, 0x69, 0x48, 0x4c, 0x00, 0x00, 0x04, 0x13, 0x01, 0x13,
2843     0x02, 0x01, 0x00, 0x00, 0xc0, 0x00, 0x00, 0x00, 0x10, 0x00, 0x0e, 0x00,
2844     0x00, 0x0b, 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x2e, 0x63, 0x6f,
2845     0x6d, 0xff, 0x01, 0x00, 0x01, 0x00, 0x00, 0x0a, 0x00, 0x08, 0x00, 0x06,
2846     0x00, 0x1d, 0x00, 0x17, 0x00, 0x18, 0x00, 0x10, 0x00, 0x07, 0x00, 0x05,
2847     0x04, 0x61, 0x6c, 0x70, 0x6e, 0x00, 0x05, 0x00, 0x05, 0x01, 0x00, 0x00,
2848     0x00, 0x00, 0x00, 0x33, 0x00, 0x26, 0x00, 0x24, 0x00, 0x1d, 0x00, 0x20,
2849     0x93, 0x70, 0xb2, 0xc9, 0xca, 0xa4, 0x7f, 0xba, 0xba, 0xf4, 0x55, 0x9f,
2850     0xed, 0xba, 0x75, 0x3d, 0xe1, 0x71, 0xfa, 0x71, 0xf5, 0x0f, 0x1c, 0xe1,
2851     0x5d, 0x43, 0xe9, 0x94, 0xec, 0x74, 0xd7, 0x48, 0x00, 0x2b, 0x00, 0x03,
2852     0x02, 0x03, 0x04, 0x00, 0x0d, 0x00, 0x10, 0x00, 0x0e, 0x04, 0x03, 0x05,
2853     0x03, 0x06, 0x03, 0x02, 0x03, 0x08, 0x04, 0x08, 0x05, 0x08, 0x06, 0x00,
2854     0x2d, 0x00, 0x02, 0x01, 0x01, 0x00, 0x1c, 0x00, 0x02, 0x40, 0x01, 0x00,
2855     0x39, 0x00, 0x32, 0x04, 0x08, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
2856     0xff, 0x05, 0x04, 0x80, 0x00, 0xff, 0xff, 0x07, 0x04, 0x80, 0x00, 0xff,
2857     0xff, 0x08, 0x01, 0x10, 0x01, 0x04, 0x80, 0x00, 0x75, 0x30, 0x09, 0x01,
2858     0x10, 0x0f, 0x08, 0x83, 0x94, 0xc8, 0xf0, 0x3e, 0x51, 0x57, 0x08, 0x06,
2859     0x04, 0x80, 0x00, 0xff, 0xff /* followed by zero padding */
2860 };
2861
2862 static const unsigned char tx_script_1_dgram[] = {
2863     0xc0, 0x00, 0x00, 0x00, 0x01, 0x08, 0x83, 0x94, 0xc8, 0xf0, 0x3e, 0x51,
2864     0x57, 0x08, 0x00, 0x00, 0x44, 0x9e, 0x7b, 0x9a, 0xec, 0x34, 0xd1, 0xb1,
2865     0xc9, 0x8d, 0xd7, 0x68, 0x9f, 0xb8, 0xec, 0x11, 0xd2, 0x42, 0xb1, 0x23,
2866     0xdc, 0x9b, 0xd8, 0xba, 0xb9, 0x36, 0xb4, 0x7d, 0x92, 0xec, 0x35, 0x6c,
2867     0x0b, 0xab, 0x7d, 0xf5, 0x97, 0x6d, 0x27, 0xcd, 0x44, 0x9f, 0x63, 0x30,
2868     0x00, 0x99, 0xf3, 0x99, 0x1c, 0x26, 0x0e, 0xc4, 0xc6, 0x0d, 0x17, 0xb3,
2869     0x1f, 0x84, 0x29, 0x15, 0x7b, 0xb3, 0x5a, 0x12, 0x82, 0xa6, 0x43, 0xa8,
2870     0xd2, 0x26, 0x2c, 0xad, 0x67, 0x50, 0x0c, 0xad, 0xb8, 0xe7, 0x37, 0x8c,
2871     0x8e, 0xb7, 0x53, 0x9e, 0xc4, 0xd4, 0x90, 0x5f, 0xed, 0x1b, 0xee, 0x1f,
2872     0xc8, 0xaa, 0xfb, 0xa1, 0x7c, 0x75, 0x0e, 0x2c, 0x7a, 0xce, 0x01, 0xe6,
2873     0x00, 0x5f, 0x80, 0xfc, 0xb7, 0xdf, 0x62, 0x12, 0x30, 0xc8, 0x37, 0x11,
2874     0xb3, 0x93, 0x43, 0xfa, 0x02, 0x8c, 0xea, 0x7f, 0x7f, 0xb5, 0xff, 0x89,
2875     0xea, 0xc2, 0x30, 0x82, 0x49, 0xa0, 0x22, 0x52, 0x15, 0x5e, 0x23, 0x47,
2876     0xb6, 0x3d, 0x58, 0xc5, 0x45, 0x7a, 0xfd, 0x84, 0xd0, 0x5d, 0xff, 0xfd,
2877     0xb2, 0x03, 0x92, 0x84, 0x4a, 0xe8, 0x12, 0x15, 0x46, 0x82, 0xe9, 0xcf,
2878     0x01, 0x2f, 0x90, 0x21, 0xa6, 0xf0, 0xbe, 0x17, 0xdd, 0xd0, 0xc2, 0x08,
2879     0x4d, 0xce, 0x25, 0xff, 0x9b, 0x06, 0xcd, 0xe5, 0x35, 0xd0, 0xf9, 0x20,
2880     0xa2, 0xdb, 0x1b, 0xf3, 0x62, 0xc2, 0x3e, 0x59, 0x6d, 0x11, 0xa4, 0xf5,
2881     0xa6, 0xcf, 0x39, 0x48, 0x83, 0x8a, 0x3a, 0xec, 0x4e, 0x15, 0xda, 0xf8,
2882     0x50, 0x0a, 0x6e, 0xf6, 0x9e, 0xc4, 0xe3, 0xfe, 0xb6, 0xb1, 0xd9, 0x8e,
2883     0x61, 0x0a, 0xc8, 0xb7, 0xec, 0x3f, 0xaf, 0x6a, 0xd7, 0x60, 0xb7, 0xba,
2884     0xd1, 0xdb, 0x4b, 0xa3, 0x48, 0x5e, 0x8a, 0x94, 0xdc, 0x25, 0x0a, 0xe3,
2885     0xfd, 0xb4, 0x1e, 0xd1, 0x5f, 0xb6, 0xa8, 0xe5, 0xeb, 0xa0, 0xfc, 0x3d,
2886     0xd6, 0x0b, 0xc8, 0xe3, 0x0c, 0x5c, 0x42, 0x87, 0xe5, 0x38, 0x05, 0xdb,
2887     0x05, 0x9a, 0xe0, 0x64, 0x8d, 0xb2, 0xf6, 0x42, 0x64, 0xed, 0x5e, 0x39,
2888     0xbe, 0x2e, 0x20, 0xd8, 0x2d, 0xf5, 0x66, 0xda, 0x8d, 0xd5, 0x99, 0x8c,
2889     0xca, 0xbd, 0xae, 0x05, 0x30, 0x60, 0xae, 0x6c, 0x7b, 0x43, 0x78, 0xe8,
2890     0x46, 0xd2, 0x9f, 0x37, 0xed, 0x7b, 0x4e, 0xa9, 0xec, 0x5d, 0x82, 0xe7,
2891     0x96, 0x1b, 0x7f, 0x25, 0xa9, 0x32, 0x38, 0x51, 0xf6, 0x81, 0xd5, 0x82,
2892     0x36, 0x3a, 0xa5, 0xf8, 0x99, 0x37, 0xf5, 0xa6, 0x72, 0x58, 0xbf, 0x63,
2893     0xad, 0x6f, 0x1a, 0x0b, 0x1d, 0x96, 0xdb, 0xd4, 0xfa, 0xdd, 0xfc, 0xef,
2894     0xc5, 0x26, 0x6b, 0xa6, 0x61, 0x17, 0x22, 0x39, 0x5c, 0x90, 0x65, 0x56,
2895     0xbe, 0x52, 0xaf, 0xe3, 0xf5, 0x65, 0x63, 0x6a, 0xd1, 0xb1, 0x7d, 0x50,
2896     0x8b, 0x73, 0xd8, 0x74, 0x3e, 0xeb, 0x52, 0x4b, 0xe2, 0x2b, 0x3d, 0xcb,
2897     0xc2, 0xc7, 0x46, 0x8d, 0x54, 0x11, 0x9c, 0x74, 0x68, 0x44, 0x9a, 0x13,
2898     0xd8, 0xe3, 0xb9, 0x58, 0x11, 0xa1, 0x98, 0xf3, 0x49, 0x1d, 0xe3, 0xe7,
2899     0xfe, 0x94, 0x2b, 0x33, 0x04, 0x07, 0xab, 0xf8, 0x2a, 0x4e, 0xd7, 0xc1,
2900     0xb3, 0x11, 0x66, 0x3a, 0xc6, 0x98, 0x90, 0xf4, 0x15, 0x70, 0x15, 0x85,
2901     0x3d, 0x91, 0xe9, 0x23, 0x03, 0x7c, 0x22, 0x7a, 0x33, 0xcd, 0xd5, 0xec,
2902     0x28, 0x1c, 0xa3, 0xf7, 0x9c, 0x44, 0x54, 0x6b, 0x9d, 0x90, 0xca, 0x00,
2903     0xf0, 0x64, 0xc9, 0x9e, 0x3d, 0xd9, 0x79, 0x11, 0xd3, 0x9f, 0xe9, 0xc5,
2904     0xd0, 0xb2, 0x3a, 0x22, 0x9a, 0x23, 0x4c, 0xb3, 0x61, 0x86, 0xc4, 0x81,
2905     0x9e, 0x8b, 0x9c, 0x59, 0x27, 0x72, 0x66, 0x32, 0x29, 0x1d, 0x6a, 0x41,
2906     0x82, 0x11, 0xcc, 0x29, 0x62, 0xe2, 0x0f, 0xe4, 0x7f, 0xeb, 0x3e, 0xdf,
2907     0x33, 0x0f, 0x2c, 0x60, 0x3a, 0x9d, 0x48, 0xc0, 0xfc, 0xb5, 0x69, 0x9d,
2908     0xbf, 0xe5, 0x89, 0x64, 0x25, 0xc5, 0xba, 0xc4, 0xae, 0xe8, 0x2e, 0x57,
2909     0xa8, 0x5a, 0xaf, 0x4e, 0x25, 0x13, 0xe4, 0xf0, 0x57, 0x96, 0xb0, 0x7b,
2910     0xa2, 0xee, 0x47, 0xd8, 0x05, 0x06, 0xf8, 0xd2, 0xc2, 0x5e, 0x50, 0xfd,
2911     0x14, 0xde, 0x71, 0xe6, 0xc4, 0x18, 0x55, 0x93, 0x02, 0xf9, 0x39, 0xb0,
2912     0xe1, 0xab, 0xd5, 0x76, 0xf2, 0x79, 0xc4, 0xb2, 0xe0, 0xfe, 0xb8, 0x5c,
2913     0x1f, 0x28, 0xff, 0x18, 0xf5, 0x88, 0x91, 0xff, 0xef, 0x13, 0x2e, 0xef,
2914     0x2f, 0xa0, 0x93, 0x46, 0xae, 0xe3, 0x3c, 0x28, 0xeb, 0x13, 0x0f, 0xf2,
2915     0x8f, 0x5b, 0x76, 0x69, 0x53, 0x33, 0x41, 0x13, 0x21, 0x19, 0x96, 0xd2,
2916     0x00, 0x11, 0xa1, 0x98, 0xe3, 0xfc, 0x43, 0x3f, 0x9f, 0x25, 0x41, 0x01,
2917     0x0a, 0xe1, 0x7c, 0x1b, 0xf2, 0x02, 0x58, 0x0f, 0x60, 0x47, 0x47, 0x2f,
2918     0xb3, 0x68, 0x57, 0xfe, 0x84, 0x3b, 0x19, 0xf5, 0x98, 0x40, 0x09, 0xdd,
2919     0xc3, 0x24, 0x04, 0x4e, 0x84, 0x7a, 0x4f, 0x4a, 0x0a, 0xb3, 0x4f, 0x71,
2920     0x95, 0x95, 0xde, 0x37, 0x25, 0x2d, 0x62, 0x35, 0x36, 0x5e, 0x9b, 0x84,
2921     0x39, 0x2b, 0x06, 0x10, 0x85, 0x34, 0x9d, 0x73, 0x20, 0x3a, 0x4a, 0x13,
2922     0xe9, 0x6f, 0x54, 0x32, 0xec, 0x0f, 0xd4, 0xa1, 0xee, 0x65, 0xac, 0xcd,
2923     0xd5, 0xe3, 0x90, 0x4d, 0xf5, 0x4c, 0x1d, 0xa5, 0x10, 0xb0, 0xff, 0x20,
2924     0xdc, 0xc0, 0xc7, 0x7f, 0xcb, 0x2c, 0x0e, 0x0e, 0xb6, 0x05, 0xcb, 0x05,
2925     0x04, 0xdb, 0x87, 0x63, 0x2c, 0xf3, 0xd8, 0xb4, 0xda, 0xe6, 0xe7, 0x05,
2926     0x76, 0x9d, 0x1d, 0xe3, 0x54, 0x27, 0x01, 0x23, 0xcb, 0x11, 0x45, 0x0e,
2927     0xfc, 0x60, 0xac, 0x47, 0x68, 0x3d, 0x7b, 0x8d, 0x0f, 0x81, 0x13, 0x65,
2928     0x56, 0x5f, 0xd9, 0x8c, 0x4c, 0x8e, 0xb9, 0x36, 0xbc, 0xab, 0x8d, 0x06,
2929     0x9f, 0xc3, 0x3b, 0xd8, 0x01, 0xb0, 0x3a, 0xde, 0xa2, 0xe1, 0xfb, 0xc5,
2930     0xaa, 0x46, 0x3d, 0x08, 0xca, 0x19, 0x89, 0x6d, 0x2b, 0xf5, 0x9a, 0x07,
2931     0x1b, 0x85, 0x1e, 0x6c, 0x23, 0x90, 0x52, 0x17, 0x2f, 0x29, 0x6b, 0xfb,
2932     0x5e, 0x72, 0x40, 0x47, 0x90, 0xa2, 0x18, 0x10, 0x14, 0xf3, 0xb9, 0x4a,
2933     0x4e, 0x97, 0xd1, 0x17, 0xb4, 0x38, 0x13, 0x03, 0x68, 0xcc, 0x39, 0xdb,
2934     0xb2, 0xd1, 0x98, 0x06, 0x5a, 0xe3, 0x98, 0x65, 0x47, 0x92, 0x6c, 0xd2,
2935     0x16, 0x2f, 0x40, 0xa2, 0x9f, 0x0c, 0x3c, 0x87, 0x45, 0xc0, 0xf5, 0x0f,
2936     0xba, 0x38, 0x52, 0xe5, 0x66, 0xd4, 0x45, 0x75, 0xc2, 0x9d, 0x39, 0xa0,
2937     0x3f, 0x0c, 0xda, 0x72, 0x19, 0x84, 0xb6, 0xf4, 0x40, 0x59, 0x1f, 0x35,
2938     0x5e, 0x12, 0xd4, 0x39, 0xff, 0x15, 0x0a, 0xab, 0x76, 0x13, 0x49, 0x9d,
2939     0xbd, 0x49, 0xad, 0xab, 0xc8, 0x67, 0x6e, 0xef, 0x02, 0x3b, 0x15, 0xb6,
2940     0x5b, 0xfc, 0x5c, 0xa0, 0x69, 0x48, 0x10, 0x9f, 0x23, 0xf3, 0x50, 0xdb,
2941     0x82, 0x12, 0x35, 0x35, 0xeb, 0x8a, 0x74, 0x33, 0xbd, 0xab, 0xcb, 0x90,
2942     0x92, 0x71, 0xa6, 0xec, 0xbc, 0xb5, 0x8b, 0x93, 0x6a, 0x88, 0xcd, 0x4e,
2943     0x8f, 0x2e, 0x6f, 0xf5, 0x80, 0x01, 0x75, 0xf1, 0x13, 0x25, 0x3d, 0x8f,
2944     0xa9, 0xca, 0x88, 0x85, 0xc2, 0xf5, 0x52, 0xe6, 0x57, 0xdc, 0x60, 0x3f,
2945     0x25, 0x2e, 0x1a, 0x8e, 0x30, 0x8f, 0x76, 0xf0, 0xbe, 0x79, 0xe2, 0xfb,
2946     0x8f, 0x5d, 0x5f, 0xbb, 0xe2, 0xe3, 0x0e, 0xca, 0xdd, 0x22, 0x07, 0x23,
2947     0xc8, 0xc0, 0xae, 0xa8, 0x07, 0x8c, 0xdf, 0xcb, 0x38, 0x68, 0x26, 0x3f,
2948     0xf8, 0xf0, 0x94, 0x00, 0x54, 0xda, 0x48, 0x78, 0x18, 0x93, 0xa7, 0xe4,
2949     0x9a, 0xd5, 0xaf, 0xf4, 0xaf, 0x30, 0x0c, 0xd8, 0x04, 0xa6, 0xb6, 0x27,
2950     0x9a, 0xb3, 0xff, 0x3a, 0xfb, 0x64, 0x49, 0x1c, 0x85, 0x19, 0x4a, 0xab,
2951     0x76, 0x0d, 0x58, 0xa6, 0x06, 0x65, 0x4f, 0x9f, 0x44, 0x00, 0xe8, 0xb3,
2952     0x85, 0x91, 0x35, 0x6f, 0xbf, 0x64, 0x25, 0xac, 0xa2, 0x6d, 0xc8, 0x52,
2953     0x44, 0x25, 0x9f, 0xf2, 0xb1, 0x9c, 0x41, 0xb9, 0xf9, 0x6f, 0x3c, 0xa9,
2954     0xec, 0x1d, 0xde, 0x43, 0x4d, 0xa7, 0xd2, 0xd3, 0x92, 0xb9, 0x05, 0xdd,
2955     0xf3, 0xd1, 0xf9, 0xaf, 0x93, 0xd1, 0xaf, 0x59, 0x50, 0xbd, 0x49, 0x3f,
2956     0x5a, 0xa7, 0x31, 0xb4, 0x05, 0x6d, 0xf3, 0x1b, 0xd2, 0x67, 0xb6, 0xb9,
2957     0x0a, 0x07, 0x98, 0x31, 0xaa, 0xf5, 0x79, 0xbe, 0x0a, 0x39, 0x01, 0x31,
2958     0x37, 0xaa, 0xc6, 0xd4, 0x04, 0xf5, 0x18, 0xcf, 0xd4, 0x68, 0x40, 0x64,
2959     0x7e, 0x78, 0xbf, 0xe7, 0x06, 0xca, 0x4c, 0xf5, 0xe9, 0xc5, 0x45, 0x3e,
2960     0x9f, 0x7c, 0xfd, 0x2b, 0x8b, 0x4c, 0x8d, 0x16, 0x9a, 0x44, 0xe5, 0x5c,
2961     0x88, 0xd4, 0xa9, 0xa7, 0xf9, 0x47, 0x42, 0x41, 0xe2, 0x21, 0xaf, 0x44,
2962     0x86, 0x00, 0x18, 0xab, 0x08, 0x56, 0x97, 0x2e, 0x19, 0x4c, 0xd9, 0x34
2963 };
2964
2965 static QUIC_PKT_HDR tx_script_1_hdr = {
2966     QUIC_PKT_TYPE_INITIAL,      /* type */
2967     0,                          /* spin bit */
2968     0,                          /* key phase */
2969     4,                          /* PN length */
2970     0,                          /* partial */
2971     0,                          /* fixed */
2972     1,                          /* version */
2973     {8, {0x83, 0x94, 0xc8, 0xf0, 0x3e, 0x51, 0x57, 0x08}}, /* DCID */
2974     { 0, {0} },                 /* SCID */
2975     { 0 },                      /* PN */
2976     NULL, 0,                    /* Token */
2977     5555, NULL                  /* Len/Data */
2978 };
2979
2980 static const OSSL_QTX_IOVEC tx_script_1_iovec[] = {
2981     { tx_script_1_body, sizeof(tx_script_1_body) }
2982 };
2983
2984 static const OSSL_QTX_PKT tx_script_1_pkt = {
2985     &tx_script_1_hdr,
2986     tx_script_1_iovec,
2987     OSSL_NELEM(tx_script_1_iovec),
2988     NULL, NULL,
2989     2,
2990     0
2991 };
2992
2993 static const struct tx_test_op tx_script_1[] = {
2994     TX_OP_PROVIDE_SECRET_INITIAL(tx_script_1_hdr.dst_conn_id, 0)
2995     TX_OP_WRITE_CHECK(1)
2996     TX_OP_END
2997 };
2998
2999 /* 2. RFC 9001 - A.3 Server Initial */
3000 static const unsigned char tx_script_2_body[] = {
3001     0x02, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x40, 0x5a, 0x02, 0x00, 0x00,
3002     0x56, 0x03, 0x03, 0xee, 0xfc, 0xe7, 0xf7, 0xb3, 0x7b, 0xa1, 0xd1, 0x63,
3003     0x2e, 0x96, 0x67, 0x78, 0x25, 0xdd, 0xf7, 0x39, 0x88, 0xcf, 0xc7, 0x98,
3004     0x25, 0xdf, 0x56, 0x6d, 0xc5, 0x43, 0x0b, 0x9a, 0x04, 0x5a, 0x12, 0x00,
3005     0x13, 0x01, 0x00, 0x00, 0x2e, 0x00, 0x33, 0x00, 0x24, 0x00, 0x1d, 0x00,
3006     0x20, 0x9d, 0x3c, 0x94, 0x0d, 0x89, 0x69, 0x0b, 0x84, 0xd0, 0x8a, 0x60,
3007     0x99, 0x3c, 0x14, 0x4e, 0xca, 0x68, 0x4d, 0x10, 0x81, 0x28, 0x7c, 0x83,
3008     0x4d, 0x53, 0x11, 0xbc, 0xf3, 0x2b, 0xb9, 0xda, 0x1a, 0x00, 0x2b, 0x00,
3009     0x02, 0x03, 0x04
3010 };
3011
3012 static const unsigned char tx_script_2_dgram[] = {
3013
3014     0xcf, 0x00, 0x00, 0x00, 0x01, 0x00, 0x08, 0xf0, 0x67, 0xa5, 0x50, 0x2a,
3015     0x42, 0x62, 0xb5, 0x00, 0x40, 0x75, 0xc0, 0xd9, 0x5a, 0x48, 0x2c, 0xd0,
3016     0x99, 0x1c, 0xd2, 0x5b, 0x0a, 0xac, 0x40, 0x6a, 0x58, 0x16, 0xb6, 0x39,
3017     0x41, 0x00, 0xf3, 0x7a, 0x1c, 0x69, 0x79, 0x75, 0x54, 0x78, 0x0b, 0xb3,
3018     0x8c, 0xc5, 0xa9, 0x9f, 0x5e, 0xde, 0x4c, 0xf7, 0x3c, 0x3e, 0xc2, 0x49,
3019     0x3a, 0x18, 0x39, 0xb3, 0xdb, 0xcb, 0xa3, 0xf6, 0xea, 0x46, 0xc5, 0xb7,
3020     0x68, 0x4d, 0xf3, 0x54, 0x8e, 0x7d, 0xde, 0xb9, 0xc3, 0xbf, 0x9c, 0x73,
3021     0xcc, 0x3f, 0x3b, 0xde, 0xd7, 0x4b, 0x56, 0x2b, 0xfb, 0x19, 0xfb, 0x84,
3022     0x02, 0x2f, 0x8e, 0xf4, 0xcd, 0xd9, 0x37, 0x95, 0xd7, 0x7d, 0x06, 0xed,
3023     0xbb, 0x7a, 0xaf, 0x2f, 0x58, 0x89, 0x18, 0x50, 0xab, 0xbd, 0xca, 0x3d,
3024     0x20, 0x39, 0x8c, 0x27, 0x64, 0x56, 0xcb, 0xc4, 0x21, 0x58, 0x40, 0x7d,
3025     0xd0, 0x74, 0xee
3026 };
3027
3028 static QUIC_PKT_HDR tx_script_2_hdr = {
3029     QUIC_PKT_TYPE_INITIAL,      /* type */
3030     0,                          /* spin bit */
3031     0,                          /* key phase */
3032     2,                          /* PN length */
3033     0,                          /* partial */
3034     0,                          /* fixed */
3035     1,                          /* version */
3036     { 0, {0} },                 /* DCID */
3037     {8, {0xf0, 0x67, 0xa5, 0x50, 0x2a, 0x42, 0x62, 0xb5}}, /* SCID */
3038     { 0 },                      /* PN */
3039     NULL, 0,                    /* Token */
3040     5555, NULL                  /* Len/Data */
3041 };
3042
3043 static const OSSL_QTX_IOVEC tx_script_2_iovec[] = {
3044     { tx_script_2_body, sizeof(tx_script_2_body) }
3045 };
3046
3047 static const OSSL_QTX_PKT tx_script_2_pkt = {
3048     &tx_script_2_hdr,
3049     tx_script_2_iovec,
3050     OSSL_NELEM(tx_script_2_iovec),
3051     NULL, NULL,
3052     1,
3053     0
3054 };
3055
3056 static const struct tx_test_op tx_script_2[] = {
3057     TX_OP_PROVIDE_SECRET_INITIAL(tx_script_1_hdr.dst_conn_id, 1)
3058     TX_OP_WRITE_CHECK(2)
3059     TX_OP_END
3060 };
3061
3062 #ifndef OPENSSL_NO_CHACHA
3063 /* 3. RFC 9001 - A.5 ChaCha20-Poly1305 Short Header Packet */
3064 static const unsigned char tx_script_3_body[] = {
3065     0x01
3066 };
3067
3068 static const unsigned char tx_script_3_dgram[] = {
3069     0x4c, 0xfe, 0x41, 0x89, 0x65, 0x5e, 0x5c, 0xd5, 0x5c, 0x41, 0xf6, 0x90,
3070     0x80, 0x57, 0x5d, 0x79, 0x99, 0xc2, 0x5a, 0x5b, 0xfb
3071 };
3072 static const unsigned char tx_script_3_secret[] = {
3073     0x9a, 0xc3, 0x12, 0xa7, 0xf8, 0x77, 0x46, 0x8e, 0xbe, 0x69, 0x42, 0x27,
3074     0x48, 0xad, 0x00, 0xa1, 0x54, 0x43, 0xf1, 0x82, 0x03, 0xa0, 0x7d, 0x60,
3075     0x60, 0xf6, 0x88, 0xf3, 0x0f, 0x21, 0x63, 0x2b
3076 };
3077
3078 static QUIC_PKT_HDR tx_script_3_hdr = {
3079     QUIC_PKT_TYPE_1RTT,         /* type */
3080     0,                          /* spin bit */
3081     0,                          /* key phase */
3082     3,                          /* PN length */
3083     0,                          /* partial */
3084     0,                          /* fixed */
3085     0,                          /* version */
3086     { 0, {0} },                 /* DCID */
3087     { 0, {0} },                 /* SCID */
3088     { 0 },                      /* PN */
3089     NULL, 0,                    /* Token */
3090     5555, NULL                  /* Len/Data */
3091 };
3092
3093 static const OSSL_QTX_IOVEC tx_script_3_iovec[] = {
3094     { tx_script_3_body, sizeof(tx_script_3_body) }
3095 };
3096
3097 static const OSSL_QTX_PKT tx_script_3_pkt = {
3098     &tx_script_3_hdr,
3099     tx_script_3_iovec,
3100     OSSL_NELEM(tx_script_3_iovec),
3101     NULL, NULL,
3102     654360564,
3103     0
3104 };
3105
3106 static const struct tx_test_op tx_script_3[] = {
3107     TX_OP_PROVIDE_SECRET(QUIC_ENC_LEVEL_1RTT, QRL_SUITE_CHACHA20POLY1305, tx_script_3_secret)
3108     TX_OP_WRITE_CHECK(3)
3109     TX_OP_END
3110 };
3111 #endif /* !defined(OPENSSL_NO_CHACHA) */
3112
3113 /* 4. Real World - AES-128-GCM Key Update */
3114 static const unsigned char tx_script_4_secret[] = {
3115     0x70, 0x82, 0xc0, 0x45, 0x61, 0x4d, 0xfe, 0x04, 0x76, 0xa6, 0x4e, 0xf0,
3116     0x38, 0xe6, 0x63, 0xd9, 0xdd, 0x4a, 0x75, 0x16, 0xa8, 0xa0, 0x06, 0x5a,
3117     0xf2, 0x56, 0xfd, 0x84, 0x78, 0xfd, 0xf6, 0x5e
3118 };
3119
3120 static const unsigned char tx_script_4a_body[] = {
3121     0x02, 0x03, 0x09, 0x00, 0x03, 0x0c, 0x00, 0x36, 0x49, 0x27, 0x6d, 0x20,
3122     0x68, 0x61, 0x76, 0x69, 0x6e, 0x67, 0x20, 0x61, 0x20, 0x77, 0x6f, 0x6e,
3123     0x64, 0x65, 0x72, 0x66, 0x75, 0x6c, 0x20, 0x74, 0x69, 0x6d, 0x65,
3124 };
3125
3126 static const unsigned char tx_script_4a_dgram[] = {
3127     0x47, 0x6e, 0x4e, 0xbd, 0x49, 0x7e, 0xbd, 0x15, 0x1c, 0xd1, 0x3e, 0xc8,
3128     0xcd, 0x43, 0x87, 0x6b, 0x84, 0xdb, 0xeb, 0x06, 0x8b, 0x8a, 0xae, 0x37,
3129     0xed, 0x9c, 0xeb, 0xbc, 0xcf, 0x0d, 0x3c, 0xf0, 0xa1, 0x6f, 0xee, 0xd2,
3130     0x7c, 0x07, 0x6e, 0xd1, 0xbe, 0x40, 0x6a, 0xd4, 0x53, 0x38, 0x9e, 0x63,
3131     0xb5, 0xde, 0x35, 0x09, 0xb2, 0x78, 0x94, 0xe4, 0x2b, 0x37
3132 };
3133
3134 static QUIC_PKT_HDR tx_script_4a_hdr = {
3135     QUIC_PKT_TYPE_1RTT,         /* type */
3136     0,                          /* spin bit */
3137     0,                          /* key phase */
3138     2,                          /* PN length */
3139     0,                          /* partial */
3140     0,                          /* fixed */
3141     0,                          /* version */
3142     { 4, {0x6e, 0x4e, 0xbd, 0x49} }, /* DCID */
3143     { 0, {0} },                 /* SCID */
3144     { 0 },                      /* PN */
3145     NULL, 0,                    /* Token */
3146     5555, NULL                  /* Len/Data */
3147 };
3148
3149 static const OSSL_QTX_IOVEC tx_script_4a_iovec[] = {
3150     { tx_script_4a_body, sizeof(tx_script_4a_body) }
3151 };
3152
3153 static const OSSL_QTX_PKT tx_script_4a_pkt = {
3154     &tx_script_4a_hdr,
3155     tx_script_4a_iovec,
3156     OSSL_NELEM(tx_script_4a_iovec),
3157     NULL, NULL,
3158     4,
3159     0
3160 };
3161
3162 static const unsigned char tx_script_4b_body[] = {
3163     0x02, 0x04, 0x07, 0x00, 0x00, 0x0c, 0x00, 0x40, 0x51, 0x49, 0x27, 0x6d,
3164     0x20, 0x68, 0x61, 0x76, 0x69, 0x6e, 0x67, 0x20, 0x61, 0x20, 0x77, 0x6f,
3165     0x6e, 0x64, 0x65, 0x72, 0x66, 0x75, 0x6c, 0x20, 0x74, 0x69, 0x6d, 0x65,
3166 };
3167
3168 static const unsigned char tx_script_4b_dgram[] = {
3169     0x58, 0x6e, 0x4e, 0xbd, 0x49, 0xa4, 0x43, 0x33, 0xea, 0x11, 0x3a, 0x6c,
3170     0xf5, 0x20, 0xef, 0x55, 0x8d, 0x25, 0xe2, 0x3b, 0x0e, 0x8c, 0xea, 0x17,
3171     0xfc, 0x2b, 0x7a, 0xab, 0xfa, 0x3d, 0x07, 0xda, 0xa7, 0x7c, 0xc7, 0x47,
3172     0x82, 0x02, 0x46, 0x40, 0x4f, 0x01, 0xad, 0xb2, 0x9d, 0x97, 0xdb, 0xfc,
3173     0x9c, 0x4b, 0x46, 0xb1, 0x5a, 0x7f, 0x0b, 0x12, 0xaf, 0x49, 0xdf,
3174 };
3175
3176 static QUIC_PKT_HDR tx_script_4b_hdr = {
3177     QUIC_PKT_TYPE_1RTT,         /* type */
3178     0,                          /* spin bit */
3179     1,                          /* key phase */
3180     2,                          /* PN length */
3181     0,                          /* partial */
3182     0,                          /* fixed */
3183     0,                          /* version */
3184     { 4, {0x6e, 0x4e, 0xbd, 0x49} }, /* DCID */
3185     { 0, {0} },                 /* SCID */
3186     { 0 },                      /* PN */
3187     NULL, 0,                    /* Token */
3188     5555, NULL                  /* Len/Data */
3189 };
3190
3191 static const OSSL_QTX_IOVEC tx_script_4b_iovec[] = {
3192     { tx_script_4b_body, sizeof(tx_script_4b_body) }
3193 };
3194
3195 static const OSSL_QTX_PKT tx_script_4b_pkt = {
3196     &tx_script_4b_hdr,
3197     tx_script_4b_iovec,
3198     OSSL_NELEM(tx_script_4b_iovec),
3199     NULL, NULL,
3200     5,
3201     0
3202 };
3203
3204 static const unsigned char tx_script_4c_body[] = {
3205     0x02, 0x09, 0x0e, 0x00, 0x00, 0x0c, 0x00, 0x40, 0xd8, 0x49, 0x27, 0x6d,
3206     0x20, 0x68, 0x61, 0x76, 0x69, 0x6e, 0x67, 0x20, 0x61, 0x20, 0x77, 0x6f,
3207     0x6e, 0x64, 0x65, 0x72, 0x66, 0x75, 0x6c, 0x20, 0x74, 0x69, 0x6d, 0x65,
3208 };
3209
3210 static const unsigned char tx_script_4c_dgram[] = {
3211     0x49, 0x6e, 0x4e, 0xbd, 0x49, 0x4d, 0xd9, 0x85, 0xba, 0x26, 0xfb, 0x68,
3212     0x83, 0x9b, 0x94, 0x34, 0x7d, 0xc1, 0x7a, 0x05, 0xb7, 0x38, 0x43, 0x21,
3213     0xe2, 0xec, 0x2b, 0xc1, 0x81, 0x74, 0x2d, 0xda, 0x24, 0xba, 0xbd, 0x99,
3214     0x69, 0xd2, 0x56, 0xfa, 0xae, 0x29, 0x24, 0xb2, 0xaa, 0xda, 0xbd, 0x82,
3215     0x80, 0xf1, 0xbb, 0x6a, 0xfd, 0xae, 0xda, 0x0e, 0x09, 0xcf, 0x09,
3216 };
3217
3218 static QUIC_PKT_HDR tx_script_4c_hdr = {
3219     QUIC_PKT_TYPE_1RTT,         /* type */
3220     0,                          /* spin bit */
3221     0,                          /* key phase */
3222     2,                          /* PN length */
3223     0,                          /* partial */
3224     0,                          /* fixed */
3225     0,                          /* version */
3226     { 4, {0x6e, 0x4e, 0xbd, 0x49} }, /* DCID */
3227     { 0, {0} },                 /* SCID */
3228     { 0 },                      /* PN */
3229     NULL, 0,                    /* Token */
3230     5555, NULL                  /* Len/Data */
3231 };
3232
3233 static const OSSL_QTX_IOVEC tx_script_4c_iovec[] = {
3234     { tx_script_4c_body, sizeof(tx_script_4c_body) }
3235 };
3236
3237 static const OSSL_QTX_PKT tx_script_4c_pkt = {
3238     &tx_script_4c_hdr,
3239     tx_script_4c_iovec,
3240     OSSL_NELEM(tx_script_4c_iovec),
3241     NULL, NULL,
3242     10,
3243     0
3244 };
3245
3246 static const struct tx_test_op tx_script_4[] = {
3247     TX_OP_PROVIDE_SECRET(QUIC_ENC_LEVEL_1RTT, QRL_SUITE_AES128GCM, tx_script_4_secret)
3248     TX_OP_WRITE_CHECK(4a)
3249     TX_OP_KEY_UPDATE()
3250     TX_OP_WRITE_CHECK(4b)
3251     TX_OP_KEY_UPDATE()
3252     TX_OP_WRITE_CHECK(4c)
3253     TX_OP_END
3254 };
3255
3256 /* 5. Real World - Retry Packet */
3257 static const unsigned char tx_script_5_body[] = {
3258     /* Retry Token */
3259     0x92, 0xe7, 0xc6, 0xd8, 0x09, 0x65, 0x72, 0x55, 0xe5, 0xe2, 0x73, 0x04,
3260     0xf3, 0x07, 0x5b, 0x21, 0x9f, 0x50, 0xcb, 0xbc, 0x79, 0xc5, 0x77, 0x5a,
3261     0x29, 0x43, 0x65, 0x49, 0xf0, 0x6e, 0xc1, 0xc0, 0x3a, 0xe8, 0xca, 0xd2,
3262     0x44, 0x69, 0xdd, 0x23, 0x31, 0x93, 0x52, 0x02, 0xf7, 0x42, 0x07, 0x78,
3263     0xa1, 0x81, 0x61, 0x9c, 0x39, 0x07, 0x18, 0x69, 0x6e, 0x4f, 0xdc, 0xa0,
3264     0xbe, 0x4b, 0xe5, 0xf2, 0xe9, 0xd2, 0xa4, 0xa7, 0x34, 0x55, 0x5e, 0xf3,
3265     0xf8, 0x9c, 0x49, 0x8f, 0x0c, 0xc8, 0xb2, 0x75, 0x4b, 0x4d, 0x2f, 0xfe,
3266     0x05, 0x5a, 0xdd, 0x4b, 0xe6, 0x14, 0xb4, 0xd2, 0xc0, 0x93, 0x6e, 0x0e,
3267     0x84, 0x41, 0x4d, 0x31,
3268     /* Retry Integrity Tag */
3269     0x43, 0x8e, 0xab, 0xcd, 0xce, 0x24, 0x44, 0xc2, 0x20, 0xe1, 0xe2, 0xc8,
3270     0xae, 0xa3, 0x8d, 0x4e,
3271 };
3272
3273 static const unsigned char tx_script_5_dgram[] = {
3274     0xf0, 0x00, 0x00, 0x00, 0x01, 0x00, 0x04, 0xa9, 0x20, 0xcc, 0xc2, 0x92,
3275     0xe7, 0xc6, 0xd8, 0x09, 0x65, 0x72, 0x55, 0xe5, 0xe2, 0x73, 0x04, 0xf3,
3276     0x07, 0x5b, 0x21, 0x9f, 0x50, 0xcb, 0xbc, 0x79, 0xc5, 0x77, 0x5a, 0x29,
3277     0x43, 0x65, 0x49, 0xf0, 0x6e, 0xc1, 0xc0, 0x3a, 0xe8, 0xca, 0xd2, 0x44,
3278     0x69, 0xdd, 0x23, 0x31, 0x93, 0x52, 0x02, 0xf7, 0x42, 0x07, 0x78, 0xa1,
3279     0x81, 0x61, 0x9c, 0x39, 0x07, 0x18, 0x69, 0x6e, 0x4f, 0xdc, 0xa0, 0xbe,
3280     0x4b, 0xe5, 0xf2, 0xe9, 0xd2, 0xa4, 0xa7, 0x34, 0x55, 0x5e, 0xf3, 0xf8,
3281     0x9c, 0x49, 0x8f, 0x0c, 0xc8, 0xb2, 0x75, 0x4b, 0x4d, 0x2f, 0xfe, 0x05,
3282     0x5a, 0xdd, 0x4b, 0xe6, 0x14, 0xb4, 0xd2, 0xc0, 0x93, 0x6e, 0x0e, 0x84,
3283     0x41, 0x4d, 0x31, 0x43, 0x8e, 0xab, 0xcd, 0xce, 0x24, 0x44, 0xc2, 0x20,
3284     0xe1, 0xe2, 0xc8, 0xae, 0xa3, 0x8d, 0x4e,
3285 };
3286
3287 static QUIC_PKT_HDR tx_script_5_hdr = {
3288     QUIC_PKT_TYPE_RETRY,        /* type */
3289     0,                          /* spin bit */
3290     0,                          /* key phase */
3291     0,                          /* PN length */
3292     0,                          /* partial */
3293     0,                          /* fixed */
3294     1,                          /* version */
3295     { 0, {0} },                 /* DCID */
3296     { 4, {0xa9, 0x20, 0xcc, 0xc2} },   /* SCID */
3297     { 0 },                      /* PN */
3298     NULL, 0,                    /* Token */
3299     5555, NULL                  /* Len/Data */
3300 };
3301
3302 static const OSSL_QTX_IOVEC tx_script_5_iovec[] = {
3303     { tx_script_5_body, sizeof(tx_script_5_body) }
3304 };
3305
3306 static const OSSL_QTX_PKT tx_script_5_pkt = {
3307     &tx_script_5_hdr,
3308     tx_script_5_iovec,
3309     OSSL_NELEM(tx_script_5_iovec),
3310     NULL, NULL,
3311     0,
3312     0
3313 };
3314
3315 static const struct tx_test_op tx_script_5[] = {
3316     TX_OP_WRITE_CHECK(5)
3317     TX_OP_END
3318 };
3319
3320 /* 6. Real World - Version Negotiation Packet */
3321 static const unsigned char tx_script_6_body[] = {
3322     0x00, 0x00, 0x00, 0x01,             /* Supported Version: 1 */
3323     0xaa, 0x9a, 0x3a, 0x9a              /* Supported Version: Random (GREASE) */
3324 };
3325
3326 static const unsigned char tx_script_6_dgram[] = {
3327     0x80,                               /* Long */
3328     0x00, 0x00, 0x00, 0x00,             /* Version 0 (Version Negotiation) */
3329     0x00,                               /* DCID */
3330     0x0c, 0x35, 0x3c, 0x1b, 0x97, 0xca, /* SCID */
3331     0xf8, 0x99, 0x11, 0x39, 0xad, 0x79,
3332     0x1f,
3333     0x00, 0x00, 0x00, 0x01,             /* Supported Version: 1 */
3334     0xaa, 0x9a, 0x3a, 0x9a              /* Supported Version: Random (GREASE) */
3335 };
3336
3337 static QUIC_PKT_HDR tx_script_6_hdr = {
3338     QUIC_PKT_TYPE_VERSION_NEG,  /* type */
3339     0,                          /* spin bit */
3340     0,                          /* key phase */
3341     0,                          /* PN length */
3342     0,                          /* partial */
3343     0,                          /* fixed */
3344     0,                          /* version */
3345     { 0, {0} },                 /* DCID */
3346     { 12, {0x35, 0x3c, 0x1b, 0x97, 0xca, 0xf8, 0x99,
3347            0x11, 0x39, 0xad, 0x79, 0x1f} }, /* SCID */
3348     { 0 },                      /* PN */
3349     NULL, 0,                    /* Token */
3350     5555, NULL                  /* Len/Data */
3351 };
3352
3353 static const OSSL_QTX_IOVEC tx_script_6_iovec[] = {
3354     { tx_script_6_body, sizeof(tx_script_6_body) }
3355 };
3356
3357 static const OSSL_QTX_PKT tx_script_6_pkt = {
3358     &tx_script_6_hdr,
3359     tx_script_6_iovec,
3360     OSSL_NELEM(tx_script_6_iovec),
3361     NULL, NULL,
3362     0,
3363     0
3364 };
3365
3366 static const struct tx_test_op tx_script_6[] = {
3367     TX_OP_WRITE_CHECK(6)
3368     TX_OP_END
3369 };
3370
3371 static const struct tx_test_op *const tx_scripts[] = {
3372     tx_script_1,
3373     tx_script_2,
3374 #ifndef OPENSSL_NO_CHACHA
3375     tx_script_3,
3376 #endif
3377     tx_script_4,
3378     tx_script_5,
3379     tx_script_6
3380 };
3381
3382 static int tx_run_script(const struct tx_test_op *script)
3383 {
3384     int testresult = 0;
3385     const struct tx_test_op *op = script;
3386     OSSL_QTX *qtx = NULL;
3387     BIO_MSG msg = {0};
3388     OSSL_QTX_ARGS args = {0};
3389
3390     args.mdpl = 1472;
3391
3392     if (!TEST_ptr(qtx = ossl_qtx_new(&args)))
3393         goto err;
3394
3395     for (; op->op != TX_TEST_OP_END; ++op)
3396         switch (op->op) {
3397             case TX_TEST_OP_PROVIDE_SECRET:
3398                 if (!TEST_true(ossl_qtx_provide_secret(qtx, op->enc_level,
3399                                                        op->suite_id, NULL,
3400                                                        op->buf, op->buf_len)))
3401                     goto err;
3402                 break;
3403             case TX_TEST_OP_PROVIDE_SECRET_INITIAL:
3404                 if (!TEST_true(ossl_quic_provide_initial_secret(NULL, NULL,
3405                                                                 op->dcid,
3406                                                                 (int)op->suite_id,
3407                                                                 NULL, qtx)))
3408                     goto err;
3409                 break;
3410             case TX_TEST_OP_DISCARD_EL:
3411                 if (!TEST_true(ossl_qtx_discard_enc_level(qtx, op->enc_level)))
3412                     goto err;
3413                 break;
3414             case TX_TEST_OP_WRITE:
3415                 {
3416                     uint32_t enc_level
3417                         = ossl_quic_pkt_type_to_enc_level(op->pkt->hdr->type);
3418                     uint64_t old_value = 0, new_value, max_value;
3419
3420                     if (enc_level < QUIC_ENC_LEVEL_NUM) { /* encrypted packet */
3421                         max_value = ossl_qtx_get_max_epoch_pkt_count(qtx, enc_level);
3422
3423                         if (!TEST_uint64_t_lt(max_value, UINT64_MAX))
3424                             goto err;
3425
3426                         old_value = ossl_qtx_get_cur_epoch_pkt_count(qtx, enc_level);
3427                         if (!TEST_uint64_t_lt(old_value, UINT64_MAX))
3428                             goto err;
3429                     }
3430
3431                     if (!TEST_true(ossl_qtx_write_pkt(qtx, op->pkt)))
3432                         goto err;
3433
3434                     if (enc_level < QUIC_ENC_LEVEL_NUM) {
3435                         new_value = ossl_qtx_get_cur_epoch_pkt_count(qtx, enc_level);
3436                         if (!TEST_uint64_t_eq(old_value + 1, new_value))
3437                             goto err;
3438                     }
3439                 }
3440                 break;
3441             case TX_TEST_OP_CHECK_DGRAM:
3442                 if (!TEST_true(ossl_qtx_pop_net(qtx, &msg)))
3443                     goto err;
3444
3445                 if (!TEST_mem_eq(msg.data, msg.data_len, op->buf, op->buf_len))
3446                     goto err;
3447
3448                 break;
3449             case TX_TEST_OP_CHECK_NO_DGRAM:
3450                 if (!TEST_false(ossl_qtx_pop_net(qtx, &msg)))
3451                     goto err;
3452                 break;
3453             case TX_TEST_OP_KEY_UPDATE:
3454                 if (!TEST_true(ossl_qtx_trigger_key_update(qtx)))
3455                     goto err;
3456                 break;
3457             default:
3458                 OPENSSL_assert(0);
3459                 goto err;
3460         }
3461
3462     testresult = 1;
3463 err:
3464     if (qtx != NULL)
3465         ossl_qtx_free(qtx);
3466
3467     return testresult;
3468 }
3469
3470 static int test_tx_script(int idx)
3471 {
3472     return tx_run_script(tx_scripts[idx]);
3473 }
3474
3475 int setup_tests(void)
3476 {
3477     ADD_ALL_TESTS(test_rx_script, OSSL_NELEM(rx_scripts));
3478     /*
3479      * Each instance of this test is executed multiple times to get enough
3480      * statistical coverage for our statistical test, as well as for each
3481      * supported key type.
3482      *
3483      * We call the statistical test as the last index in the wire_pkt_hdr
3484      * test rather than as a separate case, as it needs to execute last
3485      * and otherwise random test ordering will cause itt to randomly fail.
3486      */
3487     ADD_ALL_TESTS(test_wire_pkt_hdr, NUM_WIRE_PKT_HDR_TESTS + 1);
3488     ADD_ALL_TESTS(test_tx_script, OSSL_NELEM(tx_scripts));
3489     return 1;
3490 }