Debian Codegraph @

third_party/rust/neqo-http3/src/headers_checks.rs

raw
1 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
2 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
3 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
4 // option. This file may not be copied, modified, or distributed
5 // except according to those terms.
6
7 use enumset::{enum_set, EnumSet, EnumSetType};
8 use neqo_common::{header::HeadersExt as _, Header};
9
10 use crate::{Error, MessageType, Res};
11
12 #[derive(EnumSetType, Debug)]
13 enum PseudoHeaderState {
14 Status,
15 Method,
16 Scheme,
17 Authority,
18 Path,
19 Protocol,
20 Regular,
21 }
22
23 impl PseudoHeaderState {
24 fn is_pseudo(self) -> bool {
25 self != Self::Regular
26 }
27 }
28
29 impl TryFrom<(MessageType, &str)> for PseudoHeaderState {
30 type Error = Error;
31
32 fn try_from(v: (MessageType, &str)) -> Res<Self> {
33 match v {
34 (MessageType::Response, ":status") => Ok(Self::Status),
35 (MessageType::Request, ":method") => Ok(Self::Method),
36 (MessageType::Request, ":scheme") => Ok(Self::Scheme),
37 (MessageType::Request, ":authority") => Ok(Self::Authority),
38 (MessageType::Request, ":path") => Ok(Self::Path),
39 (MessageType::Request, ":protocol") => Ok(Self::Protocol),
40 (_, _) => Err(Error::InvalidHeader),
41 }
42 }
43 }
44
45 /// Check whether the response is informational(1xx).
46 ///
47 /// # Errors
48 ///
49 /// Returns an error if response headers do not contain
50 /// a status header or if the value of the header is 101 or cannot be parsed.
51 pub fn is_interim(headers: &[Header]) -> Res<bool> {
52 if let Some(h) = headers.iter().take(1).find_header(":status") {
53 let status_code = h.value().parse::<u16>().map_err(|_| Error::InvalidHeader)?;
54 if status_code == 101 {
55 // https://datatracker.ietf.org/doc/html/draft-ietf-quic-http#section-4.3
56 Err(Error::InvalidHeader)
57 } else {
58 Ok((100..200).contains(&status_code))
59 }
60 } else {
61 Err(Error::InvalidHeader)
62 }
63 }
64
65 fn track_pseudo(
66 name: &str,
67 result_state: &mut EnumSet<PseudoHeaderState>,
68 message_type: MessageType,
69 ) -> Res<bool> {
70 let new_state = if name.starts_with(':') {
71 if result_state.contains(PseudoHeaderState::Regular) {
72 return Err(Error::InvalidHeader);
73 }
74 PseudoHeaderState::try_from((message_type, name))?
75 } else {
76 PseudoHeaderState::Regular
77 };
78
79 let pseudo = new_state.is_pseudo();
80 if *result_state & new_state == EnumSet::empty() || !pseudo {
81 *result_state |= new_state;
82 Ok(pseudo)
83 } else {
84 Err(Error::InvalidHeader)
85 }
86 }
87
88 /// Checks if request/response headers are well formed, i.e. contain
89 /// allowed pseudo headers and in a right order, etc.
90 ///
91 /// # Errors
92 ///
93 /// Returns an error if headers are not well formed.
94 pub fn headers_valid(headers: &[Header], message_type: MessageType) -> Res<()> {
95 let mut method_value: Option<&str> = None;
96 let mut protocol_value: Option<&str> = None;
97 let mut scheme_value: Option<&str> = None;
98 let mut pseudo_state = EnumSet::new();
99 for header in headers {
100 let is_pseudo = track_pseudo(header.name(), &mut pseudo_state, message_type)?;
101
102 let mut bytes = header.name().bytes();
103 if is_pseudo {
104 if header.name() == ":method" {
105 method_value = Some(header.value());
106 } else if header.name() == ":protocol" {
107 protocol_value = Some(header.value());
108 } else if header.name() == ":scheme" {
109 scheme_value = Some(header.value());
110 }
111 _ = bytes.next();
112 }
113
114 if bytes.any(|b| matches!(b, 0 | 0x10 | 0x13 | 0x3a | 0x41..=0x5a)) {
115 return Err(Error::InvalidHeader); // illegal characters.
116 }
117 }
118 // Clear the regular header bit, since we only check pseudo headers below.
119 pseudo_state.remove(PseudoHeaderState::Regular);
120 let pseudo_header_mask = match message_type {
121 MessageType::Response => enum_set!(PseudoHeaderState::Status),
122 MessageType::Request => {
123 if method_value == Some("CONNECT") {
124 let connect_mask = PseudoHeaderState::Method | PseudoHeaderState::Authority;
125 if let Some(protocol) = protocol_value {
126 // For a webtransport CONNECT, the :scheme field must be set to https.
127 if protocol == "webtransport" && scheme_value != Some("https") {
128 return Err(Error::InvalidHeader);
129 }
130 // The CONNECT request for with :protocol included must have the scheme,
131 // authority, and path set.
132 connect_mask | PseudoHeaderState::Scheme | PseudoHeaderState::Path
133 } else {
134 connect_mask
135 }
136 } else {
137 PseudoHeaderState::Method | PseudoHeaderState::Scheme | PseudoHeaderState::Path
138 }
139 }
140 };
141
142 if (MessageType::Request == message_type)
143 && pseudo_state.contains(PseudoHeaderState::Protocol)
144 && method_value != Some("CONNECT")
145 {
146 return Err(Error::InvalidHeader);
147 }
148
149 if pseudo_state & pseudo_header_mask != pseudo_header_mask {
150 return Err(Error::InvalidHeader);
151 }
152
153 Ok(())
154 }
155
156 /// Checks if trailers are well formed, i.e. pseudo headers are not
157 /// allowed in trailers.
158 ///
159 /// # Errors
160 ///
161 /// Returns an error if trailers are not well formed.
162 pub fn trailers_valid(headers: &[Header]) -> Res<()> {
163 for header in headers {
164 if header.name().starts_with(':') {
165 return Err(Error::InvalidHeader);
166 }
167 }
168 Ok(())
169 }
170
171 #[cfg(test)]
172 mod tests {
173 use neqo_common::Header;
174
175 use super::headers_valid;
176 use crate::MessageType;
177
178 fn create_connect_headers() -> Vec<Header> {
179 vec![
180 Header::new(":method", "CONNECT"),
181 Header::new(":protocol", "webtransport"),
182 Header::new(":scheme", "https"),
183 Header::new(":authority", "something.com"),
184 Header::new(":path", "/here"),
185 ]
186 }
187
188 fn create_connect_headers_without_field(field: &str) -> Vec<Header> {
189 create_connect_headers()
190 .into_iter()
191 .filter(|header| header.name() != field)
192 .collect()
193 }
194
195 #[test]
196 fn connect_with_missing_header() {
197 for field in &[":scheme", ":path", ":authority"] {
198 assert!(headers_valid(
199 &create_connect_headers_without_field(field),
200 MessageType::Request
201 )
202 .is_err());
203 }
204 }
205
206 #[test]
207 fn invalid_scheme_webtransport_connect() {
208 assert!(headers_valid(
209 &[
210 Header::new(":method", "CONNECT"),
211 Header::new(":protocol", "webtransport"),
212 Header::new(":authority", "something.com"),
213 Header::new(":scheme", "http"),
214 Header::new(":path", "/here"),
215 ],
216 MessageType::Request
217 )
218 .is_err());
219 }
220
221 #[test]
222 fn valid_webtransport_connect() {
223 assert!(headers_valid(&create_connect_headers(), MessageType::Request).is_ok());
224 }
225
226 #[test]
227 fn invalid_webtransport_connect_with_status() {
228 assert!(headers_valid(
229 [
230 create_connect_headers(),
231 vec![Header::new(":status", "200")]
232 ]
233 .concat()
234 .as_slice(),
235 MessageType::Request
236 )
237 .is_err());
238 }
239 }