2 * Copyright 2022-2023 The OpenSSL Project Authors. All Rights Reserved.
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
10 #include "internal/packet.h"
11 #include "internal/quic_wire.h"
12 #include "internal/quic_wire_pkt.h"
15 struct encode_test_case
{
16 int (*serializer
)(WPACKET
*pkt
);
17 const unsigned char *expect_buf
;
18 size_t expect_buf_len
;
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
24 int (*deserializer
)(PACKET
*pkt
, ossl_ssize_t fail
);
28 static int encode_case_1_enc(WPACKET
*pkt
)
30 if (!TEST_int_eq(ossl_quic_wire_encode_padding(pkt
, 3), 1))
36 static int encode_case_1_dec(PACKET
*pkt
, ossl_ssize_t fail
)
39 /* No failure modes for padding */
42 if (!TEST_int_eq(ossl_quic_wire_decode_padding(pkt
), 3))
48 static const unsigned char encode_case_1_expect
[] = {
53 static int encode_case_2_enc(WPACKET
*pkt
)
56 if (!TEST_int_eq(ossl_quic_wire_encode_frame_ping(pkt
), 1))
62 static int encode_case_2_dec(PACKET
*pkt
, ossl_ssize_t fail
)
65 if (!TEST_int_eq(ossl_quic_wire_decode_frame_ping(pkt
), fail
< 0))
71 static const unsigned char encode_case_2_expect
[] = {
76 static const OSSL_QUIC_ACK_RANGE encode_case_3_ranges
[] = {
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
),
88 static int encode_case_3_enc(WPACKET
*pkt
)
90 if (!TEST_int_eq(ossl_quic_wire_encode_frame_ack(pkt
, 3, &encode_case_3_f
), 1))
96 static int encode_case_3_dec(PACKET
*pkt
, ossl_ssize_t fail
)
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;
103 f
.ack_ranges
= ranges
;
104 f
.num_ack_ranges
= OSSL_NELEM(ranges
);
106 ret
= ossl_quic_wire_peek_frame_ack_num_ranges(pkt
, &peek_total_ranges
);
107 if (fail
< 0 && !TEST_int_eq(ret
, 1))
110 if (!TEST_int_eq(ossl_quic_wire_decode_frame_ack(pkt
, 3, &f
, &total_ranges
), fail
< 0))
113 if (ret
== 1 && !TEST_uint64_t_eq(peek_total_ranges
, 2))
119 if (!TEST_uint64_t_eq(total_ranges
, peek_total_ranges
))
122 if (!TEST_uint64_t_le(f
.num_ack_ranges
* sizeof(OSSL_QUIC_ACK_RANGE
),
124 || !TEST_uint64_t_le(encode_case_3_f
.num_ack_ranges
125 * sizeof(OSSL_QUIC_ACK_RANGE
),
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
)))
135 if (!TEST_uint64_t_eq(ossl_time2ticks(f
.delay_time
),
136 ossl_time2ticks(encode_case_3_f
.delay_time
)))
139 if (!TEST_true(f
.ecn_present
))
142 if (!TEST_uint64_t_eq(f
.ect0
, encode_case_3_f
.ect0
))
145 if (!TEST_uint64_t_eq(f
.ect1
, encode_case_3_f
.ect1
))
148 if (!TEST_uint64_t_eq(f
.ecnce
, encode_case_3_f
.ecnce
))
154 static const unsigned char encode_case_3_expect
[] = {
156 0x1E, /* Largest Acknowledged */
157 0x40, 0x7d, /* ACK Delay */
158 1, /* ACK Range Count */
159 10, /* First ACK Range */
164 0x3c, /* ECT0 Count */
165 0x40, 0x46, /* ECT1 Count */
166 0x40, 0x50, /* ECNCE Count */
169 /* 4. RESET_STREAM */
170 static const OSSL_QUIC_FRAME_RESET_STREAM encode_case_4_f
= {
171 0x1234, 0x9781, 0x11717
174 static int encode_case_4_enc(WPACKET
*pkt
)
176 if (!TEST_int_eq(ossl_quic_wire_encode_frame_reset_stream(pkt
,
177 &encode_case_4_f
), 1))
183 static int encode_case_4_dec(PACKET
*pkt
, ossl_ssize_t fail
)
185 OSSL_QUIC_FRAME_RESET_STREAM f
= {0};
187 if (!TEST_int_eq(ossl_quic_wire_decode_frame_reset_stream(pkt
, &f
), fail
< 0))
193 if (!TEST_mem_eq(&f
, sizeof(f
), &encode_case_4_f
, sizeof(encode_case_4_f
)))
199 static const unsigned char encode_case_4_expect
[] = {
201 0x52, 0x34, /* Stream ID */
202 0x80, 0x00, 0x97, 0x81, /* App Error Code */
203 0x80, 0x01, 0x17, 0x17, /* Final Size */
206 /* 5. STOP_SENDING */
207 static const OSSL_QUIC_FRAME_STOP_SENDING encode_case_5_f
= {
211 static int encode_case_5_enc(WPACKET
*pkt
)
213 if (!TEST_int_eq(ossl_quic_wire_encode_frame_stop_sending(pkt
,
214 &encode_case_5_f
), 1))
220 static int encode_case_5_dec(PACKET
*pkt
, ossl_ssize_t fail
)
222 OSSL_QUIC_FRAME_STOP_SENDING f
= {0};
224 if (!TEST_int_eq(ossl_quic_wire_decode_frame_stop_sending(pkt
, &f
), fail
< 0))
230 if (!TEST_mem_eq(&f
, sizeof(f
), &encode_case_5_f
, sizeof(encode_case_5_f
)))
236 static const unsigned char encode_case_5_expect
[] = {
238 0x52, 0x34, /* Stream ID */
239 0x80, 0x00, 0x97, 0x81 /* App Error Code */
243 static const unsigned char encode_case_6_data
[] = {
247 static const OSSL_QUIC_FRAME_CRYPTO encode_case_6_f
= {
248 0x1234, sizeof(encode_case_6_data
), encode_case_6_data
251 static int encode_case_6_enc(WPACKET
*pkt
)
253 if (!TEST_ptr(ossl_quic_wire_encode_frame_crypto(pkt
,
260 static int encode_case_6_dec(PACKET
*pkt
, ossl_ssize_t fail
)
262 OSSL_QUIC_FRAME_CRYPTO f
= {0};
264 if (!TEST_int_eq(ossl_quic_wire_decode_frame_crypto(pkt
, 0, &f
), fail
< 0))
270 if (!TEST_uint64_t_eq(f
.offset
, 0x1234))
273 if (!TEST_uint64_t_le(f
.len
, SIZE_MAX
))
276 if (!TEST_mem_eq(f
.data
, (size_t)f
.len
,
277 encode_case_6_data
, sizeof(encode_case_6_data
)))
283 static const unsigned char encode_case_6_expect
[] = {
285 0x52, 0x34, /* Offset */
287 93, 18, 17, 102, 33 /* Data */
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
296 static int encode_case_7_enc(WPACKET
*pkt
)
298 if (!TEST_int_eq(ossl_quic_wire_encode_frame_new_token(pkt
,
300 sizeof(encode_case_7_token
)), 1))
306 static int encode_case_7_dec(PACKET
*pkt
, ossl_ssize_t fail
)
308 const unsigned char *token
= NULL
;
309 size_t token_len
= 0;
311 if (!TEST_int_eq(ossl_quic_wire_decode_frame_new_token(pkt
,
313 &token_len
), fail
< 0))
319 if (!TEST_mem_eq(token
, token_len
,
320 encode_case_7_token
, sizeof(encode_case_7_token
)))
326 static const unsigned char encode_case_7_expect
[] = {
329 0xde, 0x06, 0xcb, 0x76, 0x5d, 0xb1, 0xa7, 0x71, /* Token */
330 0x78, 0x09, 0xbb, 0xe8, 0x50, 0x19, 0x12, 0x9a
333 /* 8. STREAM (no length, no offset, no fin) */
334 static const unsigned char encode_case_8_data
[] = {
335 0xde, 0x06, 0xcb, 0x76, 0x5d
337 static const OSSL_QUIC_FRAME_STREAM encode_case_8_f
= {
338 0x1234, 0, 5, encode_case_8_data
, 0, 0
341 static int encode_case_8_enc(WPACKET
*pkt
)
343 if (!TEST_ptr(ossl_quic_wire_encode_frame_stream(pkt
,
350 static int encode_case_8_dec(PACKET
*pkt
, ossl_ssize_t fail
)
352 OSSL_QUIC_FRAME_STREAM f
= {0};
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.
361 if (!TEST_int_eq(ossl_quic_wire_decode_frame_stream(pkt
, 0, &f
), fail
< 0))
367 if (!TEST_uint64_t_le(f
.len
, SIZE_MAX
))
370 if (!TEST_mem_eq(f
.data
, (size_t)f
.len
,
371 encode_case_8_data
, sizeof(encode_case_8_data
)))
374 if (!TEST_uint64_t_eq(f
.stream_id
, 0x1234))
377 if (!TEST_uint64_t_eq(f
.offset
, 0))
380 if (!TEST_int_eq(f
.has_explicit_len
, 0))
383 if (!TEST_int_eq(f
.is_fin
, 0))
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 */
395 /* 9. STREAM (length, offset, fin) */
396 static const unsigned char encode_case_9_data
[] = {
397 0xde, 0x06, 0xcb, 0x76, 0x5d
399 static const OSSL_QUIC_FRAME_STREAM encode_case_9_f
= {
400 0x1234, 0x39, 5, encode_case_9_data
, 1, 1
403 static int encode_case_9_enc(WPACKET
*pkt
)
405 if (!TEST_ptr(ossl_quic_wire_encode_frame_stream(pkt
,
412 static int encode_case_9_dec(PACKET
*pkt
, ossl_ssize_t fail
)
414 OSSL_QUIC_FRAME_STREAM f
= {0};
416 if (!TEST_int_eq(ossl_quic_wire_decode_frame_stream(pkt
, 0, &f
), fail
< 0))
422 if (!TEST_uint64_t_le(f
.len
, SIZE_MAX
))
425 if (!TEST_mem_eq(f
.data
, (size_t)f
.len
,
426 encode_case_9_data
, sizeof(encode_case_9_data
)))
429 if (!TEST_uint64_t_eq(f
.stream_id
, 0x1234))
432 if (!TEST_uint64_t_eq(f
.offset
, 0x39))
435 if (!TEST_int_eq(f
.has_explicit_len
, 1))
438 if (!TEST_int_eq(f
.is_fin
, 1))
444 static const unsigned char encode_case_9_expect
[] = {
445 0x0f, /* Type (OFF=1, LEN=1, FIN=1) */
446 0x52, 0x34, /* Stream ID */
449 0xde, 0x06, 0xcb, 0x76, 0x5d /* Data */
453 static int encode_case_10_enc(WPACKET
*pkt
)
455 if (!TEST_int_eq(ossl_quic_wire_encode_frame_max_data(pkt
, 0x1234), 1))
461 static int encode_case_10_dec(PACKET
*pkt
, ossl_ssize_t fail
)
463 uint64_t max_data
= 0;
465 if (!TEST_int_eq(ossl_quic_wire_decode_frame_max_data(pkt
, &max_data
), fail
< 0))
471 if (!TEST_uint64_t_eq(max_data
, 0x1234))
477 static const unsigned char encode_case_10_expect
[] = {
479 0x52, 0x34, /* Max Data */
482 /* 11. MAX_STREAM_DATA */
483 static int encode_case_11_enc(WPACKET
*pkt
)
485 if (!TEST_int_eq(ossl_quic_wire_encode_frame_max_stream_data(pkt
,
493 static int encode_case_11_dec(PACKET
*pkt
, ossl_ssize_t fail
)
495 uint64_t stream_id
= 0, max_data
= 0;
497 if (!TEST_int_eq(ossl_quic_wire_decode_frame_max_stream_data(pkt
,
499 &max_data
), fail
< 0))
505 if (!TEST_uint64_t_eq(stream_id
, 0x1234))
508 if (!TEST_uint64_t_eq(max_data
, 0x9781))
514 static const unsigned char encode_case_11_expect
[] = {
516 0x52, 0x34, /* Stream ID */
517 0x80, 0x00, 0x97, 0x81, /* Max Data */
520 /* 12. MAX_STREAMS */
521 static int encode_case_12_enc(WPACKET
*pkt
)
523 if (!TEST_int_eq(ossl_quic_wire_encode_frame_max_streams(pkt
, 0, 0x1234), 1))
526 if (!TEST_int_eq(ossl_quic_wire_encode_frame_max_streams(pkt
, 1, 0x9781), 1))
532 static int encode_case_12_dec(PACKET
*pkt
, ossl_ssize_t fail
)
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
;
538 success_if
= (fail
< 0 || fail
>= 1);
539 if (!TEST_int_eq(ossl_quic_wire_peek_frame_header(pkt
, &frame_type_1
,
544 if (!TEST_true(!success_if
|| is_minimal
))
547 success_if
= (fail
< 0 || fail
>= 3);
548 if (!TEST_int_eq(ossl_quic_wire_decode_frame_max_streams(pkt
,
553 success_if
= (fail
< 0 || fail
>= 4);
554 if (!TEST_int_eq(ossl_quic_wire_peek_frame_header(pkt
, &frame_type_2
,
559 if (!TEST_true(!success_if
|| is_minimal
))
562 success_if
= (fail
< 0);
563 if (!TEST_int_eq(ossl_quic_wire_decode_frame_max_streams(pkt
,
568 if ((fail
< 0 || fail
>= 3)
569 && !TEST_uint64_t_eq(frame_type_1
, OSSL_QUIC_FRAME_TYPE_MAX_STREAMS_BIDI
))
572 if ((fail
< 0 || fail
>= 3)
573 && !TEST_uint64_t_eq(max_streams_1
, 0x1234))
576 if ((fail
< 0 || fail
>= 8)
577 && !TEST_uint64_t_eq(frame_type_2
, OSSL_QUIC_FRAME_TYPE_MAX_STREAMS_UNI
))
580 if ((fail
< 0 || fail
>= 8)
581 && !TEST_uint64_t_eq(max_streams_2
, 0x9781))
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 */
594 /* 13. DATA_BLOCKED */
595 static int encode_case_13_enc(WPACKET
*pkt
)
597 if (!TEST_int_eq(ossl_quic_wire_encode_frame_data_blocked(pkt
, 0x1234), 1))
603 static int encode_case_13_dec(PACKET
*pkt
, ossl_ssize_t fail
)
605 uint64_t max_data
= 0;
607 if (!TEST_int_eq(ossl_quic_wire_decode_frame_data_blocked(pkt
,
608 &max_data
), fail
< 0))
614 if (!TEST_uint64_t_eq(max_data
, 0x1234))
620 static const unsigned char encode_case_13_expect
[] = {
622 0x52, 0x34, /* Max Data */
625 /* 14. STREAM_DATA_BLOCKED */
626 static int encode_case_14_enc(WPACKET
*pkt
)
628 if (!TEST_int_eq(ossl_quic_wire_encode_frame_stream_data_blocked(pkt
,
636 static int encode_case_14_dec(PACKET
*pkt
, ossl_ssize_t fail
)
638 uint64_t stream_id
= 0, max_data
= 0;
640 if (!TEST_int_eq(ossl_quic_wire_decode_frame_stream_data_blocked(pkt
,
642 &max_data
), fail
< 0))
648 if (!TEST_uint64_t_eq(stream_id
, 0x1234))
651 if (!TEST_uint64_t_eq(max_data
, 0x9781))
657 static const unsigned char encode_case_14_expect
[] = {
659 0x52, 0x34, /* Stream ID */
660 0x80, 0x00, 0x97, 0x81, /* Max Data */
663 /* 15. STREAMS_BLOCKED */
664 static int encode_case_15_enc(WPACKET
*pkt
)
666 if (!TEST_int_eq(ossl_quic_wire_encode_frame_streams_blocked(pkt
, 0, 0x1234), 1))
669 if (!TEST_int_eq(ossl_quic_wire_encode_frame_streams_blocked(pkt
, 1, 0x9781), 1))
675 static int encode_case_15_dec(PACKET
*pkt
, ossl_ssize_t fail
)
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
;
681 success_if
= (fail
< 0 || fail
>= 1);
682 if (!TEST_int_eq(ossl_quic_wire_peek_frame_header(pkt
, &frame_type_1
,
687 if (!TEST_true(!success_if
|| is_minimal
))
690 success_if
= (fail
< 0 || fail
>= 3);
691 if (!TEST_int_eq(ossl_quic_wire_decode_frame_streams_blocked(pkt
,
696 success_if
= (fail
< 0 || fail
>= 4);
697 if (!TEST_int_eq(ossl_quic_wire_peek_frame_header(pkt
, &frame_type_2
,
702 if (!TEST_true(!success_if
|| is_minimal
))
705 if (!TEST_int_eq(ossl_quic_wire_decode_frame_streams_blocked(pkt
,
707 fail
< 0 || fail
>= 8))
710 if ((fail
< 0 || fail
>= 1)
711 && !TEST_uint64_t_eq(frame_type_1
, OSSL_QUIC_FRAME_TYPE_STREAMS_BLOCKED_BIDI
))
714 if ((fail
< 0 || fail
>= 3)
715 && !TEST_uint64_t_eq(max_streams_1
, 0x1234))
718 if ((fail
< 0 || fail
>= 4)
719 && !TEST_uint64_t_eq(frame_type_2
, OSSL_QUIC_FRAME_TYPE_STREAMS_BLOCKED_UNI
))
722 if ((fail
< 0 || fail
>= 8)
723 && !TEST_uint64_t_eq(max_streams_2
, 0x9781))
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 */
736 /* 16. NEW_CONNECTION_ID */
737 static const unsigned char encode_case_16_conn_id
[] = {
738 0x33, 0x44, 0x55, 0x66
741 static const OSSL_QUIC_FRAME_NEW_CONN_ID encode_case_16_f
= {
746 {0x33, 0x44, 0x55, 0x66}
750 0xde, 0x06, 0xcb, 0x76, 0x5d, 0xb1, 0xa7, 0x71,
751 0x78, 0x09, 0xbb, 0xe8, 0x50, 0x19, 0x12, 0x9a
756 static int encode_case_16_enc(WPACKET
*pkt
)
758 if (!TEST_int_eq(ossl_quic_wire_encode_frame_new_conn_id(pkt
,
759 &encode_case_16_f
), 1))
765 static int encode_case_16_dec(PACKET
*pkt
, ossl_ssize_t fail
)
767 OSSL_QUIC_FRAME_NEW_CONN_ID f
= {0};
769 if (!TEST_int_eq(ossl_quic_wire_decode_frame_new_conn_id(pkt
, &f
), fail
< 0))
775 if (!TEST_uint64_t_eq(f
.seq_num
, 0x9781))
778 if (!TEST_uint64_t_eq(f
.retire_prior_to
, 0x1234))
781 if (!TEST_uint64_t_eq(f
.conn_id
.id_len
, sizeof(encode_case_16_conn_id
)))
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
)))
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
)))
797 static const unsigned char encode_case_16_expect
[] = {
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
807 /* 16b. NEW_CONNECTION_ID seq_num < retire_prior_to */
808 static const OSSL_QUIC_FRAME_NEW_CONN_ID encode_case_16b_f
= {
813 {0x33, 0x44, 0x55, 0x66}
817 0xde, 0x06, 0xcb, 0x76, 0x5d, 0xb1, 0xa7, 0x71,
818 0x78, 0x09, 0xbb, 0xe8, 0x50, 0x19, 0x12, 0x9a
823 static int encode_case_16b_enc(WPACKET
*pkt
)
825 if (!TEST_int_eq(ossl_quic_wire_encode_frame_new_conn_id(pkt
,
826 &encode_case_16b_f
), 1))
832 static int encode_case_16b_dec(PACKET
*pkt
, ossl_ssize_t fail
)
834 OSSL_QUIC_FRAME_NEW_CONN_ID f
= {0};
836 if (!TEST_int_eq(ossl_quic_wire_decode_frame_new_conn_id(pkt
, &f
), 0))
839 if (!TEST_true(PACKET_forward(pkt
, PACKET_remaining(pkt
))))
845 static const unsigned char encode_case_16b_expect
[] = {
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
855 /* 17. RETIRE_CONNECTION_ID */
856 static int encode_case_17_enc(WPACKET
*pkt
)
858 if (!TEST_int_eq(ossl_quic_wire_encode_frame_retire_conn_id(pkt
, 0x1234), 1))
864 static int encode_case_17_dec(PACKET
*pkt
, ossl_ssize_t fail
)
866 uint64_t seq_num
= 0;
868 if (!TEST_int_eq(ossl_quic_wire_decode_frame_retire_conn_id(pkt
, &seq_num
), fail
< 0))
874 if (!TEST_uint64_t_eq(seq_num
, 0x1234))
880 static const unsigned char encode_case_17_expect
[] = {
882 0x52, 0x34, /* Seq Num */
885 /* 18. PATH_CHALLENGE */
886 static const uint64_t encode_case_18_data
887 = (((uint64_t)0x5f4b12)<<40) | (uint64_t)0x731834UL
;
889 static int encode_case_18_enc(WPACKET
*pkt
)
891 if (!TEST_int_eq(ossl_quic_wire_encode_frame_path_challenge(pkt
,
892 encode_case_18_data
), 1))
898 static int encode_case_18_dec(PACKET
*pkt
, ossl_ssize_t fail
)
900 uint64_t challenge
= 0;
902 if (!TEST_int_eq(ossl_quic_wire_decode_frame_path_challenge(pkt
, &challenge
), fail
< 0))
908 if (!TEST_uint64_t_eq(challenge
, encode_case_18_data
))
914 static const unsigned char encode_case_18_expect
[] = {
916 0x5f, 0x4b, 0x12, 0x00, 0x00, 0x73, 0x18, 0x34, /* Data */
919 /* 19. PATH_RESPONSE */
920 static const uint64_t encode_case_19_data
921 = (((uint64_t)0x5f4b12)<<40) | (uint64_t)0x731834UL
;
923 static int encode_case_19_enc(WPACKET
*pkt
)
925 if (!TEST_int_eq(ossl_quic_wire_encode_frame_path_response(pkt
,
926 encode_case_19_data
), 1))
932 static int encode_case_19_dec(PACKET
*pkt
, ossl_ssize_t fail
)
934 uint64_t challenge
= 0;
936 if (!TEST_int_eq(ossl_quic_wire_decode_frame_path_response(pkt
, &challenge
), fail
< 0))
942 if (!TEST_uint64_t_eq(challenge
, encode_case_19_data
))
948 static const unsigned char encode_case_19_expect
[] = {
950 0x5f, 0x4b, 0x12, 0x00, 0x00, 0x73, 0x18, 0x34, /* Data */
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
960 static const OSSL_QUIC_FRAME_CONN_CLOSE encode_case_20_f
= {
964 (char *)encode_case_20_reason
,
965 sizeof(encode_case_20_reason
)
968 static int encode_case_20_enc(WPACKET
*pkt
)
970 if (!TEST_int_eq(ossl_quic_wire_encode_frame_conn_close(pkt
,
971 &encode_case_20_f
), 1))
977 static int encode_case_20_dec(PACKET
*pkt
, ossl_ssize_t fail
)
979 OSSL_QUIC_FRAME_CONN_CLOSE f
= {0};
981 if (!TEST_int_eq(ossl_quic_wire_decode_frame_conn_close(pkt
, &f
), fail
< 0))
987 if (!TEST_int_eq(f
.is_app
, 0))
990 if (!TEST_uint64_t_eq(f
.error_code
, 0x1234))
993 if (!TEST_uint64_t_eq(f
.frame_type
, 0x9781))
996 if (!TEST_size_t_eq(f
.reason_len
, 18))
999 if (!TEST_mem_eq(f
.reason
, f
.reason_len
,
1000 encode_case_20_f
.reason
, encode_case_20_f
.reason_len
))
1006 static const unsigned char encode_case_20_expect
[] = {
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
1015 /* 21. HANDSHAKE_DONE */
1016 static int encode_case_21_enc(WPACKET
*pkt
)
1019 if (!TEST_int_eq(ossl_quic_wire_encode_frame_handshake_done(pkt
), 1))
1025 static int encode_case_21_dec(PACKET
*pkt
, ossl_ssize_t fail
)
1028 if (!TEST_int_eq(ossl_quic_wire_decode_frame_handshake_done(pkt
), fail
< 0))
1034 static const unsigned char encode_case_21_expect
[] = {
1038 /* 22. Buffer Transport Parameter */
1039 static const unsigned char encode_case_22_data
[] = {0x55,0x77,0x32,0x46,0x99};
1041 static int encode_case_22_enc(WPACKET
*pkt
)
1045 if (!TEST_ptr(ossl_quic_wire_encode_transport_param_bytes(pkt
, 0x1234,
1046 encode_case_22_data
,
1047 sizeof(encode_case_22_data
))))
1050 if (!TEST_ptr(p
= ossl_quic_wire_encode_transport_param_bytes(pkt
, 0x9781,
1060 static int encode_case_22_dec(PACKET
*pkt
, ossl_ssize_t fail
)
1064 const unsigned char *p
;
1065 static const unsigned char data
[] = {0x33, 0x44};
1067 if (!TEST_int_eq(ossl_quic_wire_peek_transport_param(pkt
, &id
),
1068 fail
< 0 || fail
>= 2))
1071 if ((fail
< 0 || fail
>= 2)
1072 && !TEST_uint64_t_eq(id
, 0x1234))
1077 p
= ossl_quic_wire_decode_transport_param_bytes(pkt
, &id
, &len
);
1078 if (fail
< 0 || fail
>= 8) {
1082 if (!TEST_ptr_null(p
))
1086 if ((fail
< 0 || fail
>= 8)
1087 && !TEST_uint64_t_eq(id
, 0x1234))
1090 if ((fail
< 0 || fail
>= 8)
1091 && !TEST_mem_eq(p
, len
, encode_case_22_data
, sizeof(encode_case_22_data
)))
1094 if ((fail
< 0 || fail
>= 8)
1095 && !TEST_int_eq(ossl_quic_wire_peek_transport_param(pkt
, &id
),
1096 fail
< 0 || fail
>= 12))
1099 if ((fail
< 0 || fail
>= 12)
1100 && !TEST_uint64_t_eq(id
, 0x9781))
1105 p
= ossl_quic_wire_decode_transport_param_bytes(pkt
, &id
, &len
);
1106 if (fail
< 0 || fail
>= 15) {
1110 if (!TEST_ptr_null(p
))
1114 if ((fail
< 0 || fail
>= 15)
1115 && !TEST_uint64_t_eq(id
, 0x9781))
1118 if ((fail
< 0 || fail
>= 15)
1119 && !TEST_mem_eq(p
, len
, data
, sizeof(data
)))
1125 static const unsigned char encode_case_22_expect
[] = {
1126 0x52, 0x34, /* ID */
1128 0x55, 0x77, 0x32, 0x46, 0x99, /* Data */
1130 0x80, 0x00, 0x97, 0x81, /* ID */
1132 0x33, 0x44 /* Data */
1135 /* 23. Integer Transport Parameter */
1136 static int encode_case_23_enc(WPACKET
*pkt
)
1138 if (!TEST_int_eq(ossl_quic_wire_encode_transport_param_int(pkt
, 0x1234, 0x9781), 1))
1141 if (!TEST_int_eq(ossl_quic_wire_encode_transport_param_int(pkt
, 0x2233, 0x4545), 1))
1147 static int encode_case_23_dec(PACKET
*pkt
, ossl_ssize_t fail
)
1149 uint64_t id
= 0, value
= 0;
1151 if (!TEST_int_eq(ossl_quic_wire_decode_transport_param_int(pkt
,
1153 fail
< 0 || fail
>= 7))
1156 if ((fail
< 0 || fail
>= 7)
1157 && !TEST_uint64_t_eq(id
, 0x1234))
1160 if ((fail
< 0 || fail
>= 7)
1161 && !TEST_uint64_t_eq(value
, 0x9781))
1164 if (!TEST_int_eq(ossl_quic_wire_decode_transport_param_int(pkt
,
1166 fail
< 0 || fail
>= 14))
1169 if ((fail
< 0 || fail
>= 14)
1170 && !TEST_uint64_t_eq(id
, 0x2233))
1173 if ((fail
< 0 || fail
>= 14)
1174 && !TEST_uint64_t_eq(value
, 0x4545))
1180 static const unsigned char encode_case_23_expect
[] = {
1183 0x80, 0x00, 0x97, 0x81,
1187 0x80, 0x00, 0x45, 0x45,
1190 #define ENCODE_CASE(n) \
1192 encode_case_##n##_enc, \
1193 encode_case_##n##_expect, \
1194 OSSL_NELEM(encode_case_##n##_expect), \
1195 encode_case_##n##_dec \
1198 static const struct encode_test_case encode_cases
[] = {
1225 static int test_wire_encode(int idx
)
1230 BUF_MEM
*buf
= NULL
;
1232 const struct encode_test_case
*c
= &encode_cases
[idx
];
1236 if (!TEST_ptr(buf
= BUF_MEM_new()))
1239 if (!TEST_int_eq(WPACKET_init(&wpkt
, buf
), 1))
1243 if (!TEST_int_eq(c
->serializer(&wpkt
), 1))
1246 if (!TEST_int_eq(WPACKET_get_total_written(&wpkt
, &written
), 1))
1249 if (!TEST_mem_eq(buf
->data
, written
, c
->expect_buf
, c
->expect_buf_len
))
1252 if (!TEST_int_eq(PACKET_buf_init(&pkt
, (unsigned char *)buf
->data
, written
), 1))
1255 if (!TEST_int_eq(c
->deserializer(&pkt
, -1), 1))
1258 if (!TEST_false(PACKET_remaining(&pkt
)))
1261 for (i
= 0; i
< c
->expect_buf_len
; ++i
) {
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.
1271 if (!TEST_int_eq(PACKET_buf_init(&pkt2
, (unsigned char *)c
->expect_buf
, i
), 1))
1274 if (!TEST_int_eq(c
->deserializer(&pkt2
, i
), 1))
1281 WPACKET_finish(&wpkt
);
1286 struct ack_test_case
{
1287 const unsigned char *input_buf
;
1288 size_t input_buf_len
;
1289 int (*deserializer
)(PACKET
*pkt
);
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 */
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 */
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 */
1320 0x01, /* ACK Range Length */
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 */
1332 0x01, /* ACK Range Length */
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 */
1344 0x02, /* ACK Range Length */
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 */
1356 0x02, /* ACK Range Length */
1359 0x01, /* ACK Range Length */
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 */
1371 0x02, /* ACK Range Length */
1374 0x00, /* ACK Range Length */
1377 static int ack_generic_decode(PACKET
*pkt
)
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;
1385 f
.ack_ranges
= ranges
;
1386 f
.num_ack_ranges
= OSSL_NELEM(ranges
);
1388 if (!TEST_int_eq(ossl_quic_wire_peek_frame_ack_num_ranges(pkt
,
1389 &peek_total_ranges
), 1))
1392 r
= ossl_quic_wire_decode_frame_ack(pkt
, 3, &f
, &total_ranges
);
1396 if (!TEST_uint64_t_eq(total_ranges
, peek_total_ranges
))
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
))
1402 if (!TEST_uint64_t_lt(f
.ack_ranges
[i
].end
, 1000))
1409 #define ACK_CASE(n, expect_fail, dec) \
1411 ack_case_##n##_input, \
1412 sizeof(ack_case_##n##_input), \
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
)
1427 static int test_wire_ack(int idx
)
1429 int testresult
= 0, r
;
1431 const struct ack_test_case
*c
= &ack_cases
[idx
];
1433 if (!TEST_int_eq(PACKET_buf_init(&pkt
,
1434 (unsigned char *)c
->input_buf
,
1435 c
->input_buf_len
), 1))
1438 r
= c
->deserializer(&pkt
);
1439 if (c
->expect_fail
) {
1440 if (!TEST_int_eq(r
, 0))
1443 if (!TEST_int_eq(r
, 1))
1446 if (!TEST_false(PACKET_remaining(&pkt
)))
1455 /* Packet Header PN Encoding Tests */
1457 QUIC_PN pn
, tx_largest_acked
, rx_largest_pn
;
1459 unsigned char expected_bytes
[4];
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} },
1486 static int test_wire_pkt_hdr_pn(int tidx
)
1489 const struct pn_test
*t
= &pn_tests
[tidx
];
1490 unsigned char buf
[4];
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
))
1498 if (!TEST_true(ossl_quic_wire_encode_pkt_hdr_pn(t
->pn
, buf
, pn_len
)))
1501 if (!TEST_mem_eq(t
->expected_bytes
, t
->expected_len
, buf
, pn_len
))
1504 if (!TEST_true(ossl_quic_wire_decode_pkt_hdr_pn(buf
, pn_len
,
1505 t
->rx_largest_pn
, &res_pn
)))
1508 if (!TEST_uint64_t_eq(res_pn
, t
->pn
))
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 }
1521 static const unsigned char retry_encoded
[] = {
1522 0xff, /* Long Header, Retry */
1523 0x00, 0x00, 0x00, 0x01, /* Version 1 */
1525 0x08, 0xf0, 0x67, 0xa5, 0x50, 0x2a, 0x42, 0x62, 0xb5, /* SCID */
1528 0x74, 0x6f, 0x6b, 0x65, 0x6e,
1530 /* Retry Integrity Tag */
1531 0x04, 0xa2, 0x65, 0xba, 0x2e, 0xff, 0x4d, 0x82, 0x90, 0x58, 0xfb, 0x3f, 0x0f,
1535 static int test_wire_retry_integrity_tag(void)
1539 QUIC_PKT_HDR hdr
= {0};
1540 unsigned char got_tag
[QUIC_RETRY_INTEGRITY_TAG_LEN
] = {0};
1542 if (!TEST_true(PACKET_buf_init(&pkt
, retry_encoded
, sizeof(retry_encoded
))))
1545 if (!TEST_true(ossl_quic_wire_decode_pkt_hdr(&pkt
, 0, 0, 0, &hdr
, NULL
)))
1548 if (!TEST_int_eq(hdr
.type
, QUIC_PKT_TYPE_RETRY
))
1551 if (!TEST_true(ossl_quic_calculate_retry_integrity_tag(NULL
, NULL
, &hdr
,
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
))
1562 if (!TEST_true(ossl_quic_validate_retry_integrity_tag(NULL
, NULL
, &hdr
,
1571 /* is_minimal=0 test */
1572 static const unsigned char non_minimal_1
[] = {
1576 static const unsigned char non_minimal_2
[] = {
1580 static const unsigned char non_minimal_3
[] = {
1581 0x80, 0x00, 0x00, 0x00,
1584 static const unsigned char non_minimal_4
[] = {
1585 0x80, 0x00, 0x3F, 0xFF,
1588 static const unsigned char non_minimal_5
[] = {
1589 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
1592 static const unsigned char non_minimal_6
[] = {
1593 0xC0, 0x00, 0x00, 0x00, 0x3F, 0xFF, 0xFF, 0xFF
1596 static const unsigned char *const non_minimal
[] = {
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
),
1614 static int test_wire_minimal(int idx
)
1618 uint64_t frame_type
;
1621 if (!TEST_true(PACKET_buf_init(&pkt
, non_minimal
[idx
],
1622 non_minimal_len
[idx
])))
1625 if (!TEST_true(ossl_quic_wire_peek_frame_header(&pkt
, &frame_type
,
1629 if (!TEST_false(is_minimal
))
1637 int setup_tests(void)
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
));