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 <openssl/macros.h>
11 #include <openssl/objects.h>
12 #include "internal/quic_ssl.h"
13 #include "internal/quic_vlint.h"
14 #include "internal/quic_wire.h"
15 #include "internal/quic_error.h"
17 OSSL_SAFE_MATH_UNSIGNED(uint64_t, uint64_t)
19 int ossl_quic_frame_ack_contains_pn(const OSSL_QUIC_FRAME_ACK
*ack
, QUIC_PN pn
)
23 for (i
= 0; i
< ack
->num_ack_ranges
; ++i
)
24 if (pn
>= ack
->ack_ranges
[i
].start
25 && pn
<= ack
->ack_ranges
[i
].end
)
32 * QUIC Wire Format Encoding
33 * =========================
36 int ossl_quic_wire_encode_padding(WPACKET
*pkt
, size_t num_bytes
)
39 * PADDING is frame type zero, which as a variable-length integer is
40 * represented as a single zero byte. As an optimisation, just use memset.
42 return WPACKET_memset(pkt
, 0, num_bytes
);
45 static int encode_frame_hdr(WPACKET
*pkt
, uint64_t frame_type
)
47 return WPACKET_quic_write_vlint(pkt
, frame_type
);
50 int ossl_quic_wire_encode_frame_ping(WPACKET
*pkt
)
52 return encode_frame_hdr(pkt
, OSSL_QUIC_FRAME_TYPE_PING
);
55 int ossl_quic_wire_encode_frame_ack(WPACKET
*pkt
,
56 uint32_t ack_delay_exponent
,
57 const OSSL_QUIC_FRAME_ACK
*ack
)
59 uint64_t frame_type
= ack
->ecn_present
? OSSL_QUIC_FRAME_TYPE_ACK_WITH_ECN
60 : OSSL_QUIC_FRAME_TYPE_ACK_WITHOUT_ECN
;
62 uint64_t largest_ackd
, first_ack_range
, ack_delay_enc
;
63 uint64_t i
, num_ack_ranges
= ack
->num_ack_ranges
;
66 if (num_ack_ranges
== 0)
69 delay
= ossl_time_divide(ossl_time_divide(ack
->delay_time
, OSSL_TIME_US
),
70 (uint64_t)1 << ack_delay_exponent
);
71 ack_delay_enc
= ossl_time2ticks(delay
);
73 largest_ackd
= ack
->ack_ranges
[0].end
;
74 first_ack_range
= ack
->ack_ranges
[0].end
- ack
->ack_ranges
[0].start
;
76 if (!encode_frame_hdr(pkt
, frame_type
)
77 || !WPACKET_quic_write_vlint(pkt
, largest_ackd
)
78 || !WPACKET_quic_write_vlint(pkt
, ack_delay_enc
)
79 || !WPACKET_quic_write_vlint(pkt
, num_ack_ranges
- 1)
80 || !WPACKET_quic_write_vlint(pkt
, first_ack_range
))
83 for (i
= 1; i
< num_ack_ranges
; ++i
) {
84 uint64_t gap
, range_len
;
86 gap
= ack
->ack_ranges
[i
- 1].start
- ack
->ack_ranges
[i
].end
- 2;
87 range_len
= ack
->ack_ranges
[i
].end
- ack
->ack_ranges
[i
].start
;
89 if (!WPACKET_quic_write_vlint(pkt
, gap
)
90 || !WPACKET_quic_write_vlint(pkt
, range_len
))
95 if (!WPACKET_quic_write_vlint(pkt
, ack
->ect0
)
96 || !WPACKET_quic_write_vlint(pkt
, ack
->ect1
)
97 || !WPACKET_quic_write_vlint(pkt
, ack
->ecnce
))
103 int ossl_quic_wire_encode_frame_reset_stream(WPACKET
*pkt
,
104 const OSSL_QUIC_FRAME_RESET_STREAM
*f
)
106 if (!encode_frame_hdr(pkt
, OSSL_QUIC_FRAME_TYPE_RESET_STREAM
)
107 || !WPACKET_quic_write_vlint(pkt
, f
->stream_id
)
108 || !WPACKET_quic_write_vlint(pkt
, f
->app_error_code
)
109 || !WPACKET_quic_write_vlint(pkt
, f
->final_size
))
115 int ossl_quic_wire_encode_frame_stop_sending(WPACKET
*pkt
,
116 const OSSL_QUIC_FRAME_STOP_SENDING
*f
)
118 if (!encode_frame_hdr(pkt
, OSSL_QUIC_FRAME_TYPE_STOP_SENDING
)
119 || !WPACKET_quic_write_vlint(pkt
, f
->stream_id
)
120 || !WPACKET_quic_write_vlint(pkt
, f
->app_error_code
))
126 int ossl_quic_wire_encode_frame_crypto_hdr(WPACKET
*pkt
,
127 const OSSL_QUIC_FRAME_CRYPTO
*f
)
129 if (!encode_frame_hdr(pkt
, OSSL_QUIC_FRAME_TYPE_CRYPTO
)
130 || !WPACKET_quic_write_vlint(pkt
, f
->offset
)
131 || !WPACKET_quic_write_vlint(pkt
, f
->len
))
137 size_t ossl_quic_wire_get_encoded_frame_len_crypto_hdr(const OSSL_QUIC_FRAME_CRYPTO
*f
)
141 a
= ossl_quic_vlint_encode_len(OSSL_QUIC_FRAME_TYPE_CRYPTO
);
142 b
= ossl_quic_vlint_encode_len(f
->offset
);
143 c
= ossl_quic_vlint_encode_len(f
->len
);
144 if (a
== 0 || b
== 0 || c
== 0)
150 void *ossl_quic_wire_encode_frame_crypto(WPACKET
*pkt
,
151 const OSSL_QUIC_FRAME_CRYPTO
*f
)
153 unsigned char *p
= NULL
;
155 if (!ossl_quic_wire_encode_frame_crypto_hdr(pkt
, f
)
156 || f
->len
> SIZE_MAX
/* sizeof(uint64_t) > sizeof(size_t)? */
157 || !WPACKET_allocate_bytes(pkt
, (size_t)f
->len
, &p
))
161 memcpy(p
, f
->data
, (size_t)f
->len
);
166 int ossl_quic_wire_encode_frame_new_token(WPACKET
*pkt
,
167 const unsigned char *token
,
170 if (!encode_frame_hdr(pkt
, OSSL_QUIC_FRAME_TYPE_NEW_TOKEN
)
171 || !WPACKET_quic_write_vlint(pkt
, token_len
)
172 || !WPACKET_memcpy(pkt
, token
, token_len
))
178 int ossl_quic_wire_encode_frame_stream_hdr(WPACKET
*pkt
,
179 const OSSL_QUIC_FRAME_STREAM
*f
)
181 uint64_t frame_type
= OSSL_QUIC_FRAME_TYPE_STREAM
;
184 frame_type
|= OSSL_QUIC_FRAME_FLAG_STREAM_OFF
;
185 if (f
->has_explicit_len
)
186 frame_type
|= OSSL_QUIC_FRAME_FLAG_STREAM_LEN
;
188 frame_type
|= OSSL_QUIC_FRAME_FLAG_STREAM_FIN
;
190 if (!encode_frame_hdr(pkt
, frame_type
)
191 || !WPACKET_quic_write_vlint(pkt
, f
->stream_id
))
194 if (f
->offset
!= 0 && !WPACKET_quic_write_vlint(pkt
, f
->offset
))
197 if (f
->has_explicit_len
&& !WPACKET_quic_write_vlint(pkt
, f
->len
))
203 size_t ossl_quic_wire_get_encoded_frame_len_stream_hdr(const OSSL_QUIC_FRAME_STREAM
*f
)
207 a
= ossl_quic_vlint_encode_len(OSSL_QUIC_FRAME_TYPE_STREAM
);
208 b
= ossl_quic_vlint_encode_len(f
->stream_id
);
209 if (a
== 0 || b
== 0)
213 c
= ossl_quic_vlint_encode_len(f
->offset
);
220 if (f
->has_explicit_len
) {
221 d
= ossl_quic_vlint_encode_len(f
->len
);
228 return a
+ b
+ c
+ d
;
231 void *ossl_quic_wire_encode_frame_stream(WPACKET
*pkt
,
232 const OSSL_QUIC_FRAME_STREAM
*f
)
235 unsigned char *p
= NULL
;
237 if (!ossl_quic_wire_encode_frame_stream_hdr(pkt
, f
)
238 || f
->len
> SIZE_MAX
/* sizeof(uint64_t) > sizeof(size_t)? */)
241 if (!WPACKET_allocate_bytes(pkt
, (size_t)f
->len
, &p
))
245 memcpy(p
, f
->data
, (size_t)f
->len
);
250 int ossl_quic_wire_encode_frame_max_data(WPACKET
*pkt
,
253 if (!encode_frame_hdr(pkt
, OSSL_QUIC_FRAME_TYPE_MAX_DATA
)
254 || !WPACKET_quic_write_vlint(pkt
, max_data
))
260 int ossl_quic_wire_encode_frame_max_stream_data(WPACKET
*pkt
,
264 if (!encode_frame_hdr(pkt
, OSSL_QUIC_FRAME_TYPE_MAX_STREAM_DATA
)
265 || !WPACKET_quic_write_vlint(pkt
, stream_id
)
266 || !WPACKET_quic_write_vlint(pkt
, max_data
))
272 int ossl_quic_wire_encode_frame_max_streams(WPACKET
*pkt
,
274 uint64_t max_streams
)
276 if (!encode_frame_hdr(pkt
, is_uni
? OSSL_QUIC_FRAME_TYPE_MAX_STREAMS_UNI
277 : OSSL_QUIC_FRAME_TYPE_MAX_STREAMS_BIDI
)
278 || !WPACKET_quic_write_vlint(pkt
, max_streams
))
284 int ossl_quic_wire_encode_frame_data_blocked(WPACKET
*pkt
,
287 if (!encode_frame_hdr(pkt
, OSSL_QUIC_FRAME_TYPE_DATA_BLOCKED
)
288 || !WPACKET_quic_write_vlint(pkt
, max_data
))
295 int ossl_quic_wire_encode_frame_stream_data_blocked(WPACKET
*pkt
,
297 uint64_t max_stream_data
)
299 if (!encode_frame_hdr(pkt
, OSSL_QUIC_FRAME_TYPE_STREAM_DATA_BLOCKED
)
300 || !WPACKET_quic_write_vlint(pkt
, stream_id
)
301 || !WPACKET_quic_write_vlint(pkt
, max_stream_data
))
307 int ossl_quic_wire_encode_frame_streams_blocked(WPACKET
*pkt
,
309 uint64_t max_streams
)
311 if (!encode_frame_hdr(pkt
, is_uni
? OSSL_QUIC_FRAME_TYPE_STREAMS_BLOCKED_UNI
312 : OSSL_QUIC_FRAME_TYPE_STREAMS_BLOCKED_BIDI
)
313 || !WPACKET_quic_write_vlint(pkt
, max_streams
))
319 int ossl_quic_wire_encode_frame_new_conn_id(WPACKET
*pkt
,
320 const OSSL_QUIC_FRAME_NEW_CONN_ID
*f
)
322 if (f
->conn_id
.id_len
< 1
323 || f
->conn_id
.id_len
> QUIC_MAX_CONN_ID_LEN
)
326 if (!encode_frame_hdr(pkt
, OSSL_QUIC_FRAME_TYPE_NEW_CONN_ID
)
327 || !WPACKET_quic_write_vlint(pkt
, f
->seq_num
)
328 || !WPACKET_quic_write_vlint(pkt
, f
->retire_prior_to
)
329 || !WPACKET_put_bytes_u8(pkt
, f
->conn_id
.id_len
)
330 || !WPACKET_memcpy(pkt
, f
->conn_id
.id
, f
->conn_id
.id_len
)
331 || !WPACKET_memcpy(pkt
, f
->stateless_reset
.token
,
332 sizeof(f
->stateless_reset
.token
)))
338 int ossl_quic_wire_encode_frame_retire_conn_id(WPACKET
*pkt
,
341 if (!encode_frame_hdr(pkt
, OSSL_QUIC_FRAME_TYPE_RETIRE_CONN_ID
)
342 || !WPACKET_quic_write_vlint(pkt
, seq_num
))
348 int ossl_quic_wire_encode_frame_path_challenge(WPACKET
*pkt
,
351 if (!encode_frame_hdr(pkt
, OSSL_QUIC_FRAME_TYPE_PATH_CHALLENGE
)
352 || !WPACKET_put_bytes_u64(pkt
, data
))
358 int ossl_quic_wire_encode_frame_path_response(WPACKET
*pkt
,
361 if (!encode_frame_hdr(pkt
, OSSL_QUIC_FRAME_TYPE_PATH_RESPONSE
)
362 || !WPACKET_put_bytes_u64(pkt
, data
))
368 int ossl_quic_wire_encode_frame_conn_close(WPACKET
*pkt
,
369 const OSSL_QUIC_FRAME_CONN_CLOSE
*f
)
371 if (!encode_frame_hdr(pkt
, f
->is_app
? OSSL_QUIC_FRAME_TYPE_CONN_CLOSE_APP
372 : OSSL_QUIC_FRAME_TYPE_CONN_CLOSE_TRANSPORT
)
373 || !WPACKET_quic_write_vlint(pkt
, f
->error_code
))
377 * RFC 9000 s. 19.19: The application-specific variant of CONNECTION_CLOSE
378 * (type 0x1d) does not include this field.
380 if (!f
->is_app
&& !WPACKET_quic_write_vlint(pkt
, f
->frame_type
))
383 if (!WPACKET_quic_write_vlint(pkt
, f
->reason_len
)
384 || !WPACKET_memcpy(pkt
, f
->reason
, f
->reason_len
))
390 int ossl_quic_wire_encode_frame_handshake_done(WPACKET
*pkt
)
392 return encode_frame_hdr(pkt
, OSSL_QUIC_FRAME_TYPE_HANDSHAKE_DONE
);
395 unsigned char *ossl_quic_wire_encode_transport_param_bytes(WPACKET
*pkt
,
397 const unsigned char *value
,
400 unsigned char *b
= NULL
;
402 if (!WPACKET_quic_write_vlint(pkt
, id
)
403 || !WPACKET_quic_write_vlint(pkt
, value_len
))
407 b
= WPACKET_get_curr(pkt
);
408 else if (!WPACKET_allocate_bytes(pkt
, value_len
, (unsigned char **)&b
))
412 memcpy(b
, value
, value_len
);
417 int ossl_quic_wire_encode_transport_param_int(WPACKET
*pkt
,
421 if (!WPACKET_quic_write_vlint(pkt
, id
)
422 || !WPACKET_quic_write_vlint(pkt
, ossl_quic_vlint_encode_len(value
))
423 || !WPACKET_quic_write_vlint(pkt
, value
))
429 int ossl_quic_wire_encode_transport_param_cid(WPACKET
*wpkt
,
431 const QUIC_CONN_ID
*cid
)
433 if (cid
->id_len
> QUIC_MAX_CONN_ID_LEN
)
436 if (ossl_quic_wire_encode_transport_param_bytes(wpkt
, id
,
438 cid
->id_len
) == NULL
)
445 * QUIC Wire Format Decoding
446 * =========================
448 int ossl_quic_wire_peek_frame_header(PACKET
*pkt
, uint64_t *type
,
451 return PACKET_peek_quic_vlint_ex(pkt
, type
, was_minimal
);
454 int ossl_quic_wire_skip_frame_header(PACKET
*pkt
, uint64_t *type
)
456 return PACKET_get_quic_vlint(pkt
, type
);
459 static int expect_frame_header_mask(PACKET
*pkt
,
460 uint64_t expected_frame_type
,
462 uint64_t *actual_frame_type
)
464 uint64_t actual_frame_type_
;
466 if (!ossl_quic_wire_skip_frame_header(pkt
, &actual_frame_type_
)
467 || (actual_frame_type_
& ~mask_bits
) != expected_frame_type
)
470 if (actual_frame_type
!= NULL
)
471 *actual_frame_type
= actual_frame_type_
;
476 static int expect_frame_header(PACKET
*pkt
, uint64_t expected_frame_type
)
478 uint64_t actual_frame_type
;
480 if (!ossl_quic_wire_skip_frame_header(pkt
, &actual_frame_type
)
481 || actual_frame_type
!= expected_frame_type
)
487 int ossl_quic_wire_peek_frame_ack_num_ranges(const PACKET
*orig_pkt
,
488 uint64_t *total_ranges
)
490 PACKET pkt
= *orig_pkt
;
491 uint64_t ack_range_count
, i
;
493 if (!expect_frame_header_mask(&pkt
, OSSL_QUIC_FRAME_TYPE_ACK_WITHOUT_ECN
,
495 || !PACKET_skip_quic_vlint(&pkt
)
496 || !PACKET_skip_quic_vlint(&pkt
)
497 || !PACKET_get_quic_vlint(&pkt
, &ack_range_count
))
501 * Ensure the specified number of ack ranges listed in the ACK frame header
502 * actually are available in the frame data. This naturally bounds the
503 * number of ACK ranges which can be requested by the MDPL, and therefore by
504 * the MTU. This ensures we do not allocate memory for an excessive number
507 for (i
= 0; i
< ack_range_count
; ++i
)
508 if (!PACKET_skip_quic_vlint(&pkt
)
509 || !PACKET_skip_quic_vlint(&pkt
))
512 /* (cannot overflow because QUIC vlints can only encode up to 2**62-1) */
513 *total_ranges
= ack_range_count
+ 1;
517 int ossl_quic_wire_decode_frame_ack(PACKET
*pkt
,
518 uint32_t ack_delay_exponent
,
519 OSSL_QUIC_FRAME_ACK
*ack
,
520 uint64_t *total_ranges
) {
521 uint64_t frame_type
, largest_ackd
, ack_delay_raw
;
522 uint64_t ack_range_count
, first_ack_range
, start
, end
, i
;
524 /* This call matches both ACK_WITHOUT_ECN and ACK_WITH_ECN. */
525 if (!expect_frame_header_mask(pkt
, OSSL_QUIC_FRAME_TYPE_ACK_WITHOUT_ECN
,
527 || !PACKET_get_quic_vlint(pkt
, &largest_ackd
)
528 || !PACKET_get_quic_vlint(pkt
, &ack_delay_raw
)
529 || !PACKET_get_quic_vlint(pkt
, &ack_range_count
)
530 || !PACKET_get_quic_vlint(pkt
, &first_ack_range
))
533 if (first_ack_range
> largest_ackd
)
536 if (ack_range_count
> SIZE_MAX
/* sizeof(uint64_t) > sizeof(size_t)? */)
539 start
= largest_ackd
- first_ack_range
;
544 = ossl_time_multiply(ossl_ticks2time(OSSL_TIME_US
),
545 safe_mul_uint64_t(ack_delay_raw
,
546 (uint64_t)1 << ack_delay_exponent
,
549 ack
->delay_time
= ossl_time_infinite();
551 if (ack
->num_ack_ranges
> 0) {
552 ack
->ack_ranges
[0].end
= largest_ackd
;
553 ack
->ack_ranges
[0].start
= start
;
557 for (i
= 0; i
< ack_range_count
; ++i
) {
560 if (!PACKET_get_quic_vlint(pkt
, &gap
)
561 || !PACKET_get_quic_vlint(pkt
, &len
))
564 end
= start
- gap
- 2;
565 if (start
< gap
+ 2 || len
> end
)
568 if (ack
!= NULL
&& i
+ 1 < ack
->num_ack_ranges
) {
569 ack
->ack_ranges
[i
+ 1].start
= start
= end
- len
;
570 ack
->ack_ranges
[i
+ 1].end
= end
;
574 if (ack
!= NULL
&& ack_range_count
+ 1 < ack
->num_ack_ranges
)
575 ack
->num_ack_ranges
= (size_t)ack_range_count
+ 1;
577 if (total_ranges
!= NULL
)
578 *total_ranges
= ack_range_count
+ 1;
580 if (frame_type
== OSSL_QUIC_FRAME_TYPE_ACK_WITH_ECN
) {
581 uint64_t ect0
, ect1
, ecnce
;
583 if (!PACKET_get_quic_vlint(pkt
, &ect0
)
584 || !PACKET_get_quic_vlint(pkt
, &ect1
)
585 || !PACKET_get_quic_vlint(pkt
, &ecnce
))
592 ack
->ecn_present
= 1;
594 } else if (ack
!= NULL
) {
595 ack
->ecn_present
= 0;
601 int ossl_quic_wire_decode_frame_reset_stream(PACKET
*pkt
,
602 OSSL_QUIC_FRAME_RESET_STREAM
*f
)
604 if (!expect_frame_header(pkt
, OSSL_QUIC_FRAME_TYPE_RESET_STREAM
)
605 || !PACKET_get_quic_vlint(pkt
, &f
->stream_id
)
606 || !PACKET_get_quic_vlint(pkt
, &f
->app_error_code
)
607 || !PACKET_get_quic_vlint(pkt
, &f
->final_size
))
613 int ossl_quic_wire_decode_frame_stop_sending(PACKET
*pkt
,
614 OSSL_QUIC_FRAME_STOP_SENDING
*f
)
616 if (!expect_frame_header(pkt
, OSSL_QUIC_FRAME_TYPE_STOP_SENDING
)
617 || !PACKET_get_quic_vlint(pkt
, &f
->stream_id
)
618 || !PACKET_get_quic_vlint(pkt
, &f
->app_error_code
))
624 int ossl_quic_wire_decode_frame_crypto(PACKET
*pkt
,
626 OSSL_QUIC_FRAME_CRYPTO
*f
)
628 if (!expect_frame_header(pkt
, OSSL_QUIC_FRAME_TYPE_CRYPTO
)
629 || !PACKET_get_quic_vlint(pkt
, &f
->offset
)
630 || !PACKET_get_quic_vlint(pkt
, &f
->len
)
631 || f
->len
> SIZE_MAX
/* sizeof(uint64_t) > sizeof(size_t)? */)
634 if (f
->offset
+ f
->len
> (((uint64_t)1) << 62) - 1)
635 /* RFC 9000 s. 19.6 */
641 if (PACKET_remaining(pkt
) < f
->len
)
644 f
->data
= PACKET_data(pkt
);
646 if (!PACKET_forward(pkt
, (size_t)f
->len
))
653 int ossl_quic_wire_decode_frame_new_token(PACKET
*pkt
,
654 const unsigned char **token
,
659 if (!expect_frame_header(pkt
, OSSL_QUIC_FRAME_TYPE_NEW_TOKEN
)
660 || !PACKET_get_quic_vlint(pkt
, &token_len_
))
663 if (token_len_
> SIZE_MAX
)
666 *token
= PACKET_data(pkt
);
667 *token_len
= (size_t)token_len_
;
669 if (!PACKET_forward(pkt
, (size_t)token_len_
))
675 int ossl_quic_wire_decode_frame_stream(PACKET
*pkt
,
677 OSSL_QUIC_FRAME_STREAM
*f
)
681 /* This call matches all STREAM values (low 3 bits are masked). */
682 if (!expect_frame_header_mask(pkt
, OSSL_QUIC_FRAME_TYPE_STREAM
,
683 OSSL_QUIC_FRAME_FLAG_STREAM_MASK
,
685 || !PACKET_get_quic_vlint(pkt
, &f
->stream_id
))
688 if ((frame_type
& OSSL_QUIC_FRAME_FLAG_STREAM_OFF
) != 0) {
689 if (!PACKET_get_quic_vlint(pkt
, &f
->offset
))
695 f
->has_explicit_len
= ((frame_type
& OSSL_QUIC_FRAME_FLAG_STREAM_LEN
) != 0);
696 f
->is_fin
= ((frame_type
& OSSL_QUIC_FRAME_FLAG_STREAM_FIN
) != 0);
698 if (f
->has_explicit_len
) {
699 if (!PACKET_get_quic_vlint(pkt
, &f
->len
))
705 f
->len
= PACKET_remaining(pkt
);
709 * RFC 9000 s. 19.8: "The largest offset delivered on a stream -- the sum of
710 * the offset and data length -- cannot exceed 2**62 - 1, as it is not
711 * possible to provide flow control credit for that data."
713 if (f
->offset
+ f
->len
> (((uint64_t)1) << 62) - 1)
719 f
->data
= PACKET_data(pkt
);
721 if (f
->len
> SIZE_MAX
/* sizeof(uint64_t) > sizeof(size_t)? */
722 || !PACKET_forward(pkt
, (size_t)f
->len
))
729 int ossl_quic_wire_decode_frame_max_data(PACKET
*pkt
,
732 if (!expect_frame_header(pkt
, OSSL_QUIC_FRAME_TYPE_MAX_DATA
)
733 || !PACKET_get_quic_vlint(pkt
, max_data
))
739 int ossl_quic_wire_decode_frame_max_stream_data(PACKET
*pkt
,
741 uint64_t *max_stream_data
)
743 if (!expect_frame_header(pkt
, OSSL_QUIC_FRAME_TYPE_MAX_STREAM_DATA
)
744 || !PACKET_get_quic_vlint(pkt
, stream_id
)
745 || !PACKET_get_quic_vlint(pkt
, max_stream_data
))
751 int ossl_quic_wire_decode_frame_max_streams(PACKET
*pkt
,
752 uint64_t *max_streams
)
754 /* This call matches both MAX_STREAMS_BIDI and MAX_STREAMS_UNI. */
755 if (!expect_frame_header_mask(pkt
, OSSL_QUIC_FRAME_TYPE_MAX_STREAMS_BIDI
,
757 || !PACKET_get_quic_vlint(pkt
, max_streams
))
763 int ossl_quic_wire_decode_frame_data_blocked(PACKET
*pkt
,
766 if (!expect_frame_header(pkt
, OSSL_QUIC_FRAME_TYPE_DATA_BLOCKED
)
767 || !PACKET_get_quic_vlint(pkt
, max_data
))
773 int ossl_quic_wire_decode_frame_stream_data_blocked(PACKET
*pkt
,
775 uint64_t *max_stream_data
)
777 if (!expect_frame_header(pkt
, OSSL_QUIC_FRAME_TYPE_STREAM_DATA_BLOCKED
)
778 || !PACKET_get_quic_vlint(pkt
, stream_id
)
779 || !PACKET_get_quic_vlint(pkt
, max_stream_data
))
785 int ossl_quic_wire_decode_frame_streams_blocked(PACKET
*pkt
,
786 uint64_t *max_streams
)
788 /* This call matches both STREAMS_BLOCKED_BIDI and STREAMS_BLOCKED_UNI. */
789 if (!expect_frame_header_mask(pkt
, OSSL_QUIC_FRAME_TYPE_STREAMS_BLOCKED_BIDI
,
791 || !PACKET_get_quic_vlint(pkt
, max_streams
))
797 int ossl_quic_wire_decode_frame_new_conn_id(PACKET
*pkt
,
798 OSSL_QUIC_FRAME_NEW_CONN_ID
*f
)
802 if (!expect_frame_header(pkt
, OSSL_QUIC_FRAME_TYPE_NEW_CONN_ID
)
803 || !PACKET_get_quic_vlint(pkt
, &f
->seq_num
)
804 || !PACKET_get_quic_vlint(pkt
, &f
->retire_prior_to
)
805 || f
->seq_num
< f
->retire_prior_to
806 || !PACKET_get_1(pkt
, &len
)
808 || len
> QUIC_MAX_CONN_ID_LEN
)
811 f
->conn_id
.id_len
= (unsigned char)len
;
812 if (!PACKET_copy_bytes(pkt
, f
->conn_id
.id
, len
))
815 /* Clear unused bytes to allow consistent memcmp. */
816 if (len
< QUIC_MAX_CONN_ID_LEN
)
817 memset(f
->conn_id
.id
+ len
, 0, QUIC_MAX_CONN_ID_LEN
- len
);
819 if (!PACKET_copy_bytes(pkt
, f
->stateless_reset
.token
,
820 sizeof(f
->stateless_reset
.token
)))
826 int ossl_quic_wire_decode_frame_retire_conn_id(PACKET
*pkt
,
829 if (!expect_frame_header(pkt
, OSSL_QUIC_FRAME_TYPE_RETIRE_CONN_ID
)
830 || !PACKET_get_quic_vlint(pkt
, seq_num
))
836 int ossl_quic_wire_decode_frame_path_challenge(PACKET
*pkt
,
839 if (!expect_frame_header(pkt
, OSSL_QUIC_FRAME_TYPE_PATH_CHALLENGE
)
840 || !PACKET_get_net_8(pkt
, data
))
846 int ossl_quic_wire_decode_frame_path_response(PACKET
*pkt
,
849 if (!expect_frame_header(pkt
, OSSL_QUIC_FRAME_TYPE_PATH_RESPONSE
)
850 || !PACKET_get_net_8(pkt
, data
))
856 int ossl_quic_wire_decode_frame_conn_close(PACKET
*pkt
,
857 OSSL_QUIC_FRAME_CONN_CLOSE
*f
)
859 uint64_t frame_type
, reason_len
;
861 /* This call matches both CONN_CLOSE_TRANSPORT and CONN_CLOSE_APP. */
862 if (!expect_frame_header_mask(pkt
, OSSL_QUIC_FRAME_TYPE_CONN_CLOSE_TRANSPORT
,
864 || !PACKET_get_quic_vlint(pkt
, &f
->error_code
))
867 f
->is_app
= ((frame_type
& 1) != 0);
870 if (!PACKET_get_quic_vlint(pkt
, &f
->frame_type
))
876 if (!PACKET_get_quic_vlint(pkt
, &reason_len
)
877 || reason_len
> SIZE_MAX
)
880 if (!PACKET_get_bytes(pkt
, (const unsigned char **)&f
->reason
,
884 f
->reason_len
= (size_t)reason_len
;
888 size_t ossl_quic_wire_decode_padding(PACKET
*pkt
)
890 const unsigned char *start
= PACKET_data(pkt
), *end
= PACKET_end(pkt
),
893 while (p
< end
&& *p
== 0)
896 if (!PACKET_forward(pkt
, p
- start
))
902 int ossl_quic_wire_decode_frame_ping(PACKET
*pkt
)
904 return expect_frame_header(pkt
, OSSL_QUIC_FRAME_TYPE_PING
);
907 int ossl_quic_wire_decode_frame_handshake_done(PACKET
*pkt
)
909 return expect_frame_header(pkt
, OSSL_QUIC_FRAME_TYPE_HANDSHAKE_DONE
);
912 int ossl_quic_wire_peek_transport_param(PACKET
*pkt
, uint64_t *id
)
914 return PACKET_peek_quic_vlint(pkt
, id
);
917 const unsigned char *ossl_quic_wire_decode_transport_param_bytes(PACKET
*pkt
,
922 const unsigned char *b
= NULL
;
925 if (!PACKET_get_quic_vlint(pkt
, &id_
)
926 || !PACKET_get_quic_vlint(pkt
, &len_
))
930 || !PACKET_get_bytes(pkt
, (const unsigned char **)&b
, (size_t)len_
))
939 int ossl_quic_wire_decode_transport_param_int(PACKET
*pkt
,
945 sub
.curr
= ossl_quic_wire_decode_transport_param_bytes(pkt
,
947 if (sub
.curr
== NULL
)
950 if (!PACKET_get_quic_vlint(&sub
, value
))
956 int ossl_quic_wire_decode_transport_param_cid(PACKET
*pkt
,
960 const unsigned char *body
;
963 body
= ossl_quic_wire_decode_transport_param_bytes(pkt
, id
, &len
);
964 if (body
== NULL
|| len
> QUIC_MAX_CONN_ID_LEN
)
967 cid
->id_len
= (unsigned char)len
;
968 memcpy(cid
->id
, body
, cid
->id_len
);
972 int ossl_quic_wire_decode_transport_param_preferred_addr(PACKET
*pkt
,
973 QUIC_PREFERRED_ADDR
*p
)
975 const unsigned char *body
;
979 unsigned int ipv4_port
, ipv6_port
, cidl
;
981 body
= ossl_quic_wire_decode_transport_param_bytes(pkt
, &id
, &len
);
983 || len
< QUIC_MIN_ENCODED_PREFERRED_ADDR_LEN
984 || len
> QUIC_MAX_ENCODED_PREFERRED_ADDR_LEN
985 || id
!= QUIC_TPARAM_PREFERRED_ADDR
)
988 if (!PACKET_buf_init(&pkt2
, body
, len
))
991 if (!PACKET_copy_bytes(&pkt2
, p
->ipv4
, sizeof(p
->ipv4
))
992 || !PACKET_get_net_2(&pkt2
, &ipv4_port
)
993 || !PACKET_copy_bytes(&pkt2
, p
->ipv6
, sizeof(p
->ipv6
))
994 || !PACKET_get_net_2(&pkt2
, &ipv6_port
)
995 || !PACKET_get_1(&pkt2
, &cidl
)
996 || cidl
> QUIC_MAX_CONN_ID_LEN
997 || !PACKET_copy_bytes(&pkt2
, p
->cid
.id
, cidl
)
998 || !PACKET_copy_bytes(&pkt2
, p
->stateless_reset
.token
,
999 sizeof(p
->stateless_reset
.token
)))
1002 p
->ipv4_port
= (uint16_t)ipv4_port
;
1003 p
->ipv6_port
= (uint16_t)ipv6_port
;
1004 p
->cid
.id_len
= (unsigned char)cidl
;
1009 ossl_quic_frame_type_to_string(uint64_t frame_type
)
1011 switch (frame_type
) {
1012 #define X(name) case OSSL_QUIC_FRAME_TYPE_##name: return #name;
1026 X(STREAM_DATA_BLOCKED
)
1027 X(STREAMS_BLOCKED_BIDI
)
1028 X(STREAMS_BLOCKED_UNI
)
1033 X(CONN_CLOSE_TRANSPORT
)
1043 X(STREAM_OFF_LEN_FIN
)
1050 const char *ossl_quic_err_to_string(uint64_t error_code
)
1052 switch (error_code
) {
1053 #define X(name) case QUIC_ERR_##name: return #name;
1056 X(CONNECTION_REFUSED
)
1057 X(FLOW_CONTROL_ERROR
)
1058 X(STREAM_LIMIT_ERROR
)
1059 X(STREAM_STATE_ERROR
)
1061 X(FRAME_ENCODING_ERROR
)
1062 X(TRANSPORT_PARAMETER_ERROR
)
1063 X(CONNECTION_ID_LIMIT_ERROR
)
1064 X(PROTOCOL_VIOLATION
)
1066 X(APPLICATION_ERROR
)
1067 X(CRYPTO_BUFFER_EXCEEDED
)
1069 X(AEAD_LIMIT_REACHED
)