test/quic_wire_test.c

   1 /*
   2  * Copyright 2022-2023 The OpenSSL Project Authors. All Rights Reserved.
   3  *
   4  * Licensed under the Apache License 2.0 (the "License").  You may not use
   5  * this file except in compliance with the License.  You can obtain a copy
   6  * in the file LICENSE in the source distribution or at
   7  * https://www.openssl.org/source/license.html
   8  */
   9
  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, 0, &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, 0, &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, 0, &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     int is_minimal = 1, success_if;
 537
 538     success_if = (fail < 0 || fail >= 1);
 539     if (!TEST_int_eq(ossl_quic_wire_peek_frame_header(pkt, &frame_type_1,
 540                                                       &is_minimal),
 541                      success_if))
 542         return 0;
 543
 544     if (!TEST_true(!success_if || is_minimal))
 545         return 0;
 546
 547     success_if = (fail < 0 || fail >= 3);
 548     if (!TEST_int_eq(ossl_quic_wire_decode_frame_max_streams(pkt,
 549                                                              &max_streams_1),
 550                      success_if))
 551         return 0;
 552
 553     success_if = (fail < 0 || fail >= 4);
 554     if (!TEST_int_eq(ossl_quic_wire_peek_frame_header(pkt, &frame_type_2,
 555                                                       &is_minimal),
 556                      success_if))
 557         return 0;
 558
 559     if (!TEST_true(!success_if || is_minimal))
 560         return 0;
 561
 562     success_if = (fail < 0);
 563     if (!TEST_int_eq(ossl_quic_wire_decode_frame_max_streams(pkt,
 564                                                              &max_streams_2),
 565                      success_if))
 566         return 0;
 567
 568     if ((fail < 0 || fail >= 3)
 569         && !TEST_uint64_t_eq(frame_type_1, OSSL_QUIC_FRAME_TYPE_MAX_STREAMS_BIDI))
 570         return 0;
 571
 572     if ((fail < 0 || fail >= 3)
 573         && !TEST_uint64_t_eq(max_streams_1, 0x1234))
 574         return 0;
 575
 576     if ((fail < 0 || fail >= 8)
 577         && !TEST_uint64_t_eq(frame_type_2, OSSL_QUIC_FRAME_TYPE_MAX_STREAMS_UNI))
 578         return 0;
 579
 580     if ((fail < 0 || fail >= 8)
 581         && !TEST_uint64_t_eq(max_streams_2, 0x9781))
 582         return 0;
 583
 584     return 1;
 585 }
 586
 587 static const unsigned char encode_case_12_expect[] = {
 588     0x12,                           /* Type (MAX_STREAMS Bidirectional) */
 589     0x52, 0x34,                     /* Max Streams */
 590     0x13,                           /* Type (MAX_STREAMS Unidirectional) */
 591     0x80, 0x00, 0x97, 0x81,         /* Max Streams */
 592 };
 593
 594 /* 13. DATA_BLOCKED */
 595 static int encode_case_13_enc(WPACKET *pkt)
 596 {
 597     if (!TEST_int_eq(ossl_quic_wire_encode_frame_data_blocked(pkt, 0x1234), 1))
 598         return 0;
 599
 600     return 1;
 601 }
 602
 603 static int encode_case_13_dec(PACKET *pkt, ossl_ssize_t fail)
 604 {
 605     uint64_t max_data = 0;
 606
 607     if (!TEST_int_eq(ossl_quic_wire_decode_frame_data_blocked(pkt,
 608                                                               &max_data), fail < 0))
 609         return 0;
 610
 611     if (fail >= 0)
 612         return 1;
 613
 614     if (!TEST_uint64_t_eq(max_data, 0x1234))
 615         return 0;
 616
 617     return 1;
 618 }
 619
 620 static const unsigned char encode_case_13_expect[] = {
 621     0x14,                           /* Type */
 622     0x52, 0x34,                     /* Max Data */
 623 };
 624
 625 /* 14. STREAM_DATA_BLOCKED */
 626 static int encode_case_14_enc(WPACKET *pkt)
 627 {
 628     if (!TEST_int_eq(ossl_quic_wire_encode_frame_stream_data_blocked(pkt,
 629                                                                      0x1234,
 630                                                                      0x9781), 1))
 631         return 0;
 632
 633     return 1;
 634 }
 635
 636 static int encode_case_14_dec(PACKET *pkt, ossl_ssize_t fail)
 637 {
 638     uint64_t stream_id = 0, max_data = 0;
 639
 640     if (!TEST_int_eq(ossl_quic_wire_decode_frame_stream_data_blocked(pkt,
 641                                                                      &stream_id,
 642                                                                      &max_data), fail < 0))
 643         return 0;
 644
 645     if (fail >= 0)
 646         return 1;
 647
 648     if (!TEST_uint64_t_eq(stream_id, 0x1234))
 649         return 0;
 650
 651     if (!TEST_uint64_t_eq(max_data, 0x9781))
 652         return 0;
 653
 654     return 1;
 655 }
 656
 657 static const unsigned char encode_case_14_expect[] = {
 658     0x15,                           /* Type */
 659     0x52, 0x34,                     /* Stream ID */
 660     0x80, 0x00, 0x97, 0x81,         /* Max Data */
 661 };
 662
 663 /* 15. STREAMS_BLOCKED */
 664 static int encode_case_15_enc(WPACKET *pkt)
 665 {
 666     if (!TEST_int_eq(ossl_quic_wire_encode_frame_streams_blocked(pkt, 0, 0x1234), 1))
 667         return 0;
 668
 669     if (!TEST_int_eq(ossl_quic_wire_encode_frame_streams_blocked(pkt, 1, 0x9781), 1))
 670         return 0;
 671
 672     return 1;
 673 }
 674
 675 static int encode_case_15_dec(PACKET *pkt, ossl_ssize_t fail)
 676 {
 677     uint64_t max_streams_1 = 0, max_streams_2 = 0,
 678             frame_type_1 = 0, frame_type_2 = 0;
 679     int is_minimal = 1, success_if;
 680
 681     success_if = (fail < 0 || fail >= 1);
 682     if (!TEST_int_eq(ossl_quic_wire_peek_frame_header(pkt, &frame_type_1,
 683                                                       &is_minimal),
 684                      success_if))
 685         return 0;
 686
 687     if (!TEST_true(!success_if || is_minimal))
 688         return 0;
 689
 690     success_if = (fail < 0 || fail >= 3);
 691     if (!TEST_int_eq(ossl_quic_wire_decode_frame_streams_blocked(pkt,
 692                                                                  &max_streams_1),
 693                      success_if))
 694         return 0;
 695
 696     success_if = (fail < 0 || fail >= 4);
 697     if (!TEST_int_eq(ossl_quic_wire_peek_frame_header(pkt, &frame_type_2,
 698                                                       &is_minimal),
 699                      success_if))
 700         return 0;
 701
 702     if (!TEST_true(!success_if || is_minimal))
 703         return 0;
 704
 705     if (!TEST_int_eq(ossl_quic_wire_decode_frame_streams_blocked(pkt,
 706                                                                  &max_streams_2),
 707                      fail < 0 || fail >= 8))
 708         return 0;
 709
 710     if ((fail < 0 || fail >= 1)
 711         && !TEST_uint64_t_eq(frame_type_1, OSSL_QUIC_FRAME_TYPE_STREAMS_BLOCKED_BIDI))
 712         return 0;
 713
 714     if ((fail < 0 || fail >= 3)
 715         && !TEST_uint64_t_eq(max_streams_1, 0x1234))
 716         return 0;
 717
 718     if ((fail < 0 || fail >= 4)
 719         && !TEST_uint64_t_eq(frame_type_2, OSSL_QUIC_FRAME_TYPE_STREAMS_BLOCKED_UNI))
 720         return 0;
 721
 722     if ((fail < 0 || fail >= 8)
 723         && !TEST_uint64_t_eq(max_streams_2, 0x9781))
 724         return 0;
 725
 726     return 1;
 727 }
 728
 729 static const unsigned char encode_case_15_expect[] = {
 730     0x16,                           /* Type (STREAMS_BLOCKED Bidirectional) */
 731     0x52, 0x34,                     /* Max Streams */
 732     0x17,                           /* Type (STREAMS_BLOCKED Unidirectional) */
 733     0x80, 0x00, 0x97, 0x81,         /* Max Streams */
 734 };
 735
 736 /* 16. NEW_CONNECTION_ID */
 737 static const unsigned char encode_case_16_conn_id[] = {
 738     0x33, 0x44, 0x55, 0x66
 739 };
 740
 741 static const OSSL_QUIC_FRAME_NEW_CONN_ID encode_case_16_f = {
 742     0x9781,
 743     0x1234,
 744     {
 745         0x4,
 746         {0x33, 0x44, 0x55, 0x66}
 747     },
 748     {
 749         {
 750             0xde, 0x06, 0xcb, 0x76, 0x5d, 0xb1, 0xa7, 0x71,
 751             0x78, 0x09, 0xbb, 0xe8, 0x50, 0x19, 0x12, 0x9a
 752         }
 753     }
 754 };
 755
 756 static int encode_case_16_enc(WPACKET *pkt)
 757 {
 758     if (!TEST_int_eq(ossl_quic_wire_encode_frame_new_conn_id(pkt,
 759                                                              &encode_case_16_f), 1))
 760         return 0;
 761
 762     return 1;
 763 }
 764
 765 static int encode_case_16_dec(PACKET *pkt, ossl_ssize_t fail)
 766 {
 767     OSSL_QUIC_FRAME_NEW_CONN_ID f = {0};
 768
 769     if (!TEST_int_eq(ossl_quic_wire_decode_frame_new_conn_id(pkt, &f), fail < 0))
 770         return 0;
 771
 772     if (fail >= 0)
 773         return 1;
 774
 775     if (!TEST_uint64_t_eq(f.seq_num, 0x9781))
 776         return 0;
 777
 778     if (!TEST_uint64_t_eq(f.retire_prior_to, 0x1234))
 779         return 0;
 780
 781     if (!TEST_uint64_t_eq(f.conn_id.id_len, sizeof(encode_case_16_conn_id)))
 782         return 0;
 783
 784     if (!TEST_mem_eq(f.conn_id.id, f.conn_id.id_len,
 785                      encode_case_16_conn_id, sizeof(encode_case_16_conn_id)))
 786         return 0;
 787
 788     if (!TEST_mem_eq(f.stateless_reset.token,
 789                      sizeof(f.stateless_reset.token),
 790                      encode_case_16_f.stateless_reset.token,
 791                      sizeof(encode_case_16_f.stateless_reset.token)))
 792         return 0;
 793
 794     return 1;
 795 }
 796
 797 static const unsigned char encode_case_16_expect[] = {
 798     0x18,                           /* Type */
 799     0x80, 0x00, 0x97, 0x81,         /* Sequence Number */
 800     0x52, 0x34,                     /* Retire Prior To */
 801     0x04,                           /* Connection ID Length */
 802     0x33, 0x44, 0x55, 0x66,         /* Connection ID */
 803     0xde, 0x06, 0xcb, 0x76, 0x5d, 0xb1, 0xa7, 0x71, /* Stateless Reset Token */
 804     0x78, 0x09, 0xbb, 0xe8, 0x50, 0x19, 0x12, 0x9a
 805 };
 806
 807 /* 16b. NEW_CONNECTION_ID seq_num < retire_prior_to */
 808 static const OSSL_QUIC_FRAME_NEW_CONN_ID encode_case_16b_f = {
 809     0x1234,
 810     0x9781,
 811     {
 812         0x4,
 813         {0x33, 0x44, 0x55, 0x66}
 814     },
 815     {
 816         {
 817             0xde, 0x06, 0xcb, 0x76, 0x5d, 0xb1, 0xa7, 0x71,
 818             0x78, 0x09, 0xbb, 0xe8, 0x50, 0x19, 0x12, 0x9a
 819         }
 820     }
 821 };
 822
 823 static int encode_case_16b_enc(WPACKET *pkt)
 824 {
 825     if (!TEST_int_eq(ossl_quic_wire_encode_frame_new_conn_id(pkt,
 826                                                              &encode_case_16b_f), 1))
 827         return 0;
 828
 829     return 1;
 830 }
 831
 832 static int encode_case_16b_dec(PACKET *pkt, ossl_ssize_t fail)
 833 {
 834     OSSL_QUIC_FRAME_NEW_CONN_ID f = {0};
 835
 836     if (!TEST_int_eq(ossl_quic_wire_decode_frame_new_conn_id(pkt, &f), 0))
 837         return 0;
 838
 839     if (!TEST_true(PACKET_forward(pkt, PACKET_remaining(pkt))))
 840         return 0;
 841
 842     return 1;
 843 }
 844
 845 static const unsigned char encode_case_16b_expect[] = {
 846     0x18,                           /* Type */
 847     0x52, 0x34,                     /* Sequence Number */
 848     0x80, 0x00, 0x97, 0x81,         /* Retire Prior To */
 849     0x04,                           /* Connection ID Length */
 850     0x33, 0x44, 0x55, 0x66,         /* Connection ID */
 851     0xde, 0x06, 0xcb, 0x76, 0x5d, 0xb1, 0xa7, 0x71, /* Stateless Reset Token */
 852     0x78, 0x09, 0xbb, 0xe8, 0x50, 0x19, 0x12, 0x9a
 853 };
 854
 855 /* 17. RETIRE_CONNECTION_ID */
 856 static int encode_case_17_enc(WPACKET *pkt)
 857 {
 858     if (!TEST_int_eq(ossl_quic_wire_encode_frame_retire_conn_id(pkt, 0x1234), 1))
 859         return 0;
 860
 861     return 1;
 862 }
 863
 864 static int encode_case_17_dec(PACKET *pkt, ossl_ssize_t fail)
 865 {
 866     uint64_t seq_num = 0;
 867
 868     if (!TEST_int_eq(ossl_quic_wire_decode_frame_retire_conn_id(pkt, &seq_num), fail < 0))
 869         return 0;
 870
 871     if (fail >= 0)
 872         return 1;
 873
 874     if (!TEST_uint64_t_eq(seq_num, 0x1234))
 875         return 0;
 876
 877     return 1;
 878 }
 879
 880 static const unsigned char encode_case_17_expect[] = {
 881     0x19,                           /* Type */
 882     0x52, 0x34,                     /* Seq Num */
 883 };
 884
 885 /* 18. PATH_CHALLENGE */
 886 static const uint64_t encode_case_18_data
 887     = (((uint64_t)0x5f4b12)<<40) | (uint64_t)0x731834UL;
 888
 889 static int encode_case_18_enc(WPACKET *pkt)
 890 {
 891     if (!TEST_int_eq(ossl_quic_wire_encode_frame_path_challenge(pkt,
 892                                                                 encode_case_18_data), 1))
 893         return 0;
 894
 895     return 1;
 896 }
 897
 898 static int encode_case_18_dec(PACKET *pkt, ossl_ssize_t fail)
 899 {
 900     uint64_t challenge = 0;
 901
 902     if (!TEST_int_eq(ossl_quic_wire_decode_frame_path_challenge(pkt, &challenge), fail < 0))
 903         return 0;
 904
 905     if (fail >= 0)
 906         return 1;
 907
 908     if (!TEST_uint64_t_eq(challenge, encode_case_18_data))
 909         return 0;
 910
 911     return 1;
 912 }
 913
 914 static const unsigned char encode_case_18_expect[] = {
 915     0x1A,                                           /* Type */
 916     0x5f, 0x4b, 0x12, 0x00, 0x00, 0x73, 0x18, 0x34, /* Data */
 917 };
 918
 919 /* 19. PATH_RESPONSE */
 920 static const uint64_t encode_case_19_data
 921     = (((uint64_t)0x5f4b12)<<40) | (uint64_t)0x731834UL;
 922
 923 static int encode_case_19_enc(WPACKET *pkt)
 924 {
 925     if (!TEST_int_eq(ossl_quic_wire_encode_frame_path_response(pkt,
 926                                                                encode_case_19_data), 1))
 927         return 0;
 928
 929     return 1;
 930 }
 931
 932 static int encode_case_19_dec(PACKET *pkt, ossl_ssize_t fail)
 933 {
 934     uint64_t challenge = 0;
 935
 936     if (!TEST_int_eq(ossl_quic_wire_decode_frame_path_response(pkt, &challenge), fail < 0))
 937         return 0;
 938
 939     if (fail >= 0)
 940         return 1;
 941
 942     if (!TEST_uint64_t_eq(challenge, encode_case_19_data))
 943         return 0;
 944
 945     return 1;
 946 }
 947
 948 static const unsigned char encode_case_19_expect[] = {
 949     0x1B,                                           /* Type */
 950     0x5f, 0x4b, 0x12, 0x00, 0x00, 0x73, 0x18, 0x34, /* Data */
 951 };
 952
 953 /* 20. CONNECTION_CLOSE (transport) */
 954 static const char encode_case_20_reason[] = {
 955     /* "reason for closure" */
 956     0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x20, 0x66, 0x6f,
 957     0x72, 0x20, 0x63, 0x6c, 0x6f, 0x73, 0x75, 0x72, 0x65
 958 };
 959
 960 static const OSSL_QUIC_FRAME_CONN_CLOSE encode_case_20_f = {
 961     0,
 962     0x1234,
 963     0x9781,
 964     (char *)encode_case_20_reason,
 965     sizeof(encode_case_20_reason)
 966 };
 967
 968 static int encode_case_20_enc(WPACKET *pkt)
 969 {
 970     if (!TEST_int_eq(ossl_quic_wire_encode_frame_conn_close(pkt,
 971                                                             &encode_case_20_f), 1))
 972         return 0;
 973
 974     return 1;
 975 }
 976
 977 static int encode_case_20_dec(PACKET *pkt, ossl_ssize_t fail)
 978 {
 979     OSSL_QUIC_FRAME_CONN_CLOSE f = {0};
 980
 981     if (!TEST_int_eq(ossl_quic_wire_decode_frame_conn_close(pkt, &f), fail < 0))
 982         return 0;
 983
 984     if (fail >= 0)
 985         return 1;
 986
 987     if (!TEST_int_eq(f.is_app, 0))
 988         return 0;
 989
 990     if (!TEST_uint64_t_eq(f.error_code, 0x1234))
 991         return 0;
 992
 993     if (!TEST_uint64_t_eq(f.frame_type, 0x9781))
 994         return 0;
 995
 996     if (!TEST_size_t_eq(f.reason_len, 18))
 997         return 0;
 998
 999     if (!TEST_mem_eq(f.reason, f.reason_len,
1000                      encode_case_20_f.reason, encode_case_20_f.reason_len))
1001         return 0;
1002
1003     return 1;
1004 }
1005
1006 static const unsigned char encode_case_20_expect[] = {
1007     0x1C,                           /* Type */
1008     0x52, 0x34,                     /* Sequence Number */
1009     0x80, 0x00, 0x97, 0x81,         /* Frame Type */
1010     0x12,                           /* Reason Length */
1011     0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x20, 0x66, 0x6f, /* Reason */
1012     0x72, 0x20, 0x63, 0x6c, 0x6f, 0x73, 0x75, 0x72, 0x65
1013 };
1014
1015 /* 21. HANDSHAKE_DONE */
1016 static int encode_case_21_enc(WPACKET *pkt)
1017 {
1018
1019     if (!TEST_int_eq(ossl_quic_wire_encode_frame_handshake_done(pkt), 1))
1020         return 0;
1021
1022     return 1;
1023 }
1024
1025 static int encode_case_21_dec(PACKET *pkt, ossl_ssize_t fail)
1026 {
1027
1028     if (!TEST_int_eq(ossl_quic_wire_decode_frame_handshake_done(pkt), fail < 0))
1029         return 0;
1030
1031     return 1;
1032 }
1033
1034 static const unsigned char encode_case_21_expect[] = {
1035     0x1E
1036 };
1037
1038 /* 22. Buffer Transport Parameter */
1039 static const unsigned char encode_case_22_data[] = {0x55,0x77,0x32,0x46,0x99};
1040
1041 static int encode_case_22_enc(WPACKET *pkt)
1042 {
1043     unsigned char *p;
1044
1045     if (!TEST_ptr(ossl_quic_wire_encode_transport_param_bytes(pkt, 0x1234,
1046                                                               encode_case_22_data,
1047                                                               sizeof(encode_case_22_data))))
1048         return 0;
1049
1050     if (!TEST_ptr(p = ossl_quic_wire_encode_transport_param_bytes(pkt, 0x9781,
1051                                                                   NULL, 2)))
1052         return 0;
1053
1054     p[0] = 0x33;
1055     p[1] = 0x44;
1056
1057     return 1;
1058 }
1059
1060 static int encode_case_22_dec(PACKET *pkt, ossl_ssize_t fail)
1061 {
1062     uint64_t id = 0;
1063     size_t len = 0;
1064     const unsigned char *p;
1065     static const unsigned char data[] = {0x33, 0x44};
1066
1067     if (!TEST_int_eq(ossl_quic_wire_peek_transport_param(pkt, &id),
1068                      fail < 0 || fail >= 2))
1069         return 0;
1070
1071     if ((fail < 0 || fail >= 2)
1072         && !TEST_uint64_t_eq(id, 0x1234))
1073         return 0;
1074
1075     id = 0;
1076
1077     p = ossl_quic_wire_decode_transport_param_bytes(pkt, &id, &len);
1078     if (fail < 0 || fail >= 8) {
1079         if (!TEST_ptr(p))
1080             return 0;
1081     } else {
1082         if (!TEST_ptr_null(p))
1083             return 0;
1084     }
1085
1086     if ((fail < 0 || fail >= 8)
1087         && !TEST_uint64_t_eq(id, 0x1234))
1088         return 0;
1089
1090     if ((fail < 0 || fail >= 8)
1091         && !TEST_mem_eq(p, len, encode_case_22_data, sizeof(encode_case_22_data)))
1092         return 0;
1093
1094     if ((fail < 0 || fail >= 8)
1095         && !TEST_int_eq(ossl_quic_wire_peek_transport_param(pkt, &id),
1096                         fail < 0 || fail >= 12))
1097         return 0;
1098
1099     if ((fail < 0 || fail >= 12)
1100         && !TEST_uint64_t_eq(id, 0x9781))
1101         return 0;
1102
1103     id = 0;
1104
1105     p = ossl_quic_wire_decode_transport_param_bytes(pkt, &id, &len);
1106     if (fail < 0 || fail >= 15) {
1107         if (!TEST_ptr(p))
1108             return 0;
1109     } else {
1110         if (!TEST_ptr_null(p))
1111             return 0;
1112     }
1113
1114     if ((fail < 0 || fail >= 15)
1115         && !TEST_uint64_t_eq(id, 0x9781))
1116         return 0;
1117
1118     if ((fail < 0 || fail >= 15)
1119         && !TEST_mem_eq(p, len, data, sizeof(data)))
1120         return 0;
1121
1122     return 1;
1123 }
1124
1125 static const unsigned char encode_case_22_expect[] = {
1126     0x52, 0x34,                         /* ID */
1127     0x05,                               /* Length */
1128     0x55, 0x77, 0x32, 0x46, 0x99,       /* Data */
1129
1130     0x80, 0x00, 0x97, 0x81,             /* ID */
1131     0x02,                               /* Length */
1132     0x33, 0x44                          /* Data */
1133 };
1134
1135 /* 23. Integer Transport Parameter */
1136 static int encode_case_23_enc(WPACKET *pkt)
1137 {
1138     if (!TEST_int_eq(ossl_quic_wire_encode_transport_param_int(pkt, 0x1234, 0x9781), 1))
1139         return 0;
1140
1141     if (!TEST_int_eq(ossl_quic_wire_encode_transport_param_int(pkt, 0x2233, 0x4545), 1))
1142         return 0;
1143
1144     return 1;
1145 }
1146
1147 static int encode_case_23_dec(PACKET *pkt, ossl_ssize_t fail)
1148 {
1149     uint64_t id = 0, value = 0;
1150
1151     if (!TEST_int_eq(ossl_quic_wire_decode_transport_param_int(pkt,
1152                                                                &id, &value),
1153                      fail < 0 || fail >= 7))
1154         return 0;
1155
1156     if ((fail < 0 || fail >= 7)
1157         && !TEST_uint64_t_eq(id, 0x1234))
1158         return 0;
1159
1160     if ((fail < 0 || fail >= 7)
1161         && !TEST_uint64_t_eq(value, 0x9781))
1162         return 0;
1163
1164     if (!TEST_int_eq(ossl_quic_wire_decode_transport_param_int(pkt,
1165                                                                &id, &value),
1166                      fail < 0 || fail >= 14))
1167         return 0;
1168
1169     if ((fail < 0 || fail >= 14)
1170         && !TEST_uint64_t_eq(id, 0x2233))
1171         return 0;
1172
1173     if ((fail < 0 || fail >= 14)
1174         && !TEST_uint64_t_eq(value, 0x4545))
1175         return 0;
1176
1177     return 1;
1178 }
1179
1180 static const unsigned char encode_case_23_expect[] = {
1181     0x52, 0x34,
1182     0x04,
1183     0x80, 0x00, 0x97, 0x81,
1184
1185     0x62, 0x33,
1186     0x04,
1187     0x80, 0x00, 0x45, 0x45,
1188 };
1189
1190 #define ENCODE_CASE(n)                          \
1191     {                                           \
1192       encode_case_##n##_enc,                    \
1193       encode_case_##n##_expect,                 \
1194       OSSL_NELEM(encode_case_##n##_expect),     \
1195       encode_case_##n##_dec                     \
1196     },
1197
1198 static const struct encode_test_case encode_cases[] = {
1199     ENCODE_CASE(1)
1200     ENCODE_CASE(2)
1201     ENCODE_CASE(3)
1202     ENCODE_CASE(4)
1203     ENCODE_CASE(5)
1204     ENCODE_CASE(6)
1205     ENCODE_CASE(7)
1206     ENCODE_CASE(8)
1207     ENCODE_CASE(9)
1208     ENCODE_CASE(10)
1209     ENCODE_CASE(11)
1210     ENCODE_CASE(12)
1211     ENCODE_CASE(13)
1212     ENCODE_CASE(14)
1213     ENCODE_CASE(15)
1214     ENCODE_CASE(16)
1215     ENCODE_CASE(16b)
1216     ENCODE_CASE(17)
1217     ENCODE_CASE(18)
1218     ENCODE_CASE(19)
1219     ENCODE_CASE(20)
1220     ENCODE_CASE(21)
1221     ENCODE_CASE(22)
1222     ENCODE_CASE(23)
1223 };
1224
1225 static int test_wire_encode(int idx)
1226 {
1227     int testresult = 0;
1228     WPACKET wpkt;
1229     PACKET pkt;
1230     BUF_MEM *buf = NULL;
1231     size_t written;
1232     const struct encode_test_case *c = &encode_cases[idx];
1233     int have_wpkt = 0;
1234     size_t i;
1235
1236     if (!TEST_ptr(buf = BUF_MEM_new()))
1237         goto err;
1238
1239     if (!TEST_int_eq(WPACKET_init(&wpkt, buf), 1))
1240         goto err;
1241
1242     have_wpkt = 1;
1243     if (!TEST_int_eq(c->serializer(&wpkt), 1))
1244         goto err;
1245
1246     if (!TEST_int_eq(WPACKET_get_total_written(&wpkt, &written), 1))
1247         goto err;
1248
1249     if (!TEST_mem_eq(buf->data, written, c->expect_buf, c->expect_buf_len))
1250         goto err;
1251
1252     if (!TEST_int_eq(PACKET_buf_init(&pkt, (unsigned char *)buf->data, written), 1))
1253         goto err;
1254
1255     if (!TEST_int_eq(c->deserializer(&pkt, -1), 1))
1256         goto err;
1257
1258     if (!TEST_false(PACKET_remaining(&pkt)))
1259         goto err;
1260
1261     for (i = 0; i < c->expect_buf_len; ++i) {
1262         PACKET pkt2;
1263
1264         /*
1265          * Check parsing truncated (i.e., malformed) input is handled correctly.
1266          * Generate all possible truncations of our reference encoding and
1267          * verify that they are handled correctly. The number of bytes of the
1268          * truncated encoding is passed as an argument to the deserializer to
1269          * help it determine whether decoding should fail or not.
1270          */
1271         if (!TEST_int_eq(PACKET_buf_init(&pkt2, (unsigned char *)c->expect_buf, i), 1))
1272             goto err;
1273
1274         if (!TEST_int_eq(c->deserializer(&pkt2, i), 1))
1275             goto err;
1276     }
1277
1278     testresult = 1;
1279 err:
1280     if (have_wpkt)
1281         WPACKET_finish(&wpkt);
1282     BUF_MEM_free(buf);
1283     return testresult;
1284 }
1285
1286 struct ack_test_case {
1287     const unsigned char    *input_buf;
1288     size_t                  input_buf_len;
1289     int                   (*deserializer)(PACKET *pkt);
1290     int                     expect_fail;
1291 };
1292
1293 /* ACK Frame with Excessive First ACK Range Field */
1294 static const unsigned char ack_case_1_input[] = {
1295     0x02,           /* ACK Without ECN */
1296     0x08,           /* Largest Acknowledged */
1297     0x01,           /* ACK Delay */
1298     0x00,           /* ACK Range Count */
1299     0x09,           /* First ACK Range */
1300 };
1301
1302 /* ACK Frame with Valid ACK Range Field */
1303 static const unsigned char ack_case_2_input[] = {
1304     0x02,           /* ACK Without ECN */
1305     0x08,           /* Largest Acknowledged */
1306     0x01,           /* ACK Delay */
1307     0x00,           /* ACK Range Count */
1308     0x08,           /* First ACK Range */
1309 };
1310
1311 /* ACK Frame with Excessive ACK Range Gap */
1312 static const unsigned char ack_case_3_input[] = {
1313     0x02,           /* ACK Without ECN */
1314     0x08,           /* Largest Acknowledged */
1315     0x01,           /* ACK Delay */
1316     0x01,           /* ACK Range Count */
1317     0x01,           /* First ACK Range */
1318
1319     0x05,           /* Gap */
1320     0x01,           /* ACK Range Length */
1321 };
1322
1323 /* ACK Frame with Valid ACK Range */
1324 static const unsigned char ack_case_4_input[] = {
1325     0x02,           /* ACK Without ECN */
1326     0x08,           /* Largest Acknowledged */
1327     0x01,           /* ACK Delay */
1328     0x01,           /* ACK Range Count */
1329     0x01,           /* First ACK Range */
1330
1331     0x04,           /* Gap */
1332     0x01,           /* ACK Range Length */
1333 };
1334
1335 /* ACK Frame with Excessive ACK Range Length */
1336 static const unsigned char ack_case_5_input[] = {
1337     0x02,           /* ACK Without ECN */
1338     0x08,           /* Largest Acknowledged */
1339     0x01,           /* ACK Delay */
1340     0x01,           /* ACK Range Count */
1341     0x01,           /* First ACK Range */
1342
1343     0x04,           /* Gap */
1344     0x02,           /* ACK Range Length */
1345 };
1346
1347 /* ACK Frame with Multiple ACK Ranges, Final Having Excessive Length */
1348 static const unsigned char ack_case_6_input[] = {
1349     0x02,           /* ACK Without ECN */
1350     0x08,           /* Largest Acknowledged */
1351     0x01,           /* ACK Delay */
1352     0x02,           /* ACK Range Count */
1353     0x01,           /* First ACK Range */
1354
1355     0x01,           /* Gap */
1356     0x02,           /* ACK Range Length */
1357
1358     0x00,           /* Gap */
1359     0x01,           /* ACK Range Length */
1360 };
1361
1362 /* ACK Frame with Multiple ACK Ranges, Valid */
1363 static const unsigned char ack_case_7_input[] = {
1364     0x02,           /* ACK Without ECN */
1365     0x08,           /* Largest Acknowledged */
1366     0x01,           /* ACK Delay */
1367     0x02,           /* ACK Range Count */
1368     0x01,           /* First ACK Range */
1369
1370     0x01,           /* Gap */
1371     0x02,           /* ACK Range Length */
1372
1373     0x00,           /* Gap */
1374     0x00,           /* ACK Range Length */
1375 };
1376
1377 static int ack_generic_decode(PACKET *pkt)
1378 {
1379     OSSL_QUIC_ACK_RANGE ranges[8] = {0};
1380     OSSL_QUIC_FRAME_ACK f = {0};
1381     uint64_t total_ranges = 0, peek_total_ranges = 0;
1382     int r;
1383     size_t i;
1384
1385     f.ack_ranges        = ranges;
1386     f.num_ack_ranges    = OSSL_NELEM(ranges);
1387
1388     if (!TEST_int_eq(ossl_quic_wire_peek_frame_ack_num_ranges(pkt,
1389                                                               &peek_total_ranges), 1))
1390         return 0;
1391
1392     r = ossl_quic_wire_decode_frame_ack(pkt, 3, &f, &total_ranges);
1393     if (r == 0)
1394         return 0;
1395
1396     if (!TEST_uint64_t_eq(total_ranges, peek_total_ranges))
1397         return 0;
1398
1399     for (i = 0; i < f.num_ack_ranges; ++i) {
1400         if (!TEST_uint64_t_le(f.ack_ranges[i].start, f.ack_ranges[i].end))
1401             return 0;
1402         if (!TEST_uint64_t_lt(f.ack_ranges[i].end, 1000))
1403             return 0;
1404     }
1405
1406     return 1;
1407 }
1408
1409 #define ACK_CASE(n, expect_fail, dec)   \
1410     {                                   \
1411         ack_case_##n##_input,           \
1412         sizeof(ack_case_##n##_input),   \
1413         (dec),                          \
1414         (expect_fail)                   \
1415     },
1416
1417 static const struct ack_test_case ack_cases[] = {
1418     ACK_CASE(1, 1, ack_generic_decode)
1419     ACK_CASE(2, 0, ack_generic_decode)
1420     ACK_CASE(3, 1, ack_generic_decode)
1421     ACK_CASE(4, 0, ack_generic_decode)
1422     ACK_CASE(5, 1, ack_generic_decode)
1423     ACK_CASE(6, 1, ack_generic_decode)
1424     ACK_CASE(7, 0, ack_generic_decode)
1425 };
1426
1427 static int test_wire_ack(int idx)
1428 {
1429     int testresult = 0, r;
1430     PACKET pkt;
1431     const struct ack_test_case *c = &ack_cases[idx];
1432
1433     if (!TEST_int_eq(PACKET_buf_init(&pkt,
1434                                      (unsigned char *)c->input_buf,
1435                                      c->input_buf_len), 1))
1436         goto err;
1437
1438     r = c->deserializer(&pkt);
1439     if (c->expect_fail) {
1440         if (!TEST_int_eq(r, 0))
1441             goto err;
1442     } else {
1443         if (!TEST_int_eq(r, 1))
1444             goto err;
1445
1446         if (!TEST_false(PACKET_remaining(&pkt)))
1447             goto err;
1448     }
1449
1450     testresult = 1;
1451 err:
1452     return testresult;
1453 }
1454
1455 /* Packet Header PN Encoding Tests */
1456 struct pn_test {
1457     QUIC_PN         pn, tx_largest_acked, rx_largest_pn;
1458     char            expected_len;
1459     unsigned char   expected_bytes[4];
1460 };
1461
1462 static const struct pn_test pn_tests[] = {
1463     /* RFC 9000 Section A.2 */
1464     { 0xac5c02, 0xabe8b3, 0xabe8b3, 2, {0x5c,0x02} },
1465     { 0xace8fe, 0xabe8b3, 0xabe8b3, 3, {0xac,0xe8,0xfe} },
1466     /* RFC 9000 Section A.3 */
1467     { 0xa82f9b32, 0xa82f30ea, 0xa82f30ea, 2, {0x9b,0x32} },
1468     /* Boundary Cases */
1469     { 1, 0, 0, 1, {0x01} },
1470     { 256, 255, 255, 1, {0x00} },
1471     { 257, 255, 255, 1, {0x01} },
1472     { 256, 128, 128, 1, {0x00} },
1473     { 256, 127, 127, 2, {0x01,0x00} },
1474     { 65536, 32768, 32768, 2, {0x00,0x00} },
1475     { 65537, 32769, 32769, 2, {0x00,0x01} },
1476     { 65536, 32767, 32767, 3, {0x01,0x00,0x00} },
1477     { 65537, 32768, 32768, 3, {0x01,0x00,0x01} },
1478     { 16777216, 8388608, 8388608, 3, {0x00,0x00,0x00} },
1479     { 16777217, 8388609, 8388609, 3, {0x00,0x00,0x01} },
1480     { 16777216, 8388607, 8388607, 4, {0x01,0x00,0x00,0x00} },
1481     { 16777217, 8388608, 8388608, 4, {0x01,0x00,0x00,0x01} },
1482     { 4294967296, 2147483648, 2147483648, 4, {0x00,0x00,0x00,0x00} },
1483     { 4294967297, 2147483648, 2147483648, 4, {0x00,0x00,0x00,0x01} },
1484 };
1485
1486 static int test_wire_pkt_hdr_pn(int tidx)
1487 {
1488     int testresult = 0;
1489     const struct pn_test *t = &pn_tests[tidx];
1490     unsigned char buf[4];
1491     int pn_len;
1492     QUIC_PN res_pn;
1493
1494     pn_len = ossl_quic_wire_determine_pn_len(t->pn, t->tx_largest_acked);
1495     if (!TEST_int_eq(pn_len, (int)t->expected_len))
1496         goto err;
1497
1498     if (!TEST_true(ossl_quic_wire_encode_pkt_hdr_pn(t->pn, buf, pn_len)))
1499         goto err;
1500
1501     if (!TEST_mem_eq(t->expected_bytes, t->expected_len, buf, pn_len))
1502         goto err;
1503
1504     if (!TEST_true(ossl_quic_wire_decode_pkt_hdr_pn(buf, pn_len,
1505                                                     t->rx_largest_pn, &res_pn)))
1506         goto err;
1507
1508     if (!TEST_uint64_t_eq(res_pn, t->pn))
1509         goto err;
1510
1511     testresult = 1;
1512 err:
1513     return testresult;
1514 }
1515
1516 /* RFC 9001 s. A.4 */
1517 static const QUIC_CONN_ID retry_orig_dcid = {
1518     8, { 0x83, 0x94, 0xc8, 0xf0, 0x3e, 0x51, 0x57, 0x08 }
1519 };
1520
1521 static const unsigned char retry_encoded[] = {
1522   0xff,                                                 /* Long Header, Retry */
1523   0x00, 0x00, 0x00, 0x01,                               /* Version 1 */
1524   0x00,                                                 /* DCID */
1525   0x08, 0xf0, 0x67, 0xa5, 0x50, 0x2a, 0x42, 0x62, 0xb5, /* SCID */
1526
1527   /* Retry Token */
1528   0x74, 0x6f, 0x6b, 0x65, 0x6e,
1529
1530   /* Retry Integrity Tag */
1531   0x04, 0xa2, 0x65, 0xba, 0x2e, 0xff, 0x4d, 0x82, 0x90, 0x58, 0xfb, 0x3f, 0x0f,
1532   0x24, 0x96, 0xba
1533 };
1534
1535 static int test_wire_retry_integrity_tag(void)
1536 {
1537     int testresult = 0;
1538     PACKET pkt = {0};
1539     QUIC_PKT_HDR hdr = {0};
1540     unsigned char got_tag[QUIC_RETRY_INTEGRITY_TAG_LEN] = {0};
1541
1542     if (!TEST_true(PACKET_buf_init(&pkt, retry_encoded, sizeof(retry_encoded))))
1543         goto err;
1544
1545     if (!TEST_true(ossl_quic_wire_decode_pkt_hdr(&pkt, 0, 0, 0, &hdr, NULL)))
1546         goto err;
1547
1548     if (!TEST_int_eq(hdr.type, QUIC_PKT_TYPE_RETRY))
1549         goto err;
1550
1551     if (!TEST_true(ossl_quic_calculate_retry_integrity_tag(NULL, NULL, &hdr,
1552                                                            &retry_orig_dcid,
1553                                                            got_tag)))
1554         goto err;
1555
1556     if (!TEST_mem_eq(got_tag, sizeof(got_tag),
1557                      retry_encoded + sizeof(retry_encoded)
1558                         - QUIC_RETRY_INTEGRITY_TAG_LEN,
1559                      QUIC_RETRY_INTEGRITY_TAG_LEN))
1560         goto err;
1561
1562     if (!TEST_true(ossl_quic_validate_retry_integrity_tag(NULL, NULL, &hdr,
1563                                                           &retry_orig_dcid)))
1564         goto err;
1565
1566     testresult = 1;
1567 err:
1568     return testresult;
1569 }
1570
1571 /* is_minimal=0 test */
1572 static const unsigned char non_minimal_1[] = {
1573     0x40, 0x00,
1574 };
1575
1576 static const unsigned char non_minimal_2[] = {
1577     0x40, 0x3F,
1578 };
1579
1580 static const unsigned char non_minimal_3[] = {
1581     0x80, 0x00, 0x00, 0x00,
1582 };
1583
1584 static const unsigned char non_minimal_4[] = {
1585     0x80, 0x00, 0x3F, 0xFF,
1586 };
1587
1588 static const unsigned char non_minimal_5[] = {
1589     0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
1590 };
1591
1592 static const unsigned char non_minimal_6[] = {
1593     0xC0, 0x00, 0x00, 0x00, 0x3F, 0xFF, 0xFF, 0xFF
1594 };
1595
1596 static const unsigned char *const non_minimal[] = {
1597     non_minimal_1,
1598     non_minimal_2,
1599     non_minimal_3,
1600     non_minimal_4,
1601     non_minimal_5,
1602     non_minimal_6,
1603 };
1604
1605 static const size_t non_minimal_len[] = {
1606     OSSL_NELEM(non_minimal_1),
1607     OSSL_NELEM(non_minimal_2),
1608     OSSL_NELEM(non_minimal_3),
1609     OSSL_NELEM(non_minimal_4),
1610     OSSL_NELEM(non_minimal_5),
1611     OSSL_NELEM(non_minimal_6),
1612 };
1613
1614 static int test_wire_minimal(int idx)
1615 {
1616     int testresult = 0;
1617     int is_minimal;
1618     uint64_t frame_type;
1619     PACKET pkt;
1620
1621     if (!TEST_true(PACKET_buf_init(&pkt, non_minimal[idx],
1622                                    non_minimal_len[idx])))
1623         goto err;
1624
1625     if (!TEST_true(ossl_quic_wire_peek_frame_header(&pkt, &frame_type,
1626                                                     &is_minimal)))
1627         goto err;
1628
1629     if (!TEST_false(is_minimal))
1630         goto err;
1631
1632     testresult = 1;
1633 err:
1634     return testresult;
1635 }
1636
1637 int setup_tests(void)
1638 {
1639     ADD_ALL_TESTS(test_wire_encode,     OSSL_NELEM(encode_cases));
1640     ADD_ALL_TESTS(test_wire_ack,        OSSL_NELEM(ack_cases));
1641     ADD_ALL_TESTS(test_wire_pkt_hdr_pn, OSSL_NELEM(pn_tests));
1642     ADD_TEST(test_wire_retry_integrity_tag);
1643     ADD_ALL_TESTS(test_wire_minimal,    OSSL_NELEM(non_minimal_len));
1644     return 1;
1645 }