test/quic_wire_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/packet.h"
  11 #include "internal/quic_wire.h"
  12 #include "internal/quic_wire_pkt.h"
  13 #include "testutil.h"
  14
  15 struct encode_test_case {
  16     int (*serializer)(WPACKET *pkt);
  17     const unsigned char *expect_buf;
  18     size_t expect_buf_len;
  19     /*
  20      * fail: -1 if not truncated (function should test for success), else number
  21      * of bytes to which the input has been truncated (function should test that
  22      * decoding fails)
  23      */
  24     int (*deserializer)(PACKET *pkt, ossl_ssize_t fail);
  25 };
  26
  27 /* 1. PADDING */
  28 static int encode_case_1_enc(WPACKET *pkt)
  29 {
  30     if (!TEST_int_eq(ossl_quic_wire_encode_padding(pkt, 3), 1))
  31         return 0;
  32
  33     return 1;
  34 }
  35
  36 static int encode_case_1_dec(PACKET *pkt, ossl_ssize_t fail)
  37 {
  38     if (fail >= 0)
  39         /* No failure modes for padding */
  40         return 1;
  41
  42     if (!TEST_int_eq(ossl_quic_wire_decode_padding(pkt), 3))
  43         return 0;
  44
  45     return 1;
  46 }
  47
  48 static const unsigned char encode_case_1_expect[] = {
  49     0, 0, 0
  50 };
  51
  52 /* 2. PING */
  53 static int encode_case_2_enc(WPACKET *pkt)
  54 {
  55
  56     if (!TEST_int_eq(ossl_quic_wire_encode_frame_ping(pkt), 1))
  57         return 0;
  58
  59     return 1;
  60 }
  61
  62 static int encode_case_2_dec(PACKET *pkt, ossl_ssize_t fail)
  63 {
  64
  65     if (!TEST_int_eq(ossl_quic_wire_decode_frame_ping(pkt), fail < 0))
  66         return 0;
  67
  68     return 1;
  69 }
  70
  71 static const unsigned char encode_case_2_expect[] = {
  72     0x01
  73 };
  74
  75 /* 3. ACK */
  76 static const OSSL_QUIC_ACK_RANGE encode_case_3_ranges[] = {
  77     { 20, 30 },
  78     {  0, 10 }
  79 };
  80
  81 static const OSSL_QUIC_FRAME_ACK encode_case_3_f = {
  82     (OSSL_QUIC_ACK_RANGE *)encode_case_3_ranges,
  83     OSSL_NELEM(encode_case_3_ranges),
  84     { OSSL_TIME_MS },
  85     60, 70, 80, 1
  86 };
  87
  88 static int encode_case_3_enc(WPACKET *pkt)
  89 {
  90     if (!TEST_int_eq(ossl_quic_wire_encode_frame_ack(pkt, 3, &encode_case_3_f), 1))
  91         return 0;
  92
  93     return 1;
  94 }
  95
  96 static int encode_case_3_dec(PACKET *pkt, ossl_ssize_t fail)
  97 {
  98     OSSL_QUIC_ACK_RANGE ranges[4] = {0};
  99     OSSL_QUIC_FRAME_ACK f = {0};
 100     uint64_t total_ranges = 0, peek_total_ranges = 0;
 101     int ret;
 102
 103     f.ack_ranges        = ranges;
 104     f.num_ack_ranges    = OSSL_NELEM(ranges);
 105
 106     ret = ossl_quic_wire_peek_frame_ack_num_ranges(pkt, &peek_total_ranges);
 107     if (fail < 0 && !TEST_int_eq(ret, 1))
 108         return 0;
 109
 110     if (!TEST_int_eq(ossl_quic_wire_decode_frame_ack(pkt, 3, &f, &total_ranges), fail < 0))
 111         return 0;
 112
 113     if (ret == 1 && !TEST_uint64_t_eq(peek_total_ranges, 2))
 114         return 0;
 115
 116     if (fail >= 0)
 117         return 1;
 118
 119     if (!TEST_uint64_t_eq(total_ranges, peek_total_ranges))
 120         return 0;
 121
 122     if (!TEST_uint64_t_le(f.num_ack_ranges * sizeof(OSSL_QUIC_ACK_RANGE),
 123                           SIZE_MAX)
 124         || !TEST_uint64_t_le(encode_case_3_f.num_ack_ranges
 125                              * sizeof(OSSL_QUIC_ACK_RANGE),
 126                              SIZE_MAX))
 127         return 0;
 128
 129     if (!TEST_mem_eq(f.ack_ranges,
 130                      (size_t)f.num_ack_ranges * sizeof(OSSL_QUIC_ACK_RANGE),
 131                      encode_case_3_f.ack_ranges,
 132                      (size_t)encode_case_3_f.num_ack_ranges * sizeof(OSSL_QUIC_ACK_RANGE)))
 133         return 0;
 134
 135     if (!TEST_uint64_t_eq(ossl_time2ticks(f.delay_time),
 136                           ossl_time2ticks(encode_case_3_f.delay_time)))
 137         return 0;
 138
 139     if (!TEST_true(f.ecn_present))
 140         return 0;
 141
 142     if (!TEST_uint64_t_eq(f.ect0, encode_case_3_f.ect0))
 143         return 0;
 144
 145     if (!TEST_uint64_t_eq(f.ect1, encode_case_3_f.ect1))
 146         return 0;
 147
 148     if (!TEST_uint64_t_eq(f.ecnce, encode_case_3_f.ecnce))
 149         return 0;
 150
 151     return 1;
 152 }
 153
 154 static const unsigned char encode_case_3_expect[] = {
 155     0x03,                   /* Type */
 156     0x1E,                   /* Largest Acknowledged */
 157     0x40, 0x7d,             /* ACK Delay */
 158     1,                      /* ACK Range Count */
 159     10,                     /* First ACK Range */
 160
 161     8,                      /* Gap */
 162     10,                     /* Length */
 163
 164     0x3c,                   /* ECT0 Count */
 165     0x40, 0x46,             /* ECT1 Count */
 166     0x40, 0x50,             /* ECNCE Count */
 167 };
 168
 169 /* 4. RESET_STREAM */
 170 static const OSSL_QUIC_FRAME_RESET_STREAM encode_case_4_f = {
 171     0x1234, 0x9781, 0x11717
 172 };
 173
 174 static int encode_case_4_enc(WPACKET *pkt)
 175 {
 176     if (!TEST_int_eq(ossl_quic_wire_encode_frame_reset_stream(pkt,
 177                                                               &encode_case_4_f), 1))
 178         return 0;
 179
 180     return 1;
 181 }
 182
 183 static int encode_case_4_dec(PACKET *pkt, ossl_ssize_t fail)
 184 {
 185     OSSL_QUIC_FRAME_RESET_STREAM f = {0};
 186
 187     if (!TEST_int_eq(ossl_quic_wire_decode_frame_reset_stream(pkt, &f), fail < 0))
 188         return 0;
 189
 190     if (fail >= 0)
 191         return 1;
 192
 193     if (!TEST_mem_eq(&f, sizeof(f), &encode_case_4_f, sizeof(encode_case_4_f)))
 194         return 0;
 195
 196     return 1;
 197 }
 198
 199 static const unsigned char encode_case_4_expect[] = {
 200     0x04,                   /* Type */
 201     0x52, 0x34,             /* Stream ID */
 202     0x80, 0x00, 0x97, 0x81, /* App Error Code */
 203     0x80, 0x01, 0x17, 0x17, /* Final Size */
 204 };
 205
 206 /* 5. STOP_SENDING */
 207 static const OSSL_QUIC_FRAME_STOP_SENDING encode_case_5_f = {
 208     0x1234, 0x9781
 209 };
 210
 211 static int encode_case_5_enc(WPACKET *pkt)
 212 {
 213     if (!TEST_int_eq(ossl_quic_wire_encode_frame_stop_sending(pkt,
 214                                                               &encode_case_5_f), 1))
 215         return 0;
 216
 217     return 1;
 218 }
 219
 220 static int encode_case_5_dec(PACKET *pkt, ossl_ssize_t fail)
 221 {
 222     OSSL_QUIC_FRAME_STOP_SENDING f = {0};
 223
 224     if (!TEST_int_eq(ossl_quic_wire_decode_frame_stop_sending(pkt, &f), fail < 0))
 225         return 0;
 226
 227     if (fail >= 0)
 228         return 1;
 229
 230     if (!TEST_mem_eq(&f, sizeof(f), &encode_case_5_f, sizeof(encode_case_5_f)))
 231         return 0;
 232
 233     return 1;
 234 }
 235
 236 static const unsigned char encode_case_5_expect[] = {
 237     0x05,                   /* Type */
 238     0x52, 0x34,             /* Stream ID */
 239     0x80, 0x00, 0x97, 0x81  /* App Error Code */
 240 };
 241
 242 /* 6. CRYPTO */
 243 static const unsigned char encode_case_6_data[] = {
 244     93, 18, 17, 102, 33
 245 };
 246
 247 static const OSSL_QUIC_FRAME_CRYPTO encode_case_6_f = {
 248     0x1234, sizeof(encode_case_6_data), encode_case_6_data
 249 };
 250
 251 static int encode_case_6_enc(WPACKET *pkt)
 252 {
 253     if (!TEST_ptr(ossl_quic_wire_encode_frame_crypto(pkt,
 254                                                      &encode_case_6_f)))
 255         return 0;
 256
 257     return 1;
 258 }
 259
 260 static int encode_case_6_dec(PACKET *pkt, ossl_ssize_t fail)
 261 {
 262     OSSL_QUIC_FRAME_CRYPTO f = {0};
 263
 264     if (!TEST_int_eq(ossl_quic_wire_decode_frame_crypto(pkt, &f), fail < 0))
 265         return 0;
 266
 267     if (fail >= 0)
 268         return 1;
 269
 270     if (!TEST_uint64_t_eq(f.offset, 0x1234))
 271         return 0;
 272
 273     if (!TEST_uint64_t_le(f.len, SIZE_MAX))
 274         return 0;
 275
 276     if (!TEST_mem_eq(f.data, (size_t)f.len,
 277                      encode_case_6_data, sizeof(encode_case_6_data)))
 278         return 0;
 279
 280     return 1;
 281 }
 282
 283 static const unsigned char encode_case_6_expect[] = {
 284     0x06,                   /* Type */
 285     0x52, 0x34,             /* Offset */
 286     0x05,                   /* Length */
 287     93, 18, 17, 102, 33     /* Data */
 288 };
 289
 290 /* 7. NEW_TOKEN */
 291 static const unsigned char encode_case_7_token[] = {
 292     0xde, 0x06, 0xcb, 0x76, 0x5d, 0xb1, 0xa7, 0x71,
 293     0x78, 0x09, 0xbb, 0xe8, 0x50, 0x19, 0x12, 0x9a
 294 };
 295
 296 static int encode_case_7_enc(WPACKET *pkt)
 297 {
 298     if (!TEST_int_eq(ossl_quic_wire_encode_frame_new_token(pkt,
 299                                                         encode_case_7_token,
 300                                                         sizeof(encode_case_7_token)), 1))
 301         return 0;
 302
 303     return 1;
 304 }
 305
 306 static int encode_case_7_dec(PACKET *pkt, ossl_ssize_t fail)
 307 {
 308     const unsigned char *token = NULL;
 309     size_t token_len = 0;
 310
 311     if (!TEST_int_eq(ossl_quic_wire_decode_frame_new_token(pkt,
 312                                                            &token,
 313                                                            &token_len), fail < 0))
 314         return 0;
 315
 316     if (fail >= 0)
 317         return 1;
 318
 319     if (!TEST_mem_eq(token, token_len,
 320                      encode_case_7_token, sizeof(encode_case_7_token)))
 321         return 0;
 322
 323     return 1;
 324 }
 325
 326 static const unsigned char encode_case_7_expect[] = {
 327     0x07,                   /* Type */
 328     0x10,                   /* Length */
 329     0xde, 0x06, 0xcb, 0x76, 0x5d, 0xb1, 0xa7, 0x71, /* Token */
 330     0x78, 0x09, 0xbb, 0xe8, 0x50, 0x19, 0x12, 0x9a
 331 };
 332
 333 /* 8. STREAM (no length, no offset, no fin) */
 334 static const unsigned char encode_case_8_data[] = {
 335     0xde, 0x06, 0xcb, 0x76, 0x5d
 336 };
 337 static const OSSL_QUIC_FRAME_STREAM encode_case_8_f = {
 338    0x1234, 0, 5, encode_case_8_data, 0, 0
 339 };
 340
 341 static int encode_case_8_enc(WPACKET *pkt)
 342 {
 343     if (!TEST_ptr(ossl_quic_wire_encode_frame_stream(pkt,
 344                                                      &encode_case_8_f)))
 345         return 0;
 346
 347     return 1;
 348 }
 349
 350 static int encode_case_8_dec(PACKET *pkt, ossl_ssize_t fail)
 351 {
 352     OSSL_QUIC_FRAME_STREAM f = {0};
 353
 354     if (fail >= 3)
 355         /*
 356          * This case uses implicit length signalling so truncation will not
 357          * cause it to fail unless the header (which is 3 bytes) is truncated.
 358          */
 359         return 1;
 360
 361     if (!TEST_int_eq(ossl_quic_wire_decode_frame_stream(pkt, &f), fail < 0))
 362         return 0;
 363
 364     if (fail >= 0)
 365         return 1;
 366
 367     if (!TEST_uint64_t_le(f.len, SIZE_MAX))
 368         return 0;
 369
 370     if (!TEST_mem_eq(f.data, (size_t)f.len,
 371                      encode_case_8_data, sizeof(encode_case_8_data)))
 372         return 0;
 373
 374     if (!TEST_uint64_t_eq(f.stream_id, 0x1234))
 375         return 0;
 376
 377     if (!TEST_uint64_t_eq(f.offset, 0))
 378         return 0;
 379
 380     if (!TEST_int_eq(f.has_explicit_len, 0))
 381         return 0;
 382
 383     if (!TEST_int_eq(f.is_fin, 0))
 384         return 0;
 385
 386     return 1;
 387 }
 388
 389 static const unsigned char encode_case_8_expect[] = {
 390     0x08,                           /* Type (OFF=0, LEN=0, FIN=0) */
 391     0x52, 0x34,                     /* Stream ID */
 392     0xde, 0x06, 0xcb, 0x76, 0x5d    /* Data */
 393 };
 394
 395 /* 9. STREAM (length, offset, fin) */
 396 static const unsigned char encode_case_9_data[] = {
 397     0xde, 0x06, 0xcb, 0x76, 0x5d
 398 };
 399 static const OSSL_QUIC_FRAME_STREAM encode_case_9_f = {
 400    0x1234, 0x39, 5, encode_case_9_data, 1, 1
 401 };
 402
 403 static int encode_case_9_enc(WPACKET *pkt)
 404 {
 405     if (!TEST_ptr(ossl_quic_wire_encode_frame_stream(pkt,
 406                                                      &encode_case_9_f)))
 407         return 0;
 408
 409     return 1;
 410 }
 411
 412 static int encode_case_9_dec(PACKET *pkt, ossl_ssize_t fail)
 413 {
 414     OSSL_QUIC_FRAME_STREAM f = {0};
 415
 416     if (!TEST_int_eq(ossl_quic_wire_decode_frame_stream(pkt, &f), fail < 0))
 417         return 0;
 418
 419     if (fail >= 0)
 420         return 1;
 421
 422     if (!TEST_uint64_t_le(f.len, SIZE_MAX))
 423         return 0;
 424
 425     if (!TEST_mem_eq(f.data, (size_t)f.len,
 426                      encode_case_9_data, sizeof(encode_case_9_data)))
 427         return 0;
 428
 429     if (!TEST_uint64_t_eq(f.stream_id, 0x1234))
 430         return 0;
 431
 432     if (!TEST_uint64_t_eq(f.offset, 0x39))
 433         return 0;
 434
 435     if (!TEST_int_eq(f.has_explicit_len, 1))
 436         return 0;
 437
 438     if (!TEST_int_eq(f.is_fin, 1))
 439         return 0;
 440
 441     return 1;
 442 }
 443
 444 static const unsigned char encode_case_9_expect[] = {
 445     0x0f,                           /* Type (OFF=1, LEN=1, FIN=1) */
 446     0x52, 0x34,                     /* Stream ID */
 447     0x39,                           /* Offset */
 448     0x05,                           /* Length */
 449     0xde, 0x06, 0xcb, 0x76, 0x5d    /* Data */
 450 };
 451
 452 /* 10. MAX_DATA */
 453 static int encode_case_10_enc(WPACKET *pkt)
 454 {
 455     if (!TEST_int_eq(ossl_quic_wire_encode_frame_max_data(pkt, 0x1234), 1))
 456         return 0;
 457
 458     return 1;
 459 }
 460
 461 static int encode_case_10_dec(PACKET *pkt, ossl_ssize_t fail)
 462 {
 463     uint64_t max_data = 0;
 464
 465     if (!TEST_int_eq(ossl_quic_wire_decode_frame_max_data(pkt, &max_data), fail < 0))
 466         return 0;
 467
 468     if (fail >= 0)
 469         return 1;
 470
 471     if (!TEST_uint64_t_eq(max_data, 0x1234))
 472         return 0;
 473
 474     return 1;
 475 }
 476
 477 static const unsigned char encode_case_10_expect[] = {
 478     0x10,                           /* Type */
 479     0x52, 0x34,                     /* Max Data */
 480 };
 481
 482 /* 11. MAX_STREAM_DATA */
 483 static int encode_case_11_enc(WPACKET *pkt)
 484 {
 485     if (!TEST_int_eq(ossl_quic_wire_encode_frame_max_stream_data(pkt,
 486                                                                  0x1234,
 487                                                                  0x9781), 1))
 488         return 0;
 489
 490     return 1;
 491 }
 492
 493 static int encode_case_11_dec(PACKET *pkt, ossl_ssize_t fail)
 494 {
 495     uint64_t stream_id = 0, max_data = 0;
 496
 497     if (!TEST_int_eq(ossl_quic_wire_decode_frame_max_stream_data(pkt,
 498                                                                  &stream_id,
 499                                                                  &max_data), fail < 0))
 500         return 0;
 501
 502     if (fail >= 0)
 503         return 1;
 504
 505     if (!TEST_uint64_t_eq(stream_id, 0x1234))
 506         return 0;
 507
 508     if (!TEST_uint64_t_eq(max_data, 0x9781))
 509         return 0;
 510
 511     return 1;
 512 }
 513
 514 static const unsigned char encode_case_11_expect[] = {
 515     0x11,                           /* Type */
 516     0x52, 0x34,                     /* Stream ID */
 517     0x80, 0x00, 0x97, 0x81,         /* Max Data */
 518 };
 519
 520 /* 12. MAX_STREAMS */
 521 static int encode_case_12_enc(WPACKET *pkt)
 522 {
 523     if (!TEST_int_eq(ossl_quic_wire_encode_frame_max_streams(pkt, 0, 0x1234), 1))
 524         return 0;
 525
 526     if (!TEST_int_eq(ossl_quic_wire_encode_frame_max_streams(pkt, 1, 0x9781), 1))
 527         return 0;
 528
 529     return 1;
 530 }
 531
 532 static int encode_case_12_dec(PACKET *pkt, ossl_ssize_t fail)
 533 {
 534     uint64_t max_streams_1 = 0, max_streams_2 = 0,
 535             frame_type_1 = 0, frame_type_2 = 0;
 536
 537     if (!TEST_int_eq(ossl_quic_wire_peek_frame_header(pkt, &frame_type_1),
 538                      fail < 0 || fail >= 1))
 539         return 0;
 540
 541     if (!TEST_int_eq(ossl_quic_wire_decode_frame_max_streams(pkt,
 542                                                              &max_streams_1),
 543                      fail < 0 || fail >= 3))
 544         return 0;
 545
 546     if (!TEST_int_eq(ossl_quic_wire_peek_frame_header(pkt, &frame_type_2),
 547                      fail < 0 || fail >= 4))
 548         return 0;
 549
 550     if (!TEST_int_eq(ossl_quic_wire_decode_frame_max_streams(pkt,
 551                                                              &max_streams_2),
 552                      fail < 0))
 553         return 0;
 554
 555     if ((fail < 0 || fail >= 3)
 556         && !TEST_uint64_t_eq(frame_type_1, OSSL_QUIC_FRAME_TYPE_MAX_STREAMS_BIDI))
 557         return 0;
 558
 559     if ((fail < 0 || fail >= 3)
 560         && !TEST_uint64_t_eq(max_streams_1, 0x1234))
 561         return 0;
 562
 563     if ((fail < 0 || fail >= 8)
 564         && !TEST_uint64_t_eq(frame_type_2, OSSL_QUIC_FRAME_TYPE_MAX_STREAMS_UNI))
 565         return 0;
 566
 567     if ((fail < 0 || fail >= 8)
 568         && !TEST_uint64_t_eq(max_streams_2, 0x9781))
 569         return 0;
 570
 571     return 1;
 572 }
 573
 574 static const unsigned char encode_case_12_expect[] = {
 575     0x12,                           /* Type (MAX_STREAMS Bidirectional) */
 576     0x52, 0x34,                     /* Max Streams */
 577     0x13,                           /* Type (MAX_STREAMS Unidirectional) */
 578     0x80, 0x00, 0x97, 0x81,         /* Max Streams */
 579 };
 580
 581 /* 13. DATA_BLOCKED */
 582 static int encode_case_13_enc(WPACKET *pkt)
 583 {
 584     if (!TEST_int_eq(ossl_quic_wire_encode_frame_data_blocked(pkt, 0x1234), 1))
 585         return 0;
 586
 587     return 1;
 588 }
 589
 590 static int encode_case_13_dec(PACKET *pkt, ossl_ssize_t fail)
 591 {
 592     uint64_t max_data = 0;
 593
 594     if (!TEST_int_eq(ossl_quic_wire_decode_frame_data_blocked(pkt,
 595                                                               &max_data), fail < 0))
 596         return 0;
 597
 598     if (fail >= 0)
 599         return 1;
 600
 601     if (!TEST_uint64_t_eq(max_data, 0x1234))
 602         return 0;
 603
 604     return 1;
 605 }
 606
 607 static const unsigned char encode_case_13_expect[] = {
 608     0x14,                           /* Type */
 609     0x52, 0x34,                     /* Max Data */
 610 };
 611
 612 /* 14. STREAM_DATA_BLOCKED */
 613 static int encode_case_14_enc(WPACKET *pkt)
 614 {
 615     if (!TEST_int_eq(ossl_quic_wire_encode_frame_stream_data_blocked(pkt,
 616                                                                      0x1234,
 617                                                                      0x9781), 1))
 618         return 0;
 619
 620     return 1;
 621 }
 622
 623 static int encode_case_14_dec(PACKET *pkt, ossl_ssize_t fail)
 624 {
 625     uint64_t stream_id = 0, max_data = 0;
 626
 627     if (!TEST_int_eq(ossl_quic_wire_decode_frame_stream_data_blocked(pkt,
 628                                                                      &stream_id,
 629                                                                      &max_data), fail < 0))
 630         return 0;
 631
 632     if (fail >= 0)
 633         return 1;
 634
 635     if (!TEST_uint64_t_eq(stream_id, 0x1234))
 636         return 0;
 637
 638     if (!TEST_uint64_t_eq(max_data, 0x9781))
 639         return 0;
 640
 641     return 1;
 642 }
 643
 644 static const unsigned char encode_case_14_expect[] = {
 645     0x15,                           /* Type */
 646     0x52, 0x34,                     /* Stream ID */
 647     0x80, 0x00, 0x97, 0x81,         /* Max Data */
 648 };
 649
 650 /* 15. STREAMS_BLOCKED */
 651 static int encode_case_15_enc(WPACKET *pkt)
 652 {
 653     if (!TEST_int_eq(ossl_quic_wire_encode_frame_streams_blocked(pkt, 0, 0x1234), 1))
 654         return 0;
 655
 656     if (!TEST_int_eq(ossl_quic_wire_encode_frame_streams_blocked(pkt, 1, 0x9781), 1))
 657         return 0;
 658
 659     return 1;
 660 }
 661
 662 static int encode_case_15_dec(PACKET *pkt, ossl_ssize_t fail)
 663 {
 664     uint64_t max_streams_1 = 0, max_streams_2 = 0,
 665             frame_type_1 = 0, frame_type_2 = 0;
 666
 667     if (!TEST_int_eq(ossl_quic_wire_peek_frame_header(pkt, &frame_type_1),
 668                      fail < 0 || fail >= 1))
 669         return 0;
 670
 671     if (!TEST_int_eq(ossl_quic_wire_decode_frame_streams_blocked(pkt,
 672                                                                  &max_streams_1),
 673                      fail < 0 || fail >= 3))
 674         return 0;
 675
 676     if (!TEST_int_eq(ossl_quic_wire_peek_frame_header(pkt, &frame_type_2),
 677                      fail < 0 || fail >= 4))
 678         return 0;
 679
 680     if (!TEST_int_eq(ossl_quic_wire_decode_frame_streams_blocked(pkt,
 681                                                                  &max_streams_2),
 682                      fail < 0 || fail >= 8))
 683         return 0;
 684
 685     if ((fail < 0 || fail >= 1)
 686         && !TEST_uint64_t_eq(frame_type_1, OSSL_QUIC_FRAME_TYPE_STREAMS_BLOCKED_BIDI))
 687         return 0;
 688
 689     if ((fail < 0 || fail >= 3)
 690         && !TEST_uint64_t_eq(max_streams_1, 0x1234))
 691         return 0;
 692
 693     if ((fail < 0 || fail >= 4)
 694         && !TEST_uint64_t_eq(frame_type_2, OSSL_QUIC_FRAME_TYPE_STREAMS_BLOCKED_UNI))
 695         return 0;
 696
 697     if ((fail < 0 || fail >= 8)
 698         && !TEST_uint64_t_eq(max_streams_2, 0x9781))
 699         return 0;
 700
 701     return 1;
 702 }
 703
 704 static const unsigned char encode_case_15_expect[] = {
 705     0x16,                           /* Type (STREAMS_BLOCKED Bidirectional) */
 706     0x52, 0x34,                     /* Max Streams */
 707     0x17,                           /* Type (STREAMS_BLOCKED Unidirectional) */
 708     0x80, 0x00, 0x97, 0x81,         /* Max Streams */
 709 };
 710
 711 /* 16. NEW_CONNECTION_ID */
 712 static const unsigned char encode_case_16_conn_id[] = {
 713     0x33, 0x44, 0x55, 0x66
 714 };
 715
 716 static const OSSL_QUIC_FRAME_NEW_CONN_ID encode_case_16_f = {
 717     0x1234,
 718     0x9781,
 719     {
 720         0x4,
 721         {0x33, 0x44, 0x55, 0x66}
 722     },
 723     {
 724         0xde, 0x06, 0xcb, 0x76, 0x5d, 0xb1, 0xa7, 0x71,
 725         0x78, 0x09, 0xbb, 0xe8, 0x50, 0x19, 0x12, 0x9a
 726     }
 727 };
 728
 729 static int encode_case_16_enc(WPACKET *pkt)
 730 {
 731     if (!TEST_int_eq(ossl_quic_wire_encode_frame_new_conn_id(pkt,
 732                                                              &encode_case_16_f), 1))
 733         return 0;
 734
 735     return 1;
 736 }
 737
 738 static int encode_case_16_dec(PACKET *pkt, ossl_ssize_t fail)
 739 {
 740     OSSL_QUIC_FRAME_NEW_CONN_ID f = {0};
 741
 742     if (!TEST_int_eq(ossl_quic_wire_decode_frame_new_conn_id(pkt, &f), fail < 0))
 743         return 0;
 744
 745     if (fail >= 0)
 746         return 1;
 747
 748     if (!TEST_uint64_t_eq(f.seq_num, 0x1234))
 749         return 0;
 750
 751     if (!TEST_uint64_t_eq(f.retire_prior_to, 0x9781))
 752         return 0;
 753
 754     if (!TEST_uint64_t_eq(f.conn_id.id_len, sizeof(encode_case_16_conn_id)))
 755         return 0;
 756
 757     if (!TEST_mem_eq(f.conn_id.id, f.conn_id.id_len,
 758                      encode_case_16_conn_id, sizeof(encode_case_16_conn_id)))
 759         return 0;
 760
 761     if (!TEST_mem_eq(f.stateless_reset_token,
 762                      sizeof(f.stateless_reset_token),
 763                      encode_case_16_f.stateless_reset_token,
 764                      sizeof(encode_case_16_f.stateless_reset_token)))
 765         return 0;
 766
 767     return 1;
 768 }
 769
 770 static const unsigned char encode_case_16_expect[] = {
 771     0x18,                           /* Type */
 772     0x52, 0x34,                     /* Sequence Number */
 773     0x80, 0x00, 0x97, 0x81,         /* Retire Prior To */
 774     0x04,                           /* Connection ID Length */
 775     0x33, 0x44, 0x55, 0x66,         /* Connection ID */
 776     0xde, 0x06, 0xcb, 0x76, 0x5d, 0xb1, 0xa7, 0x71, /* Stateless Reset Token */
 777     0x78, 0x09, 0xbb, 0xe8, 0x50, 0x19, 0x12, 0x9a
 778 };
 779
 780 /* 17. RETIRE_CONNECTION_ID */
 781 static int encode_case_17_enc(WPACKET *pkt)
 782 {
 783     if (!TEST_int_eq(ossl_quic_wire_encode_frame_retire_conn_id(pkt, 0x1234), 1))
 784         return 0;
 785
 786     return 1;
 787 }
 788
 789 static int encode_case_17_dec(PACKET *pkt, ossl_ssize_t fail)
 790 {
 791     uint64_t seq_num = 0;
 792
 793     if (!TEST_int_eq(ossl_quic_wire_decode_frame_retire_conn_id(pkt, &seq_num), fail < 0))
 794         return 0;
 795
 796     if (fail >= 0)
 797         return 1;
 798
 799     if (!TEST_uint64_t_eq(seq_num, 0x1234))
 800         return 0;
 801
 802     return 1;
 803 }
 804
 805 static const unsigned char encode_case_17_expect[] = {
 806     0x19,                           /* Type */
 807     0x52, 0x34,                     /* Seq Num */
 808 };
 809
 810 /* 18. PATH_CHALLENGE */
 811 static const uint64_t encode_case_18_data
 812     = (((uint64_t)0x5f4b12)<<40) | (uint64_t)0x731834UL;
 813
 814 static int encode_case_18_enc(WPACKET *pkt)
 815 {
 816     if (!TEST_int_eq(ossl_quic_wire_encode_frame_path_challenge(pkt,
 817                                                                 encode_case_18_data), 1))
 818         return 0;
 819
 820     return 1;
 821 }
 822
 823 static int encode_case_18_dec(PACKET *pkt, ossl_ssize_t fail)
 824 {
 825     uint64_t challenge = 0;
 826
 827     if (!TEST_int_eq(ossl_quic_wire_decode_frame_path_challenge(pkt, &challenge), fail < 0))
 828         return 0;
 829
 830     if (fail >= 0)
 831         return 1;
 832
 833     if (!TEST_uint64_t_eq(challenge, encode_case_18_data))
 834         return 0;
 835
 836     return 1;
 837 }
 838
 839 static const unsigned char encode_case_18_expect[] = {
 840     0x1A,                                           /* Type */
 841     0x5f, 0x4b, 0x12, 0x00, 0x00, 0x73, 0x18, 0x34, /* Data */
 842 };
 843
 844 /* 19. PATH_RESPONSE */
 845 static const uint64_t encode_case_19_data
 846     = (((uint64_t)0x5f4b12)<<40) | (uint64_t)0x731834UL;
 847
 848 static int encode_case_19_enc(WPACKET *pkt)
 849 {
 850     if (!TEST_int_eq(ossl_quic_wire_encode_frame_path_response(pkt,
 851                                                                encode_case_19_data), 1))
 852         return 0;
 853
 854     return 1;
 855 }
 856
 857 static int encode_case_19_dec(PACKET *pkt, ossl_ssize_t fail)
 858 {
 859     uint64_t challenge = 0;
 860
 861     if (!TEST_int_eq(ossl_quic_wire_decode_frame_path_response(pkt, &challenge), fail < 0))
 862         return 0;
 863
 864     if (fail >= 0)
 865         return 1;
 866
 867     if (!TEST_uint64_t_eq(challenge, encode_case_19_data))
 868         return 0;
 869
 870     return 1;
 871 }
 872
 873 static const unsigned char encode_case_19_expect[] = {
 874     0x1B,                                           /* Type */
 875     0x5f, 0x4b, 0x12, 0x00, 0x00, 0x73, 0x18, 0x34, /* Data */
 876 };
 877
 878 /* 20. CONNECTION_CLOSE (transport) */
 879 static const char encode_case_20_reason[] = {
 880     /* "reason for closure" */
 881     0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x20, 0x66, 0x6f,
 882     0x72, 0x20, 0x63, 0x6c, 0x6f, 0x73, 0x75, 0x72, 0x65
 883 };
 884
 885 static const OSSL_QUIC_FRAME_CONN_CLOSE encode_case_20_f = {
 886     0,
 887     0x1234,
 888     0x9781,
 889     encode_case_20_reason,
 890     sizeof(encode_case_20_reason)
 891 };
 892
 893 static int encode_case_20_enc(WPACKET *pkt)
 894 {
 895     if (!TEST_int_eq(ossl_quic_wire_encode_frame_conn_close(pkt,
 896                                                             &encode_case_20_f), 1))
 897         return 0;
 898
 899     return 1;
 900 }
 901
 902 static int encode_case_20_dec(PACKET *pkt, ossl_ssize_t fail)
 903 {
 904     OSSL_QUIC_FRAME_CONN_CLOSE f = {0};
 905
 906     if (!TEST_int_eq(ossl_quic_wire_decode_frame_conn_close(pkt, &f), fail < 0))
 907         return 0;
 908
 909     if (fail >= 0)
 910         return 1;
 911
 912     if (!TEST_int_eq(f.is_app, 0))
 913         return 0;
 914
 915     if (!TEST_uint64_t_eq(f.error_code, 0x1234))
 916         return 0;
 917
 918     if (!TEST_uint64_t_eq(f.frame_type, 0x9781))
 919         return 0;
 920
 921     if (!TEST_size_t_eq(f.reason_len, 18))
 922         return 0;
 923
 924     if (!TEST_mem_eq(f.reason, f.reason_len,
 925                      encode_case_20_f.reason, encode_case_20_f.reason_len))
 926         return 0;
 927
 928     return 1;
 929 }
 930
 931 static const unsigned char encode_case_20_expect[] = {
 932     0x1C,                           /* Type */
 933     0x52, 0x34,                     /* Sequence Number */
 934     0x80, 0x00, 0x97, 0x81,         /* Frame Type */
 935     0x12,                           /* Reason Length */
 936     0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x20, 0x66, 0x6f, /* Reason */
 937     0x72, 0x20, 0x63, 0x6c, 0x6f, 0x73, 0x75, 0x72, 0x65
 938 };
 939
 940 /* 21. HANDSHAKE_DONE */
 941 static int encode_case_21_enc(WPACKET *pkt)
 942 {
 943
 944     if (!TEST_int_eq(ossl_quic_wire_encode_frame_handshake_done(pkt), 1))
 945         return 0;
 946
 947     return 1;
 948 }
 949
 950 static int encode_case_21_dec(PACKET *pkt, ossl_ssize_t fail)
 951 {
 952
 953     if (!TEST_int_eq(ossl_quic_wire_decode_frame_handshake_done(pkt), fail < 0))
 954         return 0;
 955
 956     return 1;
 957 }
 958
 959 static const unsigned char encode_case_21_expect[] = {
 960     0x1E
 961 };
 962
 963 /* 22. Buffer Transport Parameter */
 964 static const unsigned char encode_case_22_data[] = {0x55,0x77,0x32,0x46,0x99};
 965
 966 static int encode_case_22_enc(WPACKET *pkt)
 967 {
 968     unsigned char *p;
 969
 970     if (!TEST_ptr(ossl_quic_wire_encode_transport_param_bytes(pkt, 0x1234,
 971                                                               encode_case_22_data,
 972                                                               sizeof(encode_case_22_data))))
 973         return 0;
 974
 975     if (!TEST_ptr(p = ossl_quic_wire_encode_transport_param_bytes(pkt, 0x9781,
 976                                                                   NULL, 2)))
 977         return 0;
 978
 979     p[0] = 0x33;
 980     p[1] = 0x44;
 981
 982     return 1;
 983 }
 984
 985 static int encode_case_22_dec(PACKET *pkt, ossl_ssize_t fail)
 986 {
 987     uint64_t id = 0;
 988     size_t len = 0;
 989     const unsigned char *p;
 990     static const unsigned char data[] = {0x33, 0x44};
 991
 992     if (!TEST_int_eq(ossl_quic_wire_peek_transport_param(pkt, &id),
 993                      fail < 0 || fail >= 2))
 994         return 0;
 995
 996     if ((fail < 0 || fail >= 2)
 997         && !TEST_uint64_t_eq(id, 0x1234))
 998         return 0;
 999
1000     id = 0;
1001
1002     p = ossl_quic_wire_decode_transport_param_bytes(pkt, &id, &len);
1003     if (fail < 0 || fail >= 8) {
1004         if (!TEST_ptr(p))
1005             return 0;
1006     } else {
1007         if (!TEST_ptr_null(p))
1008             return 0;
1009     }
1010
1011     if ((fail < 0 || fail >= 8)
1012         && !TEST_uint64_t_eq(id, 0x1234))
1013         return 0;
1014
1015     if ((fail < 0 || fail >= 8)
1016         && !TEST_mem_eq(p, len, encode_case_22_data, sizeof(encode_case_22_data)))
1017         return 0;
1018
1019     if ((fail < 0 || fail >= 8)
1020         && !TEST_int_eq(ossl_quic_wire_peek_transport_param(pkt, &id),
1021                         fail < 0 || fail >= 12))
1022         return 0;
1023
1024     if ((fail < 0 || fail >= 12)
1025         && !TEST_uint64_t_eq(id, 0x9781))
1026         return 0;
1027
1028     id = 0;
1029
1030     p = ossl_quic_wire_decode_transport_param_bytes(pkt, &id, &len);
1031     if (fail < 0 || fail >= 15) {
1032         if (!TEST_ptr(p))
1033             return 0;
1034     } else {
1035         if (!TEST_ptr_null(p))
1036             return 0;
1037     }
1038
1039     if ((fail < 0 || fail >= 15)
1040         && !TEST_uint64_t_eq(id, 0x9781))
1041         return 0;
1042
1043     if ((fail < 0 || fail >= 15)
1044         && !TEST_mem_eq(p, len, data, sizeof(data)))
1045         return 0;
1046
1047     return 1;
1048 }
1049
1050 static const unsigned char encode_case_22_expect[] = {
1051     0x52, 0x34,                         /* ID */
1052     0x05,                               /* Length */
1053     0x55, 0x77, 0x32, 0x46, 0x99,       /* Data */
1054
1055     0x80, 0x00, 0x97, 0x81,             /* ID */
1056     0x02,                               /* Length */
1057     0x33, 0x44                          /* Data */
1058 };
1059
1060 /* 23. Integer Transport Parameter */
1061 static int encode_case_23_enc(WPACKET *pkt)
1062 {
1063     if (!TEST_int_eq(ossl_quic_wire_encode_transport_param_int(pkt, 0x1234, 0x9781), 1))
1064         return 0;
1065
1066     if (!TEST_int_eq(ossl_quic_wire_encode_transport_param_int(pkt, 0x2233, 0x4545), 1))
1067         return 0;
1068
1069     return 1;
1070 }
1071
1072 static int encode_case_23_dec(PACKET *pkt, ossl_ssize_t fail)
1073 {
1074     uint64_t id = 0, value = 0;
1075
1076     if (!TEST_int_eq(ossl_quic_wire_decode_transport_param_int(pkt,
1077                                                                &id, &value),
1078                      fail < 0 || fail >= 7))
1079         return 0;
1080
1081     if ((fail < 0 || fail >= 7)
1082         && !TEST_uint64_t_eq(id, 0x1234))
1083         return 0;
1084
1085     if ((fail < 0 || fail >= 7)
1086         && !TEST_uint64_t_eq(value, 0x9781))
1087         return 0;
1088
1089     if (!TEST_int_eq(ossl_quic_wire_decode_transport_param_int(pkt,
1090                                                                &id, &value),
1091                      fail < 0 || fail >= 14))
1092         return 0;
1093
1094     if ((fail < 0 || fail >= 14)
1095         && !TEST_uint64_t_eq(id, 0x2233))
1096         return 0;
1097
1098     if ((fail < 0 || fail >= 14)
1099         && !TEST_uint64_t_eq(value, 0x4545))
1100         return 0;
1101
1102     return 1;
1103 }
1104
1105 static const unsigned char encode_case_23_expect[] = {
1106     0x52, 0x34,
1107     0x04,
1108     0x80, 0x00, 0x97, 0x81,
1109
1110     0x62, 0x33,
1111     0x04,
1112     0x80, 0x00, 0x45, 0x45,
1113 };
1114
1115 #define ENCODE_CASE(n)                          \
1116     {                                           \
1117       encode_case_##n##_enc,                    \
1118       encode_case_##n##_expect,                 \
1119       OSSL_NELEM(encode_case_##n##_expect),     \
1120       encode_case_##n##_dec                     \
1121     },
1122
1123 static const struct encode_test_case encode_cases[] = {
1124     ENCODE_CASE(1)
1125     ENCODE_CASE(2)
1126     ENCODE_CASE(3)
1127     ENCODE_CASE(4)
1128     ENCODE_CASE(5)
1129     ENCODE_CASE(6)
1130     ENCODE_CASE(7)
1131     ENCODE_CASE(8)
1132     ENCODE_CASE(9)
1133     ENCODE_CASE(10)
1134     ENCODE_CASE(11)
1135     ENCODE_CASE(12)
1136     ENCODE_CASE(13)
1137     ENCODE_CASE(14)
1138     ENCODE_CASE(15)
1139     ENCODE_CASE(16)
1140     ENCODE_CASE(17)
1141     ENCODE_CASE(18)
1142     ENCODE_CASE(19)
1143     ENCODE_CASE(20)
1144     ENCODE_CASE(21)
1145     ENCODE_CASE(22)
1146     ENCODE_CASE(23)
1147 };
1148
1149 static int test_wire_encode(int idx)
1150 {
1151     int testresult = 0;
1152     WPACKET wpkt;
1153     PACKET pkt;
1154     BUF_MEM *buf = NULL;
1155     size_t written;
1156     const struct encode_test_case *c = &encode_cases[idx];
1157     int have_wpkt = 0;
1158     size_t i;
1159
1160     if (!TEST_ptr(buf = BUF_MEM_new()))
1161         goto err;
1162
1163     if (!TEST_int_eq(WPACKET_init(&wpkt, buf), 1))
1164         goto err;
1165
1166     have_wpkt = 1;
1167     if (!TEST_int_eq(c->serializer(&wpkt), 1))
1168         goto err;
1169
1170     if (!TEST_int_eq(WPACKET_get_total_written(&wpkt, &written), 1))
1171         goto err;
1172
1173     if (!TEST_mem_eq(buf->data, written, c->expect_buf, c->expect_buf_len))
1174         goto err;
1175
1176     if (!TEST_int_eq(PACKET_buf_init(&pkt, (unsigned char *)buf->data, written), 1))
1177         goto err;
1178
1179     if (!TEST_int_eq(c->deserializer(&pkt, -1), 1))
1180         goto err;
1181
1182     if (!TEST_false(PACKET_remaining(&pkt)))
1183         goto err;
1184
1185     for (i = 0; i < c->expect_buf_len; ++i) {
1186         PACKET pkt2;
1187
1188         /*
1189          * Check parsing truncated (i.e., malformed) input is handled correctly.
1190          * Generate all possible truncations of our reference encoding and
1191          * verify that they are handled correctly. The number of bytes of the
1192          * truncated encoding is passed as an argument to the deserializer to
1193          * help it determine whether decoding should fail or not.
1194          */
1195         if (!TEST_int_eq(PACKET_buf_init(&pkt2, (unsigned char *)c->expect_buf, i), 1))
1196             goto err;
1197
1198         if (!TEST_int_eq(c->deserializer(&pkt2, i), 1))
1199             goto err;
1200     }
1201
1202     testresult = 1;
1203 err:
1204     if (have_wpkt)
1205         WPACKET_finish(&wpkt);
1206     BUF_MEM_free(buf);
1207     return testresult;
1208 }
1209
1210 struct ack_test_case {
1211     const unsigned char    *input_buf;
1212     size_t                  input_buf_len;
1213     int                   (*deserializer)(PACKET *pkt);
1214     int                     expect_fail;
1215 };
1216
1217 /* ACK Frame with Excessive First ACK Range Field */
1218 static const unsigned char ack_case_1_input[] = {
1219     0x02,           /* ACK Without ECN */
1220     0x08,           /* Largest Acknowledged */
1221     0x01,           /* ACK Delay */
1222     0x00,           /* ACK Range Count */
1223     0x09,           /* First ACK Range */
1224 };
1225
1226 /* ACK Frame with Valid ACK Range Field */
1227 static const unsigned char ack_case_2_input[] = {
1228     0x02,           /* ACK Without ECN */
1229     0x08,           /* Largest Acknowledged */
1230     0x01,           /* ACK Delay */
1231     0x00,           /* ACK Range Count */
1232     0x08,           /* First ACK Range */
1233 };
1234
1235 /* ACK Frame with Excessive ACK Range Gap */
1236 static const unsigned char ack_case_3_input[] = {
1237     0x02,           /* ACK Without ECN */
1238     0x08,           /* Largest Acknowledged */
1239     0x01,           /* ACK Delay */
1240     0x01,           /* ACK Range Count */
1241     0x01,           /* First ACK Range */
1242
1243     0x05,           /* Gap */
1244     0x01,           /* ACK Range Length */
1245 };
1246
1247 /* ACK Frame with Valid ACK Range */
1248 static const unsigned char ack_case_4_input[] = {
1249     0x02,           /* ACK Without ECN */
1250     0x08,           /* Largest Acknowledged */
1251     0x01,           /* ACK Delay */
1252     0x01,           /* ACK Range Count */
1253     0x01,           /* First ACK Range */
1254
1255     0x04,           /* Gap */
1256     0x01,           /* ACK Range Length */
1257 };
1258
1259 /* ACK Frame with Excessive ACK Range Length */
1260 static const unsigned char ack_case_5_input[] = {
1261     0x02,           /* ACK Without ECN */
1262     0x08,           /* Largest Acknowledged */
1263     0x01,           /* ACK Delay */
1264     0x01,           /* ACK Range Count */
1265     0x01,           /* First ACK Range */
1266
1267     0x04,           /* Gap */
1268     0x02,           /* ACK Range Length */
1269 };
1270
1271 /* ACK Frame with Multiple ACK Ranges, Final Having Excessive Length */
1272 static const unsigned char ack_case_6_input[] = {
1273     0x02,           /* ACK Without ECN */
1274     0x08,           /* Largest Acknowledged */
1275     0x01,           /* ACK Delay */
1276     0x02,           /* ACK Range Count */
1277     0x01,           /* First ACK Range */
1278
1279     0x01,           /* Gap */
1280     0x02,           /* ACK Range Length */
1281
1282     0x00,           /* Gap */
1283     0x01,           /* ACK Range Length */
1284 };
1285
1286 /* ACK Frame with Multiple ACK Ranges, Valid */
1287 static const unsigned char ack_case_7_input[] = {
1288     0x02,           /* ACK Without ECN */
1289     0x08,           /* Largest Acknowledged */
1290     0x01,           /* ACK Delay */
1291     0x02,           /* ACK Range Count */
1292     0x01,           /* First ACK Range */
1293
1294     0x01,           /* Gap */
1295     0x02,           /* ACK Range Length */
1296
1297     0x00,           /* Gap */
1298     0x00,           /* ACK Range Length */
1299 };
1300
1301 static int ack_generic_decode(PACKET *pkt)
1302 {
1303     OSSL_QUIC_ACK_RANGE ranges[8] = {0};
1304     OSSL_QUIC_FRAME_ACK f = {0};
1305     uint64_t total_ranges = 0, peek_total_ranges = 0;
1306     int r;
1307     size_t i;
1308
1309     f.ack_ranges        = ranges;
1310     f.num_ack_ranges    = OSSL_NELEM(ranges);
1311
1312     if (!TEST_int_eq(ossl_quic_wire_peek_frame_ack_num_ranges(pkt,
1313                                                               &peek_total_ranges), 1))
1314         return 0;
1315
1316     r = ossl_quic_wire_decode_frame_ack(pkt, 3, &f, &total_ranges);
1317     if (r == 0)
1318         return 0;
1319
1320     if (!TEST_uint64_t_eq(total_ranges, peek_total_ranges))
1321         return 0;
1322
1323     for (i = 0; i < f.num_ack_ranges; ++i) {
1324         if (!TEST_uint64_t_le(f.ack_ranges[i].start, f.ack_ranges[i].end))
1325             return 0;
1326         if (!TEST_uint64_t_lt(f.ack_ranges[i].end, 1000))
1327             return 0;
1328     }
1329
1330     return 1;
1331 }
1332
1333 #define ACK_CASE(n, expect_fail, dec)   \
1334     {                                   \
1335         ack_case_##n##_input,           \
1336         sizeof(ack_case_##n##_input),   \
1337         (dec),                          \
1338         (expect_fail)                   \
1339     },
1340
1341 static const struct ack_test_case ack_cases[] = {
1342     ACK_CASE(1, 1, ack_generic_decode)
1343     ACK_CASE(2, 0, ack_generic_decode)
1344     ACK_CASE(3, 1, ack_generic_decode)
1345     ACK_CASE(4, 0, ack_generic_decode)
1346     ACK_CASE(5, 1, ack_generic_decode)
1347     ACK_CASE(6, 1, ack_generic_decode)
1348     ACK_CASE(7, 0, ack_generic_decode)
1349 };
1350
1351 static int test_wire_ack(int idx)
1352 {
1353     int testresult = 0, r;
1354     PACKET pkt;
1355     const struct ack_test_case *c = &ack_cases[idx];
1356
1357     if (!TEST_int_eq(PACKET_buf_init(&pkt,
1358                                      (unsigned char *)c->input_buf,
1359                                      c->input_buf_len), 1))
1360         goto err;
1361
1362     r = c->deserializer(&pkt);
1363     if (c->expect_fail) {
1364         if (!TEST_int_eq(r, 0))
1365             goto err;
1366     } else {
1367         if (!TEST_int_eq(r, 1))
1368             goto err;
1369
1370         if (!TEST_false(PACKET_remaining(&pkt)))
1371             goto err;
1372     }
1373
1374     testresult = 1;
1375 err:
1376     return testresult;
1377 }
1378
1379 /* Packet Header PN Encoding Tests */
1380 struct pn_test {
1381     QUIC_PN         pn, tx_largest_acked, rx_largest_pn;
1382     char            expected_len;
1383     unsigned char   expected_bytes[4];
1384 };
1385
1386 static const struct pn_test pn_tests[] = {
1387     /* RFC 9000 Section A.2 */
1388     { 0xac5c02, 0xabe8b3, 0xabe8b3, 2, {0x5c,0x02} },
1389     { 0xace8fe, 0xabe8b3, 0xabe8b3, 3, {0xac,0xe8,0xfe} },
1390     /* RFC 9000 Section A.3 */
1391     { 0xa82f9b32, 0xa82f30ea, 0xa82f30ea, 2, {0x9b,0x32} },
1392     /* Boundary Cases */
1393     { 1, 0, 0, 1, {0x01} },
1394     { 256, 255, 255, 1, {0x00} },
1395     { 257, 255, 255, 1, {0x01} },
1396     { 256, 128, 128, 1, {0x00} },
1397     { 256, 127, 127, 2, {0x01,0x00} },
1398     { 65536, 32768, 32768, 2, {0x00,0x00} },
1399     { 65537, 32769, 32769, 2, {0x00,0x01} },
1400     { 65536, 32767, 32767, 3, {0x01,0x00,0x00} },
1401     { 65537, 32768, 32768, 3, {0x01,0x00,0x01} },
1402     { 16777216, 8388608, 8388608, 3, {0x00,0x00,0x00} },
1403     { 16777217, 8388609, 8388609, 3, {0x00,0x00,0x01} },
1404     { 16777216, 8388607, 8388607, 4, {0x01,0x00,0x00,0x00} },
1405     { 16777217, 8388608, 8388608, 4, {0x01,0x00,0x00,0x01} },
1406     { 4294967296, 2147483648, 2147483648, 4, {0x00,0x00,0x00,0x00} },
1407     { 4294967297, 2147483648, 2147483648, 4, {0x00,0x00,0x00,0x01} },
1408 };
1409
1410 static int test_wire_pkt_hdr_pn(int tidx)
1411 {
1412     int testresult = 0;
1413     const struct pn_test *t = &pn_tests[tidx];
1414     unsigned char buf[4];
1415     int pn_len;
1416     QUIC_PN res_pn;
1417
1418     pn_len = ossl_quic_wire_determine_pn_len(t->pn, t->tx_largest_acked);
1419     if (!TEST_int_eq(pn_len, (int)t->expected_len))
1420         goto err;
1421
1422     if (!TEST_true(ossl_quic_wire_encode_pkt_hdr_pn(t->pn, buf, pn_len)))
1423         goto err;
1424
1425     if (!TEST_mem_eq(t->expected_bytes, t->expected_len, buf, pn_len))
1426         goto err;
1427
1428     if (!TEST_true(ossl_quic_wire_decode_pkt_hdr_pn(buf, pn_len,
1429                                                     t->rx_largest_pn, &res_pn)))
1430         goto err;
1431
1432     if (!TEST_uint64_t_eq(res_pn, t->pn))
1433         goto err;
1434
1435     testresult = 1;
1436 err:
1437     return testresult;
1438 }
1439
1440 int setup_tests(void)
1441 {
1442     ADD_ALL_TESTS(test_wire_encode,     OSSL_NELEM(encode_cases));
1443     ADD_ALL_TESTS(test_wire_ack,        OSSL_NELEM(ack_cases));
1444     ADD_ALL_TESTS(test_wire_pkt_hdr_pn, OSSL_NELEM(pn_tests));
1445     return 1;
1446 }