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