1 /* 2 * Copyright 2022-2026 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, 158 0x7d, /* ACK Delay */ 159 1, /* ACK Range Count */ 160 10, /* First ACK Range */ 161 162 8, /* Gap */ 163 10, /* Length */ 164 165 0x3c, /* ECT0 Count */ 166 0x40, 167 0x46, /* ECT1 Count */ 168 0x40, 169 0x50, /* ECNCE Count */ 170 }; 171 172 /* 4. RESET_STREAM */ 173 static const OSSL_QUIC_FRAME_RESET_STREAM encode_case_4_f = { 174 0x1234, 0x9781, 0x11717 175 }; 176 177 static int encode_case_4_enc(WPACKET *pkt) 178 { 179 if (!TEST_int_eq(ossl_quic_wire_encode_frame_reset_stream(pkt, 180 &encode_case_4_f), 181 1)) 182 return 0; 183 184 return 1; 185 } 186 187 static int encode_case_4_dec(PACKET *pkt, ossl_ssize_t fail) 188 { 189 OSSL_QUIC_FRAME_RESET_STREAM f = { 0 }; 190 191 if (!TEST_int_eq(ossl_quic_wire_decode_frame_reset_stream(pkt, &f), fail < 0)) 192 return 0; 193 194 if (fail >= 0) 195 return 1; 196 197 if (!TEST_mem_eq(&f, sizeof(f), &encode_case_4_f, sizeof(encode_case_4_f))) 198 return 0; 199 200 return 1; 201 } 202 203 static const unsigned char encode_case_4_expect[] = { 204 0x04, /* Type */ 205 0x52, 206 0x34, /* Stream ID */ 207 0x80, 208 0x00, 209 0x97, 210 0x81, /* App Error Code */ 211 0x80, 212 0x01, 213 0x17, 214 0x17, /* Final Size */ 215 }; 216 217 /* 5. STOP_SENDING */ 218 static const OSSL_QUIC_FRAME_STOP_SENDING encode_case_5_f = { 219 0x1234, 0x9781 220 }; 221 222 static int encode_case_5_enc(WPACKET *pkt) 223 { 224 if (!TEST_int_eq(ossl_quic_wire_encode_frame_stop_sending(pkt, 225 &encode_case_5_f), 226 1)) 227 return 0; 228 229 return 1; 230 } 231 232 static int encode_case_5_dec(PACKET *pkt, ossl_ssize_t fail) 233 { 234 OSSL_QUIC_FRAME_STOP_SENDING f = { 0 }; 235 236 if (!TEST_int_eq(ossl_quic_wire_decode_frame_stop_sending(pkt, &f), fail < 0)) 237 return 0; 238 239 if (fail >= 0) 240 return 1; 241 242 if (!TEST_mem_eq(&f, sizeof(f), &encode_case_5_f, sizeof(encode_case_5_f))) 243 return 0; 244 245 return 1; 246 } 247 248 static const unsigned char encode_case_5_expect[] = { 249 0x05, /* Type */ 250 0x52, 0x34, /* Stream ID */ 251 0x80, 0x00, 0x97, 0x81 /* App Error Code */ 252 }; 253 254 /* 6. CRYPTO */ 255 static const unsigned char encode_case_6_data[] = { 256 93, 18, 17, 102, 33 257 }; 258 259 static const OSSL_QUIC_FRAME_CRYPTO encode_case_6_f = { 260 0x1234, sizeof(encode_case_6_data), encode_case_6_data 261 }; 262 263 static int encode_case_6_enc(WPACKET *pkt) 264 { 265 if (!TEST_ptr(ossl_quic_wire_encode_frame_crypto(pkt, 266 &encode_case_6_f))) 267 return 0; 268 269 return 1; 270 } 271 272 static int encode_case_6_dec(PACKET *pkt, ossl_ssize_t fail) 273 { 274 OSSL_QUIC_FRAME_CRYPTO f = { 0 }; 275 276 if (!TEST_int_eq(ossl_quic_wire_decode_frame_crypto(pkt, 0, &f), fail < 0)) 277 return 0; 278 279 if (fail >= 0) 280 return 1; 281 282 if (!TEST_uint64_t_eq(f.offset, 0x1234)) 283 return 0; 284 285 if (!TEST_uint64_t_le(f.len, SIZE_MAX)) 286 return 0; 287 288 if (!TEST_mem_eq(f.data, (size_t)f.len, 289 encode_case_6_data, sizeof(encode_case_6_data))) 290 return 0; 291 292 return 1; 293 } 294 295 static const unsigned char encode_case_6_expect[] = { 296 0x06, /* Type */ 297 0x52, 0x34, /* Offset */ 298 0x05, /* Length */ 299 93, 18, 17, 102, 33 /* Data */ 300 }; 301 302 /* 7. NEW_TOKEN */ 303 static const unsigned char encode_case_7_token[] = { 304 0xde, 0x06, 0xcb, 0x76, 0x5d, 0xb1, 0xa7, 0x71, 305 0x78, 0x09, 0xbb, 0xe8, 0x50, 0x19, 0x12, 0x9a 306 }; 307 308 static int encode_case_7_enc(WPACKET *pkt) 309 { 310 if (!TEST_int_eq(ossl_quic_wire_encode_frame_new_token(pkt, 311 encode_case_7_token, 312 sizeof(encode_case_7_token)), 313 1)) 314 return 0; 315 316 return 1; 317 } 318 319 static int encode_case_7_dec(PACKET *pkt, ossl_ssize_t fail) 320 { 321 const unsigned char *token = NULL; 322 size_t token_len = 0; 323 324 if (!TEST_int_eq(ossl_quic_wire_decode_frame_new_token(pkt, 325 &token, 326 &token_len), 327 fail < 0)) 328 return 0; 329 330 if (fail >= 0) 331 return 1; 332 333 if (!TEST_mem_eq(token, token_len, 334 encode_case_7_token, sizeof(encode_case_7_token))) 335 return 0; 336 337 return 1; 338 } 339 340 static const unsigned char encode_case_7_expect[] = { 341 0x07, /* Type */ 342 0x10, /* Length */ 343 0xde, 0x06, 0xcb, 0x76, 0x5d, 0xb1, 0xa7, 0x71, /* Token */ 344 0x78, 0x09, 0xbb, 0xe8, 0x50, 0x19, 0x12, 0x9a 345 }; 346 347 /* 8. STREAM (no length, no offset, no fin) */ 348 static const unsigned char encode_case_8_data[] = { 349 0xde, 0x06, 0xcb, 0x76, 0x5d 350 }; 351 static const OSSL_QUIC_FRAME_STREAM encode_case_8_f = { 352 0x1234, 0, 5, encode_case_8_data, 0, 0 353 }; 354 355 static int encode_case_8_enc(WPACKET *pkt) 356 { 357 if (!TEST_ptr(ossl_quic_wire_encode_frame_stream(pkt, 358 &encode_case_8_f))) 359 return 0; 360 361 return 1; 362 } 363 364 static int encode_case_8_dec(PACKET *pkt, ossl_ssize_t fail) 365 { 366 OSSL_QUIC_FRAME_STREAM f = { 0 }; 367 368 if (fail >= 3) 369 /* 370 * This case uses implicit length signalling so truncation will not 371 * cause it to fail unless the header (which is 3 bytes) is truncated. 372 */ 373 return 1; 374 375 if (!TEST_int_eq(ossl_quic_wire_decode_frame_stream(pkt, 0, &f), fail < 0)) 376 return 0; 377 378 if (fail >= 0) 379 return 1; 380 381 if (!TEST_uint64_t_le(f.len, SIZE_MAX)) 382 return 0; 383 384 if (!TEST_mem_eq(f.data, (size_t)f.len, 385 encode_case_8_data, sizeof(encode_case_8_data))) 386 return 0; 387 388 if (!TEST_uint64_t_eq(f.stream_id, 0x1234)) 389 return 0; 390 391 if (!TEST_uint64_t_eq(f.offset, 0)) 392 return 0; 393 394 if (!TEST_int_eq(f.has_explicit_len, 0)) 395 return 0; 396 397 if (!TEST_int_eq(f.is_fin, 0)) 398 return 0; 399 400 return 1; 401 } 402 403 static const unsigned char encode_case_8_expect[] = { 404 0x08, /* Type (OFF=0, LEN=0, FIN=0) */ 405 0x52, 0x34, /* Stream ID */ 406 0xde, 0x06, 0xcb, 0x76, 0x5d /* Data */ 407 }; 408 409 /* 9. STREAM (length, offset, fin) */ 410 static const unsigned char encode_case_9_data[] = { 411 0xde, 0x06, 0xcb, 0x76, 0x5d 412 }; 413 static const OSSL_QUIC_FRAME_STREAM encode_case_9_f = { 414 0x1234, 0x39, 5, encode_case_9_data, 1, 1 415 }; 416 417 static int encode_case_9_enc(WPACKET *pkt) 418 { 419 if (!TEST_ptr(ossl_quic_wire_encode_frame_stream(pkt, 420 &encode_case_9_f))) 421 return 0; 422 423 return 1; 424 } 425 426 static int encode_case_9_dec(PACKET *pkt, ossl_ssize_t fail) 427 { 428 OSSL_QUIC_FRAME_STREAM f = { 0 }; 429 430 if (!TEST_int_eq(ossl_quic_wire_decode_frame_stream(pkt, 0, &f), fail < 0)) 431 return 0; 432 433 if (fail >= 0) 434 return 1; 435 436 if (!TEST_uint64_t_le(f.len, SIZE_MAX)) 437 return 0; 438 439 if (!TEST_mem_eq(f.data, (size_t)f.len, 440 encode_case_9_data, sizeof(encode_case_9_data))) 441 return 0; 442 443 if (!TEST_uint64_t_eq(f.stream_id, 0x1234)) 444 return 0; 445 446 if (!TEST_uint64_t_eq(f.offset, 0x39)) 447 return 0; 448 449 if (!TEST_int_eq(f.has_explicit_len, 1)) 450 return 0; 451 452 if (!TEST_int_eq(f.is_fin, 1)) 453 return 0; 454 455 return 1; 456 } 457 458 static const unsigned char encode_case_9_expect[] = { 459 0x0f, /* Type (OFF=1, LEN=1, FIN=1) */ 460 0x52, 0x34, /* Stream ID */ 461 0x39, /* Offset */ 462 0x05, /* Length */ 463 0xde, 0x06, 0xcb, 0x76, 0x5d /* Data */ 464 }; 465 466 /* 10. MAX_DATA */ 467 static int encode_case_10_enc(WPACKET *pkt) 468 { 469 if (!TEST_int_eq(ossl_quic_wire_encode_frame_max_data(pkt, 0x1234), 1)) 470 return 0; 471 472 return 1; 473 } 474 475 static int encode_case_10_dec(PACKET *pkt, ossl_ssize_t fail) 476 { 477 uint64_t max_data = 0; 478 479 if (!TEST_int_eq(ossl_quic_wire_decode_frame_max_data(pkt, &max_data), fail < 0)) 480 return 0; 481 482 if (fail >= 0) 483 return 1; 484 485 if (!TEST_uint64_t_eq(max_data, 0x1234)) 486 return 0; 487 488 return 1; 489 } 490 491 static const unsigned char encode_case_10_expect[] = { 492 0x10, /* Type */ 493 0x52, 494 0x34, /* Max Data */ 495 }; 496 497 /* 11. MAX_STREAM_DATA */ 498 static int encode_case_11_enc(WPACKET *pkt) 499 { 500 if (!TEST_int_eq(ossl_quic_wire_encode_frame_max_stream_data(pkt, 501 0x1234, 502 0x9781), 503 1)) 504 return 0; 505 506 return 1; 507 } 508 509 static int encode_case_11_dec(PACKET *pkt, ossl_ssize_t fail) 510 { 511 uint64_t stream_id = 0, max_data = 0; 512 513 if (!TEST_int_eq(ossl_quic_wire_decode_frame_max_stream_data(pkt, 514 &stream_id, 515 &max_data), 516 fail < 0)) 517 return 0; 518 519 if (fail >= 0) 520 return 1; 521 522 if (!TEST_uint64_t_eq(stream_id, 0x1234)) 523 return 0; 524 525 if (!TEST_uint64_t_eq(max_data, 0x9781)) 526 return 0; 527 528 return 1; 529 } 530 531 static const unsigned char encode_case_11_expect[] = { 532 0x11, /* Type */ 533 0x52, 534 0x34, /* Stream ID */ 535 0x80, 536 0x00, 537 0x97, 538 0x81, /* Max Data */ 539 }; 540 541 /* 12. MAX_STREAMS */ 542 static int encode_case_12_enc(WPACKET *pkt) 543 { 544 if (!TEST_int_eq(ossl_quic_wire_encode_frame_max_streams(pkt, 0, 0x1234), 1)) 545 return 0; 546 547 if (!TEST_int_eq(ossl_quic_wire_encode_frame_max_streams(pkt, 1, 0x9781), 1)) 548 return 0; 549 550 return 1; 551 } 552 553 static int encode_case_12_dec(PACKET *pkt, ossl_ssize_t fail) 554 { 555 uint64_t max_streams_1 = 0, max_streams_2 = 0, 556 frame_type_1 = 0, frame_type_2 = 0; 557 int is_minimal = 1, success_if; 558 559 success_if = (fail < 0 || fail >= 1); 560 if (!TEST_int_eq(ossl_quic_wire_peek_frame_header(pkt, &frame_type_1, 561 &is_minimal), 562 success_if)) 563 return 0; 564 565 if (!TEST_true(!success_if || is_minimal)) 566 return 0; 567 568 success_if = (fail < 0 || fail >= 3); 569 if (!TEST_int_eq(ossl_quic_wire_decode_frame_max_streams(pkt, 570 &max_streams_1), 571 success_if)) 572 return 0; 573 574 success_if = (fail < 0 || fail >= 4); 575 if (!TEST_int_eq(ossl_quic_wire_peek_frame_header(pkt, &frame_type_2, 576 &is_minimal), 577 success_if)) 578 return 0; 579 580 if (!TEST_true(!success_if || is_minimal)) 581 return 0; 582 583 success_if = (fail < 0); 584 if (!TEST_int_eq(ossl_quic_wire_decode_frame_max_streams(pkt, 585 &max_streams_2), 586 success_if)) 587 return 0; 588 589 if ((fail < 0 || fail >= 3) 590 && !TEST_uint64_t_eq(frame_type_1, OSSL_QUIC_FRAME_TYPE_MAX_STREAMS_BIDI)) 591 return 0; 592 593 if ((fail < 0 || fail >= 3) 594 && !TEST_uint64_t_eq(max_streams_1, 0x1234)) 595 return 0; 596 597 if ((fail < 0 || fail >= 8) 598 && !TEST_uint64_t_eq(frame_type_2, OSSL_QUIC_FRAME_TYPE_MAX_STREAMS_UNI)) 599 return 0; 600 601 if ((fail < 0 || fail >= 8) 602 && !TEST_uint64_t_eq(max_streams_2, 0x9781)) 603 return 0; 604 605 return 1; 606 } 607 608 static const unsigned char encode_case_12_expect[] = { 609 0x12, /* Type (MAX_STREAMS Bidirectional) */ 610 0x52, 611 0x34, /* Max Streams */ 612 0x13, /* Type (MAX_STREAMS Unidirectional) */ 613 0x80, 614 0x00, 615 0x97, 616 0x81, /* Max Streams */ 617 }; 618 619 /* 13. DATA_BLOCKED */ 620 static int encode_case_13_enc(WPACKET *pkt) 621 { 622 if (!TEST_int_eq(ossl_quic_wire_encode_frame_data_blocked(pkt, 0x1234), 1)) 623 return 0; 624 625 return 1; 626 } 627 628 static int encode_case_13_dec(PACKET *pkt, ossl_ssize_t fail) 629 { 630 uint64_t max_data = 0; 631 632 if (!TEST_int_eq(ossl_quic_wire_decode_frame_data_blocked(pkt, 633 &max_data), 634 fail < 0)) 635 return 0; 636 637 if (fail >= 0) 638 return 1; 639 640 if (!TEST_uint64_t_eq(max_data, 0x1234)) 641 return 0; 642 643 return 1; 644 } 645 646 static const unsigned char encode_case_13_expect[] = { 647 0x14, /* Type */ 648 0x52, 649 0x34, /* Max Data */ 650 }; 651 652 /* 14. STREAM_DATA_BLOCKED */ 653 static int encode_case_14_enc(WPACKET *pkt) 654 { 655 if (!TEST_int_eq(ossl_quic_wire_encode_frame_stream_data_blocked(pkt, 656 0x1234, 657 0x9781), 658 1)) 659 return 0; 660 661 return 1; 662 } 663 664 static int encode_case_14_dec(PACKET *pkt, ossl_ssize_t fail) 665 { 666 uint64_t stream_id = 0, max_data = 0; 667 668 if (!TEST_int_eq(ossl_quic_wire_decode_frame_stream_data_blocked(pkt, 669 &stream_id, 670 &max_data), 671 fail < 0)) 672 return 0; 673 674 if (fail >= 0) 675 return 1; 676 677 if (!TEST_uint64_t_eq(stream_id, 0x1234)) 678 return 0; 679 680 if (!TEST_uint64_t_eq(max_data, 0x9781)) 681 return 0; 682 683 return 1; 684 } 685 686 static const unsigned char encode_case_14_expect[] = { 687 0x15, /* Type */ 688 0x52, 689 0x34, /* Stream ID */ 690 0x80, 691 0x00, 692 0x97, 693 0x81, /* Max Data */ 694 }; 695 696 /* 15. STREAMS_BLOCKED */ 697 static int encode_case_15_enc(WPACKET *pkt) 698 { 699 if (!TEST_int_eq(ossl_quic_wire_encode_frame_streams_blocked(pkt, 0, 0x1234), 1)) 700 return 0; 701 702 if (!TEST_int_eq(ossl_quic_wire_encode_frame_streams_blocked(pkt, 1, 0x9781), 1)) 703 return 0; 704 705 return 1; 706 } 707 708 static int encode_case_15_dec(PACKET *pkt, ossl_ssize_t fail) 709 { 710 uint64_t max_streams_1 = 0, max_streams_2 = 0, 711 frame_type_1 = 0, frame_type_2 = 0; 712 int is_minimal = 1, success_if; 713 714 success_if = (fail < 0 || fail >= 1); 715 if (!TEST_int_eq(ossl_quic_wire_peek_frame_header(pkt, &frame_type_1, 716 &is_minimal), 717 success_if)) 718 return 0; 719 720 if (!TEST_true(!success_if || is_minimal)) 721 return 0; 722 723 success_if = (fail < 0 || fail >= 3); 724 if (!TEST_int_eq(ossl_quic_wire_decode_frame_streams_blocked(pkt, 725 &max_streams_1), 726 success_if)) 727 return 0; 728 729 success_if = (fail < 0 || fail >= 4); 730 if (!TEST_int_eq(ossl_quic_wire_peek_frame_header(pkt, &frame_type_2, 731 &is_minimal), 732 success_if)) 733 return 0; 734 735 if (!TEST_true(!success_if || is_minimal)) 736 return 0; 737 738 if (!TEST_int_eq(ossl_quic_wire_decode_frame_streams_blocked(pkt, 739 &max_streams_2), 740 fail < 0 || fail >= 8)) 741 return 0; 742 743 if ((fail < 0 || fail >= 1) 744 && !TEST_uint64_t_eq(frame_type_1, OSSL_QUIC_FRAME_TYPE_STREAMS_BLOCKED_BIDI)) 745 return 0; 746 747 if ((fail < 0 || fail >= 3) 748 && !TEST_uint64_t_eq(max_streams_1, 0x1234)) 749 return 0; 750 751 if ((fail < 0 || fail >= 4) 752 && !TEST_uint64_t_eq(frame_type_2, OSSL_QUIC_FRAME_TYPE_STREAMS_BLOCKED_UNI)) 753 return 0; 754 755 if ((fail < 0 || fail >= 8) 756 && !TEST_uint64_t_eq(max_streams_2, 0x9781)) 757 return 0; 758 759 return 1; 760 } 761 762 static const unsigned char encode_case_15_expect[] = { 763 0x16, /* Type (STREAMS_BLOCKED Bidirectional) */ 764 0x52, 765 0x34, /* Max Streams */ 766 0x17, /* Type (STREAMS_BLOCKED Unidirectional) */ 767 0x80, 768 0x00, 769 0x97, 770 0x81, /* Max Streams */ 771 }; 772 773 /* 16. NEW_CONNECTION_ID */ 774 static const unsigned char encode_case_16_conn_id[] = { 775 0x33, 0x44, 0x55, 0x66 776 }; 777 778 static const OSSL_QUIC_FRAME_NEW_CONN_ID encode_case_16_f = { 779 0x9781, 780 0x1234, 781 { 0x4, 782 { 0x33, 0x44, 0x55, 0x66 } }, 783 { { 0xde, 0x06, 0xcb, 0x76, 0x5d, 0xb1, 0xa7, 0x71, 784 0x78, 0x09, 0xbb, 0xe8, 0x50, 0x19, 0x12, 0x9a } } 785 }; 786 787 static int encode_case_16_enc(WPACKET *pkt) 788 { 789 if (!TEST_int_eq(ossl_quic_wire_encode_frame_new_conn_id(pkt, 790 &encode_case_16_f), 791 1)) 792 return 0; 793 794 return 1; 795 } 796 797 static int encode_case_16_dec(PACKET *pkt, ossl_ssize_t fail) 798 { 799 OSSL_QUIC_FRAME_NEW_CONN_ID f = { 0 }; 800 801 if (!TEST_int_eq(ossl_quic_wire_decode_frame_new_conn_id(pkt, &f), fail < 0)) 802 return 0; 803 804 if (fail >= 0) 805 return 1; 806 807 if (!TEST_uint64_t_eq(f.seq_num, 0x9781)) 808 return 0; 809 810 if (!TEST_uint64_t_eq(f.retire_prior_to, 0x1234)) 811 return 0; 812 813 if (!TEST_uint64_t_eq(f.conn_id.id_len, sizeof(encode_case_16_conn_id))) 814 return 0; 815 816 if (!TEST_mem_eq(f.conn_id.id, f.conn_id.id_len, 817 encode_case_16_conn_id, sizeof(encode_case_16_conn_id))) 818 return 0; 819 820 if (!TEST_mem_eq(f.stateless_reset.token, 821 sizeof(f.stateless_reset.token), 822 encode_case_16_f.stateless_reset.token, 823 sizeof(encode_case_16_f.stateless_reset.token))) 824 return 0; 825 826 return 1; 827 } 828 829 static const unsigned char encode_case_16_expect[] = { 830 0x18, /* Type */ 831 0x80, 0x00, 0x97, 0x81, /* Sequence Number */ 832 0x52, 0x34, /* Retire Prior To */ 833 0x04, /* Connection ID Length */ 834 0x33, 0x44, 0x55, 0x66, /* Connection ID */ 835 0xde, 0x06, 0xcb, 0x76, 0x5d, 0xb1, 0xa7, 0x71, /* Stateless Reset Token */ 836 0x78, 0x09, 0xbb, 0xe8, 0x50, 0x19, 0x12, 0x9a 837 }; 838 839 /* 16b. NEW_CONNECTION_ID seq_num < retire_prior_to */ 840 static const OSSL_QUIC_FRAME_NEW_CONN_ID encode_case_16b_f = { 841 0x1234, 842 0x9781, 843 { 0x4, 844 { 0x33, 0x44, 0x55, 0x66 } }, 845 { { 0xde, 0x06, 0xcb, 0x76, 0x5d, 0xb1, 0xa7, 0x71, 846 0x78, 0x09, 0xbb, 0xe8, 0x50, 0x19, 0x12, 0x9a } } 847 }; 848 849 static int encode_case_16b_enc(WPACKET *pkt) 850 { 851 if (!TEST_int_eq(ossl_quic_wire_encode_frame_new_conn_id(pkt, 852 &encode_case_16b_f), 853 1)) 854 return 0; 855 856 return 1; 857 } 858 859 static int encode_case_16b_dec(PACKET *pkt, ossl_ssize_t fail) 860 { 861 OSSL_QUIC_FRAME_NEW_CONN_ID f = { 0 }; 862 863 if (!TEST_int_eq(ossl_quic_wire_decode_frame_new_conn_id(pkt, &f), 0)) 864 return 0; 865 866 if (!TEST_true(PACKET_forward(pkt, PACKET_remaining(pkt)))) 867 return 0; 868 869 return 1; 870 } 871 872 static const unsigned char encode_case_16b_expect[] = { 873 0x18, /* Type */ 874 0x52, 0x34, /* Sequence Number */ 875 0x80, 0x00, 0x97, 0x81, /* Retire Prior To */ 876 0x04, /* Connection ID Length */ 877 0x33, 0x44, 0x55, 0x66, /* Connection ID */ 878 0xde, 0x06, 0xcb, 0x76, 0x5d, 0xb1, 0xa7, 0x71, /* Stateless Reset Token */ 879 0x78, 0x09, 0xbb, 0xe8, 0x50, 0x19, 0x12, 0x9a 880 }; 881 882 /* 17. RETIRE_CONNECTION_ID */ 883 static int encode_case_17_enc(WPACKET *pkt) 884 { 885 if (!TEST_int_eq(ossl_quic_wire_encode_frame_retire_conn_id(pkt, 0x1234), 1)) 886 return 0; 887 888 return 1; 889 } 890 891 static int encode_case_17_dec(PACKET *pkt, ossl_ssize_t fail) 892 { 893 uint64_t seq_num = 0; 894 895 if (!TEST_int_eq(ossl_quic_wire_decode_frame_retire_conn_id(pkt, &seq_num), fail < 0)) 896 return 0; 897 898 if (fail >= 0) 899 return 1; 900 901 if (!TEST_uint64_t_eq(seq_num, 0x1234)) 902 return 0; 903 904 return 1; 905 } 906 907 static const unsigned char encode_case_17_expect[] = { 908 0x19, /* Type */ 909 0x52, 910 0x34, /* Seq Num */ 911 }; 912 913 /* 18. PATH_CHALLENGE */ 914 static const uint64_t encode_case_18_data 915 = (((uint64_t)0x5f4b12) << 40) | (uint64_t)0x731834UL; 916 917 static int encode_case_18_enc(WPACKET *pkt) 918 { 919 if (!TEST_int_eq(ossl_quic_wire_encode_frame_path_challenge(pkt, 920 encode_case_18_data), 921 1)) 922 return 0; 923 924 return 1; 925 } 926 927 static int encode_case_18_dec(PACKET *pkt, ossl_ssize_t fail) 928 { 929 uint64_t challenge = 0; 930 931 if (!TEST_int_eq(ossl_quic_wire_decode_frame_path_challenge(pkt, &challenge), fail < 0)) 932 return 0; 933 934 if (fail >= 0) 935 return 1; 936 937 if (!TEST_uint64_t_eq(challenge, encode_case_18_data)) 938 return 0; 939 940 return 1; 941 } 942 943 static const unsigned char encode_case_18_expect[] = { 944 0x1A, /* Type */ 945 0x5f, 946 0x4b, 947 0x12, 948 0x00, 949 0x00, 950 0x73, 951 0x18, 952 0x34, /* Data */ 953 }; 954 955 /* 19. PATH_RESPONSE */ 956 static const uint64_t encode_case_19_data 957 = (((uint64_t)0x5f4b12) << 40) | (uint64_t)0x731834UL; 958 959 static int encode_case_19_enc(WPACKET *pkt) 960 { 961 if (!TEST_int_eq(ossl_quic_wire_encode_frame_path_response(pkt, 962 encode_case_19_data), 963 1)) 964 return 0; 965 966 return 1; 967 } 968 969 static int encode_case_19_dec(PACKET *pkt, ossl_ssize_t fail) 970 { 971 uint64_t challenge = 0; 972 973 if (!TEST_int_eq(ossl_quic_wire_decode_frame_path_response(pkt, &challenge), fail < 0)) 974 return 0; 975 976 if (fail >= 0) 977 return 1; 978 979 if (!TEST_uint64_t_eq(challenge, encode_case_19_data)) 980 return 0; 981 982 return 1; 983 } 984 985 static const unsigned char encode_case_19_expect[] = { 986 0x1B, /* Type */ 987 0x5f, 988 0x4b, 989 0x12, 990 0x00, 991 0x00, 992 0x73, 993 0x18, 994 0x34, /* Data */ 995 }; 996 997 /* 20. CONNECTION_CLOSE (transport) */ 998 static const char encode_case_20_reason[] = { 999 /* "reason for closure" */ 1000 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x20, 0x66, 0x6f, 1001 0x72, 0x20, 0x63, 0x6c, 0x6f, 0x73, 0x75, 0x72, 0x65 1002 }; 1003 1004 static const OSSL_QUIC_FRAME_CONN_CLOSE encode_case_20_f = { 1005 0, 1006 0x1234, 1007 0x9781, 1008 (char *)encode_case_20_reason, 1009 sizeof(encode_case_20_reason) 1010 }; 1011 1012 static int encode_case_20_enc(WPACKET *pkt) 1013 { 1014 if (!TEST_int_eq(ossl_quic_wire_encode_frame_conn_close(pkt, 1015 &encode_case_20_f), 1016 1)) 1017 return 0; 1018 1019 return 1; 1020 } 1021 1022 static int encode_case_20_dec(PACKET *pkt, ossl_ssize_t fail) 1023 { 1024 OSSL_QUIC_FRAME_CONN_CLOSE f = { 0 }; 1025 1026 if (!TEST_int_eq(ossl_quic_wire_decode_frame_conn_close(pkt, &f), fail < 0)) 1027 return 0; 1028 1029 if (fail >= 0) 1030 return 1; 1031 1032 if (!TEST_int_eq(f.is_app, 0)) 1033 return 0; 1034 1035 if (!TEST_uint64_t_eq(f.error_code, 0x1234)) 1036 return 0; 1037 1038 if (!TEST_uint64_t_eq(f.frame_type, 0x9781)) 1039 return 0; 1040 1041 if (!TEST_size_t_eq(f.reason_len, 18)) 1042 return 0; 1043 1044 if (!TEST_mem_eq(f.reason, f.reason_len, 1045 encode_case_20_f.reason, encode_case_20_f.reason_len)) 1046 return 0; 1047 1048 return 1; 1049 } 1050 1051 static const unsigned char encode_case_20_expect[] = { 1052 0x1C, /* Type */ 1053 0x52, 0x34, /* Sequence Number */ 1054 0x80, 0x00, 0x97, 0x81, /* Frame Type */ 1055 0x12, /* Reason Length */ 1056 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x20, 0x66, 0x6f, /* Reason */ 1057 0x72, 0x20, 0x63, 0x6c, 0x6f, 0x73, 0x75, 0x72, 0x65 1058 }; 1059 1060 /* 21. HANDSHAKE_DONE */ 1061 static int encode_case_21_enc(WPACKET *pkt) 1062 { 1063 1064 if (!TEST_int_eq(ossl_quic_wire_encode_frame_handshake_done(pkt), 1)) 1065 return 0; 1066 1067 return 1; 1068 } 1069 1070 static int encode_case_21_dec(PACKET *pkt, ossl_ssize_t fail) 1071 { 1072 1073 if (!TEST_int_eq(ossl_quic_wire_decode_frame_handshake_done(pkt), fail < 0)) 1074 return 0; 1075 1076 return 1; 1077 } 1078 1079 static const unsigned char encode_case_21_expect[] = { 1080 0x1E 1081 }; 1082 1083 /* 22. Buffer Transport Parameter */ 1084 static const unsigned char encode_case_22_data[] = { 0x55, 0x77, 0x32, 0x46, 0x99 }; 1085 1086 static int encode_case_22_enc(WPACKET *pkt) 1087 { 1088 unsigned char *p; 1089 1090 if (!TEST_ptr(ossl_quic_wire_encode_transport_param_bytes(pkt, 0x1234, 1091 encode_case_22_data, 1092 sizeof(encode_case_22_data)))) 1093 return 0; 1094 1095 if (!TEST_ptr(p = ossl_quic_wire_encode_transport_param_bytes(pkt, 0x9781, 1096 NULL, 2))) 1097 return 0; 1098 1099 p[0] = 0x33; 1100 p[1] = 0x44; 1101 1102 return 1; 1103 } 1104 1105 static int encode_case_22_dec(PACKET *pkt, ossl_ssize_t fail) 1106 { 1107 uint64_t id = 0; 1108 size_t len = 0; 1109 const unsigned char *p; 1110 static const unsigned char data[] = { 0x33, 0x44 }; 1111 1112 if (!TEST_int_eq(ossl_quic_wire_peek_transport_param(pkt, &id), 1113 fail < 0 || fail >= 2)) 1114 return 0; 1115 1116 if ((fail < 0 || fail >= 2) 1117 && !TEST_uint64_t_eq(id, 0x1234)) 1118 return 0; 1119 1120 id = 0; 1121 1122 p = ossl_quic_wire_decode_transport_param_bytes(pkt, &id, &len); 1123 if (fail < 0 || fail >= 8) { 1124 if (!TEST_ptr(p)) 1125 return 0; 1126 } else { 1127 if (!TEST_ptr_null(p)) 1128 return 0; 1129 } 1130 1131 if ((fail < 0 || fail >= 8) 1132 && !TEST_uint64_t_eq(id, 0x1234)) 1133 return 0; 1134 1135 if ((fail < 0 || fail >= 8) 1136 && !TEST_mem_eq(p, len, encode_case_22_data, sizeof(encode_case_22_data))) 1137 return 0; 1138 1139 if ((fail < 0 || fail >= 8) 1140 && !TEST_int_eq(ossl_quic_wire_peek_transport_param(pkt, &id), 1141 fail < 0 || fail >= 12)) 1142 return 0; 1143 1144 if ((fail < 0 || fail >= 12) 1145 && !TEST_uint64_t_eq(id, 0x9781)) 1146 return 0; 1147 1148 id = 0; 1149 1150 p = ossl_quic_wire_decode_transport_param_bytes(pkt, &id, &len); 1151 if (fail < 0 || fail >= 15) { 1152 if (!TEST_ptr(p)) 1153 return 0; 1154 } else { 1155 if (!TEST_ptr_null(p)) 1156 return 0; 1157 } 1158 1159 if ((fail < 0 || fail >= 15) 1160 && !TEST_uint64_t_eq(id, 0x9781)) 1161 return 0; 1162 1163 if ((fail < 0 || fail >= 15) 1164 && !TEST_mem_eq(p, len, data, sizeof(data))) 1165 return 0; 1166 1167 return 1; 1168 } 1169 1170 static const unsigned char encode_case_22_expect[] = { 1171 0x52, 0x34, /* ID */ 1172 0x05, /* Length */ 1173 0x55, 0x77, 0x32, 0x46, 0x99, /* Data */ 1174 1175 0x80, 0x00, 0x97, 0x81, /* ID */ 1176 0x02, /* Length */ 1177 0x33, 0x44 /* Data */ 1178 }; 1179 1180 /* 23. Integer Transport Parameter */ 1181 static int encode_case_23_enc(WPACKET *pkt) 1182 { 1183 if (!TEST_int_eq(ossl_quic_wire_encode_transport_param_int(pkt, 0x1234, 0x9781), 1)) 1184 return 0; 1185 1186 if (!TEST_int_eq(ossl_quic_wire_encode_transport_param_int(pkt, 0x2233, 0x4545), 1)) 1187 return 0; 1188 1189 return 1; 1190 } 1191 1192 static int encode_case_23_dec(PACKET *pkt, ossl_ssize_t fail) 1193 { 1194 uint64_t id = 0, value = 0; 1195 1196 if (!TEST_int_eq(ossl_quic_wire_decode_transport_param_int(pkt, 1197 &id, &value), 1198 fail < 0 || fail >= 7)) 1199 return 0; 1200 1201 if ((fail < 0 || fail >= 7) 1202 && !TEST_uint64_t_eq(id, 0x1234)) 1203 return 0; 1204 1205 if ((fail < 0 || fail >= 7) 1206 && !TEST_uint64_t_eq(value, 0x9781)) 1207 return 0; 1208 1209 if (!TEST_int_eq(ossl_quic_wire_decode_transport_param_int(pkt, 1210 &id, &value), 1211 fail < 0 || fail >= 14)) 1212 return 0; 1213 1214 if ((fail < 0 || fail >= 14) 1215 && !TEST_uint64_t_eq(id, 0x2233)) 1216 return 0; 1217 1218 if ((fail < 0 || fail >= 14) 1219 && !TEST_uint64_t_eq(value, 0x4545)) 1220 return 0; 1221 1222 return 1; 1223 } 1224 1225 static const unsigned char encode_case_23_expect[] = { 1226 0x52, 1227 0x34, 1228 0x04, 1229 0x80, 1230 0x00, 1231 0x97, 1232 0x81, 1233 1234 0x62, 1235 0x33, 1236 0x04, 1237 0x80, 1238 0x00, 1239 0x45, 1240 0x45, 1241 }; 1242 1243 #define ENCODE_CASE(n) \ 1244 { \ 1245 encode_case_##n##_enc, \ 1246 encode_case_##n##_expect, \ 1247 OSSL_NELEM(encode_case_##n##_expect), \ 1248 encode_case_##n##_dec \ 1249 }, 1250 1251 static const struct encode_test_case encode_cases[] = { 1252 ENCODE_CASE(1) 1253 ENCODE_CASE(2) 1254 ENCODE_CASE(3) 1255 ENCODE_CASE(4) 1256 ENCODE_CASE(5) 1257 ENCODE_CASE(6) 1258 ENCODE_CASE(7) 1259 ENCODE_CASE(8) 1260 ENCODE_CASE(9) 1261 ENCODE_CASE(10) 1262 ENCODE_CASE(11) 1263 ENCODE_CASE(12) 1264 ENCODE_CASE(13) 1265 ENCODE_CASE(14) 1266 ENCODE_CASE(15) 1267 ENCODE_CASE(16) 1268 ENCODE_CASE(16b) 1269 ENCODE_CASE(17) 1270 ENCODE_CASE(18) 1271 ENCODE_CASE(19) 1272 ENCODE_CASE(20) 1273 ENCODE_CASE(21) 1274 ENCODE_CASE(22) 1275 ENCODE_CASE(23) 1276 }; 1277 1278 static int test_wire_encode(int idx) 1279 { 1280 int testresult = 0; 1281 WPACKET wpkt; 1282 PACKET pkt; 1283 BUF_MEM *buf = NULL; 1284 size_t written; 1285 const struct encode_test_case *c = &encode_cases[idx]; 1286 int have_wpkt = 0; 1287 size_t i; 1288 1289 if (!TEST_ptr(buf = BUF_MEM_new())) 1290 goto err; 1291 1292 if (!TEST_int_eq(WPACKET_init(&wpkt, buf), 1)) 1293 goto err; 1294 1295 have_wpkt = 1; 1296 if (!TEST_int_eq(c->serializer(&wpkt), 1)) 1297 goto err; 1298 1299 if (!TEST_int_eq(WPACKET_get_total_written(&wpkt, &written), 1)) 1300 goto err; 1301 1302 if (!TEST_mem_eq(buf->data, written, c->expect_buf, c->expect_buf_len)) 1303 goto err; 1304 1305 if (!TEST_int_eq(PACKET_buf_init(&pkt, (unsigned char *)buf->data, written), 1)) 1306 goto err; 1307 1308 if (!TEST_int_eq(c->deserializer(&pkt, -1), 1)) 1309 goto err; 1310 1311 if (!TEST_false(PACKET_remaining(&pkt))) 1312 goto err; 1313 1314 for (i = 0; i < c->expect_buf_len; ++i) { 1315 PACKET pkt2; 1316 1317 /* 1318 * Check parsing truncated (i.e., malformed) input is handled correctly. 1319 * Generate all possible truncations of our reference encoding and 1320 * verify that they are handled correctly. The number of bytes of the 1321 * truncated encoding is passed as an argument to the deserializer to 1322 * help it determine whether decoding should fail or not. 1323 */ 1324 if (!TEST_int_eq(PACKET_buf_init(&pkt2, (unsigned char *)c->expect_buf, i), 1)) 1325 goto err; 1326 1327 if (!TEST_int_eq(c->deserializer(&pkt2, i), 1)) 1328 goto err; 1329 } 1330 1331 testresult = 1; 1332 err: 1333 if (have_wpkt) 1334 WPACKET_finish(&wpkt); 1335 BUF_MEM_free(buf); 1336 return testresult; 1337 } 1338 1339 struct ack_test_case { 1340 const unsigned char *input_buf; 1341 size_t input_buf_len; 1342 int (*deserializer)(PACKET *pkt); 1343 int expect_fail; 1344 }; 1345 1346 /* ACK Frame with Excessive First ACK Range Field */ 1347 static const unsigned char ack_case_1_input[] = { 1348 0x02, /* ACK Without ECN */ 1349 0x08, /* Largest Acknowledged */ 1350 0x01, /* ACK Delay */ 1351 0x00, /* ACK Range Count */ 1352 0x09, /* First ACK Range */ 1353 }; 1354 1355 /* ACK Frame with Valid ACK Range Field */ 1356 static const unsigned char ack_case_2_input[] = { 1357 0x02, /* ACK Without ECN */ 1358 0x08, /* Largest Acknowledged */ 1359 0x01, /* ACK Delay */ 1360 0x00, /* ACK Range Count */ 1361 0x08, /* First ACK Range */ 1362 }; 1363 1364 /* ACK Frame with Excessive ACK Range Gap */ 1365 static const unsigned char ack_case_3_input[] = { 1366 0x02, /* ACK Without ECN */ 1367 0x08, /* Largest Acknowledged */ 1368 0x01, /* ACK Delay */ 1369 0x01, /* ACK Range Count */ 1370 0x01, /* First ACK Range */ 1371 1372 0x05, /* Gap */ 1373 0x01, /* ACK Range Length */ 1374 }; 1375 1376 /* ACK Frame with Valid ACK Range */ 1377 static const unsigned char ack_case_4_input[] = { 1378 0x02, /* ACK Without ECN */ 1379 0x08, /* Largest Acknowledged */ 1380 0x01, /* ACK Delay */ 1381 0x01, /* ACK Range Count */ 1382 0x01, /* First ACK Range */ 1383 1384 0x04, /* Gap */ 1385 0x01, /* ACK Range Length */ 1386 }; 1387 1388 /* ACK Frame with Excessive ACK Range Length */ 1389 static const unsigned char ack_case_5_input[] = { 1390 0x02, /* ACK Without ECN */ 1391 0x08, /* Largest Acknowledged */ 1392 0x01, /* ACK Delay */ 1393 0x01, /* ACK Range Count */ 1394 0x01, /* First ACK Range */ 1395 1396 0x04, /* Gap */ 1397 0x02, /* ACK Range Length */ 1398 }; 1399 1400 /* ACK Frame with Multiple ACK Ranges, Final Having Excessive Length */ 1401 static const unsigned char ack_case_6_input[] = { 1402 0x02, /* ACK Without ECN */ 1403 0x08, /* Largest Acknowledged */ 1404 0x01, /* ACK Delay */ 1405 0x02, /* ACK Range Count */ 1406 0x01, /* First ACK Range */ 1407 1408 0x01, /* Gap */ 1409 0x02, /* ACK Range Length */ 1410 1411 0x00, /* Gap */ 1412 0x01, /* ACK Range Length */ 1413 }; 1414 1415 /* ACK Frame with Multiple ACK Ranges, Valid */ 1416 static const unsigned char ack_case_7_input[] = { 1417 0x02, /* ACK Without ECN */ 1418 0x08, /* Largest Acknowledged */ 1419 0x01, /* ACK Delay */ 1420 0x02, /* ACK Range Count */ 1421 0x01, /* First ACK Range */ 1422 1423 0x01, /* Gap */ 1424 0x02, /* ACK Range Length */ 1425 1426 0x00, /* Gap */ 1427 0x00, /* ACK Range Length */ 1428 }; 1429 1430 static int ack_generic_decode(PACKET *pkt) 1431 { 1432 OSSL_QUIC_ACK_RANGE ranges[8] = { 0 }; 1433 OSSL_QUIC_FRAME_ACK f = { 0 }; 1434 uint64_t total_ranges = 0, peek_total_ranges = 0; 1435 int r; 1436 size_t i; 1437 1438 f.ack_ranges = ranges; 1439 f.num_ack_ranges = OSSL_NELEM(ranges); 1440 1441 if (!TEST_int_eq(ossl_quic_wire_peek_frame_ack_num_ranges(pkt, 1442 &peek_total_ranges), 1443 1)) 1444 return 0; 1445 1446 r = ossl_quic_wire_decode_frame_ack(pkt, 3, &f, &total_ranges); 1447 if (r == 0) 1448 return 0; 1449 1450 if (!TEST_uint64_t_eq(total_ranges, peek_total_ranges)) 1451 return 0; 1452 1453 for (i = 0; i < f.num_ack_ranges; ++i) { 1454 if (!TEST_uint64_t_le(f.ack_ranges[i].start, f.ack_ranges[i].end)) 1455 return 0; 1456 if (!TEST_uint64_t_lt(f.ack_ranges[i].end, 1000)) 1457 return 0; 1458 } 1459 1460 return 1; 1461 } 1462 1463 #define ACK_CASE(n, expect_fail, dec) \ 1464 { \ 1465 ack_case_##n##_input, \ 1466 sizeof(ack_case_##n##_input), \ 1467 (dec), \ 1468 (expect_fail) \ 1469 }, 1470 1471 static const struct ack_test_case ack_cases[] = { 1472 ACK_CASE(1, 1, ack_generic_decode) 1473 ACK_CASE(2, 0, ack_generic_decode) 1474 ACK_CASE(3, 1, ack_generic_decode) 1475 ACK_CASE(4, 0, ack_generic_decode) 1476 ACK_CASE(5, 1, ack_generic_decode) 1477 ACK_CASE(6, 1, ack_generic_decode) 1478 ACK_CASE(7, 0, ack_generic_decode) 1479 }; 1480 1481 static int test_wire_ack(int idx) 1482 { 1483 int testresult = 0, r; 1484 PACKET pkt; 1485 const struct ack_test_case *c = &ack_cases[idx]; 1486 1487 if (!TEST_int_eq(PACKET_buf_init(&pkt, 1488 (unsigned char *)c->input_buf, 1489 c->input_buf_len), 1490 1)) 1491 goto err; 1492 1493 r = c->deserializer(&pkt); 1494 if (c->expect_fail) { 1495 if (!TEST_int_eq(r, 0)) 1496 goto err; 1497 } else { 1498 if (!TEST_int_eq(r, 1)) 1499 goto err; 1500 1501 if (!TEST_false(PACKET_remaining(&pkt))) 1502 goto err; 1503 } 1504 1505 testresult = 1; 1506 err: 1507 return testresult; 1508 } 1509 1510 /* Packet Header PN Encoding Tests */ 1511 struct pn_test { 1512 QUIC_PN pn, tx_largest_acked, rx_largest_pn; 1513 char expected_len; 1514 unsigned char expected_bytes[4]; 1515 }; 1516 1517 static const struct pn_test pn_tests[] = { 1518 /* RFC 9000 Section A.2 */ 1519 { 0xac5c02, 0xabe8b3, 0xabe8b3, 2, { 0x5c, 0x02 } }, 1520 { 0xace8fe, 0xabe8b3, 0xabe8b3, 3, { 0xac, 0xe8, 0xfe } }, 1521 /* RFC 9000 Section A.3 */ 1522 { 0xa82f9b32, 0xa82f30ea, 0xa82f30ea, 2, { 0x9b, 0x32 } }, 1523 /* Boundary Cases */ 1524 { 1, 0, 0, 1, { 0x01 } }, 1525 { 256, 255, 255, 1, { 0x00 } }, 1526 { 257, 255, 255, 1, { 0x01 } }, 1527 { 256, 128, 128, 1, { 0x00 } }, 1528 { 256, 127, 127, 2, { 0x01, 0x00 } }, 1529 { 65536, 32768, 32768, 2, { 0x00, 0x00 } }, 1530 { 65537, 32769, 32769, 2, { 0x00, 0x01 } }, 1531 { 65536, 32767, 32767, 3, { 0x01, 0x00, 0x00 } }, 1532 { 65537, 32768, 32768, 3, { 0x01, 0x00, 0x01 } }, 1533 { 16777216, 8388608, 8388608, 3, { 0x00, 0x00, 0x00 } }, 1534 { 16777217, 8388609, 8388609, 3, { 0x00, 0x00, 0x01 } }, 1535 { 16777216, 8388607, 8388607, 4, { 0x01, 0x00, 0x00, 0x00 } }, 1536 { 16777217, 8388608, 8388608, 4, { 0x01, 0x00, 0x00, 0x01 } }, 1537 { 4294967296, 2147483648, 2147483648, 4, { 0x00, 0x00, 0x00, 0x00 } }, 1538 { 4294967297, 2147483648, 2147483648, 4, { 0x00, 0x00, 0x00, 0x01 } }, 1539 }; 1540 1541 static int test_wire_pkt_hdr_pn(int tidx) 1542 { 1543 int testresult = 0; 1544 const struct pn_test *t = &pn_tests[tidx]; 1545 unsigned char buf[4]; 1546 int pn_len; 1547 QUIC_PN res_pn; 1548 1549 pn_len = ossl_quic_wire_determine_pn_len(t->pn, t->tx_largest_acked); 1550 if (!TEST_int_eq(pn_len, (int)t->expected_len)) 1551 goto err; 1552 1553 if (!TEST_true(ossl_quic_wire_encode_pkt_hdr_pn(t->pn, buf, pn_len))) 1554 goto err; 1555 1556 if (!TEST_mem_eq(t->expected_bytes, t->expected_len, buf, pn_len)) 1557 goto err; 1558 1559 if (!TEST_true(ossl_quic_wire_decode_pkt_hdr_pn(buf, pn_len, 1560 t->rx_largest_pn, &res_pn))) 1561 goto err; 1562 1563 if (!TEST_uint64_t_eq(res_pn, t->pn)) 1564 goto err; 1565 1566 testresult = 1; 1567 err: 1568 return testresult; 1569 } 1570 1571 /* RFC 9001 s. A.4 */ 1572 static const QUIC_CONN_ID retry_orig_dcid = { 1573 8, { 0x83, 0x94, 0xc8, 0xf0, 0x3e, 0x51, 0x57, 0x08 } 1574 }; 1575 1576 static const unsigned char retry_encoded[] = { 1577 0xff, /* Long Header, Retry */ 1578 0x00, 0x00, 0x00, 0x01, /* Version 1 */ 1579 0x00, /* DCID */ 1580 0x08, 0xf0, 0x67, 0xa5, 0x50, 0x2a, 0x42, 0x62, 0xb5, /* SCID */ 1581 1582 /* Retry Token */ 1583 0x74, 0x6f, 0x6b, 0x65, 0x6e, 1584 1585 /* Retry Integrity Tag */ 1586 0x04, 0xa2, 0x65, 0xba, 0x2e, 0xff, 0x4d, 0x82, 0x90, 0x58, 0xfb, 0x3f, 0x0f, 1587 0x24, 0x96, 0xba 1588 }; 1589 1590 static int test_wire_retry_integrity_tag(void) 1591 { 1592 int testresult = 0; 1593 PACKET pkt = { 0 }; 1594 QUIC_PKT_HDR hdr = { 0 }; 1595 unsigned char got_tag[QUIC_RETRY_INTEGRITY_TAG_LEN] = { 0 }; 1596 1597 if (!TEST_true(PACKET_buf_init(&pkt, retry_encoded, sizeof(retry_encoded)))) 1598 goto err; 1599 1600 if (!TEST_true(ossl_quic_wire_decode_pkt_hdr(&pkt, 0, 0, 0, &hdr, NULL, NULL))) 1601 goto err; 1602 1603 if (!TEST_int_eq(hdr.type, QUIC_PKT_TYPE_RETRY)) 1604 goto err; 1605 1606 if (!TEST_true(ossl_quic_calculate_retry_integrity_tag(NULL, NULL, &hdr, 1607 &retry_orig_dcid, 1608 got_tag))) 1609 goto err; 1610 1611 if (!TEST_mem_eq(got_tag, sizeof(got_tag), 1612 retry_encoded + sizeof(retry_encoded) 1613 - QUIC_RETRY_INTEGRITY_TAG_LEN, 1614 QUIC_RETRY_INTEGRITY_TAG_LEN)) 1615 goto err; 1616 1617 if (!TEST_true(ossl_quic_validate_retry_integrity_tag(NULL, NULL, &hdr, 1618 &retry_orig_dcid))) 1619 goto err; 1620 1621 testresult = 1; 1622 err: 1623 return testresult; 1624 } 1625 1626 /* is_minimal=0 test */ 1627 static const unsigned char non_minimal_1[] = { 1628 0x40, 0x00 1629 }; 1630 1631 static const unsigned char non_minimal_2[] = { 1632 0x40, 0x3F 1633 }; 1634 1635 static const unsigned char non_minimal_3[] = { 1636 0x80, 0x00, 0x00, 0x00 1637 }; 1638 1639 static const unsigned char non_minimal_4[] = { 1640 0x80, 0x00, 0x3F, 0xFF 1641 }; 1642 1643 static const unsigned char non_minimal_5[] = { 1644 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 1645 }; 1646 1647 static const unsigned char non_minimal_6[] = { 1648 0xC0, 0x00, 0x00, 0x00, 0x3F, 0xFF, 0xFF, 0xFF 1649 }; 1650 1651 static const unsigned char *const non_minimal[] = { 1652 non_minimal_1, 1653 non_minimal_2, 1654 non_minimal_3, 1655 non_minimal_4, 1656 non_minimal_5, 1657 non_minimal_6, 1658 }; 1659 1660 static const size_t non_minimal_len[] = { 1661 OSSL_NELEM(non_minimal_1), 1662 OSSL_NELEM(non_minimal_2), 1663 OSSL_NELEM(non_minimal_3), 1664 OSSL_NELEM(non_minimal_4), 1665 OSSL_NELEM(non_minimal_5), 1666 OSSL_NELEM(non_minimal_6), 1667 }; 1668 1669 static int test_wire_minimal(int idx) 1670 { 1671 int testresult = 0; 1672 int is_minimal; 1673 uint64_t frame_type; 1674 PACKET pkt; 1675 1676 if (!TEST_true(PACKET_buf_init(&pkt, non_minimal[idx], 1677 non_minimal_len[idx]))) 1678 goto err; 1679 1680 if (!TEST_true(ossl_quic_wire_peek_frame_header(&pkt, &frame_type, 1681 &is_minimal))) 1682 goto err; 1683 1684 if (!TEST_false(is_minimal)) 1685 goto err; 1686 1687 testresult = 1; 1688 err: 1689 return testresult; 1690 } 1691 1692 int setup_tests(void) 1693 { 1694 ADD_ALL_TESTS(test_wire_encode, OSSL_NELEM(encode_cases)); 1695 ADD_ALL_TESTS(test_wire_ack, OSSL_NELEM(ack_cases)); 1696 ADD_ALL_TESTS(test_wire_pkt_hdr_pn, OSSL_NELEM(pn_tests)); 1697 ADD_TEST(test_wire_retry_integrity_tag); 1698 ADD_ALL_TESTS(test_wire_minimal, OSSL_NELEM(non_minimal_len)); 1699 return 1; 1700 } 1701
Indexes created Thu Aug 20 00:25:57 UTC 2026