1 /* 2 * Copyright 2022-2025 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, 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 } 1646