parse_net/
origin.rs

1//! `Origin` (RFC 6454 section 7): `null` or `scheme "://" host [ ":" port ]`.
2//!
3//! # Examples
4//!
5//! ```
6//! use parse_net::{self as pn, OriginValue};
7//!
8//! let OriginValue::Origin(a) = pn::parse_origin(b"https://app.example.com")? else { unreachable!() };
9//! let OriginValue::Origin(b) = pn::parse_origin(b"HTTPS://APP.example.com:443")? else { unreachable!() };
10//! assert!(a.same_origin(&b));
11//! let OriginValue::Origin(evil) = pn::parse_origin(b"https://app.example.com.evil.test")? else { unreachable!() };
12//! assert!(!a.same_origin(&evil));
13//! assert_eq!(pn::parse_origin(b"https://app.example.com/").unwrap_err().kind(), pn::ErrorKind::InvalidOrigin);
14//! # Ok::<(), pn::ParseError>(())
15//! ```
16
17use crate::{
18    error::{ErrorKind, ParseError, Result, WriteError, err},
19    host::{Host, HostPort, host_port},
20    text::{skip_ows, trim_ows},
21    write::{CountSink, Sink, reserve, write_decimal_u64},
22};
23
24/// An `Origin` value.
25///
26/// # Examples
27///
28/// ```
29/// use parse_net::{parse_origin, OriginValue};
30///
31/// assert_eq!(parse_origin(b"null")?, OriginValue::Null);
32/// assert!(matches!(parse_origin(b"https://example.com")?, OriginValue::Origin(_)));
33/// # Ok::<(), parse_net::ParseError>(())
34/// ```
35#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
36pub enum OriginValue<'a> {
37    /// `null` (an opaque origin: a sandboxed frame, a `data:` URL, a
38    /// privacy-sensitive redirect).
39    Null,
40    /// A serialized origin.
41    Origin(Origin<'a>),
42}
43
44/// A serialized origin.
45///
46/// # Examples
47///
48/// ```
49/// use parse_net::{parse_origin, Host, OriginValue};
50///
51/// let OriginValue::Origin(o) = parse_origin(b"http://example.com:8080")? else { unreachable!() };
52/// assert_eq!(o.scheme, b"http");
53/// assert_eq!((o.host, o.port), (Host::Name(b"example.com"), Some(8080)));
54/// # Ok::<(), parse_net::ParseError>(())
55/// ```
56#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
57pub struct Origin<'a> {
58    /// The scheme as sent (compare it ASCII case-insensitively).
59    pub scheme: &'a [u8],
60    /// The host.
61    pub host: Host<'a>,
62    /// The port, when one was given.
63    pub port: Option<u16>,
64}
65
66impl Origin<'_> {
67    /// The port, or the scheme's default: 80 for `http` and `ws`, 443 for
68    /// `https` and `wss`; `None` for another scheme without a port.
69    ///
70    /// # Examples
71    ///
72    /// ```
73    /// use parse_net::{parse_origin, OriginValue};
74    ///
75    /// let OriginValue::Origin(o) = parse_origin(b"wss://chat.example")? else { unreachable!() };
76    /// assert_eq!(o.effective_port(), Some(443));
77    /// # Ok::<(), parse_net::ParseError>(())
78    /// ```
79    #[must_use]
80    pub fn effective_port(&self) -> Option<u16> {
81        self.port.or_else(|| {
82            let s = self.scheme;
83            if s.eq_ignore_ascii_case(b"http") || s.eq_ignore_ascii_case(b"ws") {
84                Some(80)
85            } else if s.eq_ignore_ascii_case(b"https") || s.eq_ignore_ascii_case(b"wss") {
86                Some(443)
87            } else {
88                None
89            }
90        })
91    }
92
93    /// Whether two origins are the same: schemes and hosts equal as whole
94    /// values (ASCII case-insensitive, IP literals by value), effective ports
95    /// equal. Never a prefix or suffix comparison.
96    ///
97    /// # Examples
98    ///
99    /// ```
100    /// use parse_net::{parse_origin, OriginValue};
101    ///
102    /// let OriginValue::Origin(a) = parse_origin(b"http://example.com")? else { unreachable!() };
103    /// let OriginValue::Origin(b) = parse_origin(b"HTTP://EXAMPLE.com:80")? else { unreachable!() };
104    /// let OriginValue::Origin(c) = parse_origin(b"https://example.com")? else { unreachable!() };
105    /// assert!(a.same_origin(&b) && !a.same_origin(&c));
106    /// # Ok::<(), parse_net::ParseError>(())
107    /// ```
108    #[must_use]
109    pub fn same_origin(&self, other: &Origin<'_>) -> bool {
110        self.scheme.eq_ignore_ascii_case(other.scheme)
111            && self.host.eq_ignore_ascii_case(&other.host)
112            && self.effective_port() == other.effective_port()
113    }
114
115    /// Writes the origin with a lowercase scheme and without a default port.
116    ///
117    /// # Errors
118    ///
119    /// [`WriteError::Full`]; nothing is written when the sink reports its
120    /// room.
121    ///
122    /// # Examples
123    ///
124    /// ```
125    /// use parse_net::{parse_origin, OriginValue, SliceSink};
126    ///
127    /// let OriginValue::Origin(o) = parse_origin(b"HTTPS://a.example:443")? else { unreachable!() };
128    /// let mut buf = [0u8; 64];
129    /// let mut out = SliceSink::new(&mut buf);
130    /// o.write_to(&mut out).expect("room");
131    /// assert_eq!(out.written(), b"https://a.example");
132    /// # Ok::<(), parse_net::ParseError>(())
133    /// ```
134    pub fn write_to(&self, out: &mut impl Sink) -> core::result::Result<(), WriteError> {
135        let mut count = CountSink::new();
136        self.put(&mut count)?;
137        reserve(out, count.count())?;
138        self.put(out)
139    }
140
141    fn put(&self, out: &mut impl Sink) -> core::result::Result<(), WriteError> {
142        let mut scheme = [0u8; 32];
143        for chunk in self.scheme.chunks(scheme.len()) {
144            let dst = scheme.get_mut(..chunk.len()).unwrap_or(&mut []);
145            for (d, &c) in dst.iter_mut().zip(chunk) {
146                *d = c.to_ascii_lowercase();
147            }
148            out.put(dst)?;
149        }
150        out.put(b"://")?;
151        HostPort {
152            host: self.host,
153            port: None,
154            empty_port: false,
155        }
156        .write_to(out)?;
157        let default = Origin {
158            port: None,
159            ..*self
160        }
161        .effective_port();
162        if let Some(p) = self.port.filter(|&p| Some(p) != default) {
163            out.put(b":")?;
164            write_decimal_u64(u64::from(p), out)?;
165        }
166        Ok(())
167    }
168}
169
170/// Parses an `Origin` value.
171///
172/// `null` is case-sensitive. The scheme is a letter followed by letters,
173/// digits, `+`, `-`, or `.`; the host follows the `Host` rules and may not
174/// be empty; a path, query, fragment, trailing `/`, userinfo, or empty port
175/// is refused.
176///
177/// # Errors
178///
179/// [`ErrorKind::InvalidOrigin`]; the `Host` errors for the host part.
180///
181/// # Examples
182///
183/// ```
184/// use parse_net::{parse_origin, OriginValue};
185///
186/// assert_eq!(parse_origin(b"null")?, OriginValue::Null);
187/// assert!(parse_origin(b"Null").is_err());
188/// # Ok::<(), parse_net::ParseError>(())
189/// ```
190pub fn parse_origin(value: &[u8]) -> Result<OriginValue<'_>> {
191    let lead = skip_ows(value);
192    let v = trim_ows(value);
193    if v == b"null" {
194        return Ok(OriginValue::Null);
195    }
196    let scheme_len = v
197        .iter()
198        .take_while(|&&b| b.is_ascii_alphanumeric() || matches!(b, b'+' | b'-' | b'.'))
199        .count();
200    if scheme_len == 0 || !v.first().is_some_and(u8::is_ascii_alphabetic) {
201        return err(ErrorKind::InvalidOrigin, lead);
202    }
203    let scheme = v.get(..scheme_len).unwrap_or(&[]);
204    if v.get(scheme_len..scheme_len + 3) != Some(b"://") {
205        return err(ErrorKind::InvalidOrigin, lead + scheme_len);
206    }
207    let authority_at = scheme_len + 3;
208    let authority = v.get(authority_at..).unwrap_or(&[]);
209    if let Some(i) = authority
210        .iter()
211        .position(|&b| matches!(b, b'/' | b'?' | b'#'))
212    {
213        return err(ErrorKind::InvalidOrigin, lead + authority_at + i);
214    }
215    let hp = host_port(authority).map_err(|e: ParseError| e.shifted(lead + authority_at))?;
216    if hp.host.is_empty() || hp.empty_port {
217        return err(ErrorKind::InvalidOrigin, lead + authority_at);
218    }
219    Ok(OriginValue::Origin(Origin {
220        scheme,
221        host: hp.host,
222        port: hp.port,
223    }))
224}
225
226#[cfg(test)]
227mod tests {
228    use super::*;
229
230    fn o(v: &[u8]) -> Origin<'_> {
231        match parse_origin(v).unwrap() {
232            OriginValue::Origin(o) => o,
233            OriginValue::Null => panic!("null"),
234        }
235    }
236
237    #[test]
238    fn test_origin_edge_cases() {
239        let k = |v: &[u8]| parse_origin(v).unwrap_err().kind();
240        assert_eq!(k(b"Null"), ErrorKind::InvalidOrigin);
241        assert_eq!(o(b"https://a.com").port, None);
242        assert_eq!(o(b"https://a.com:443").port, Some(443));
243        assert_eq!(k(b"https://a.com/"), ErrorKind::InvalidOrigin);
244        assert_eq!(k(b"https://a.com:"), ErrorKind::InvalidOrigin);
245        assert_eq!(k(b"https://user@a.com"), ErrorKind::InvalidHost);
246        assert_eq!(o(b"HTTPS://A.COM").scheme, b"HTTPS");
247        assert_eq!(k(b"file://"), ErrorKind::InvalidOrigin);
248        assert_eq!(k(b"https:a.com"), ErrorKind::InvalidOrigin);
249        assert_eq!(k(b"1https://a.com"), ErrorKind::InvalidOrigin);
250        assert_eq!(k(b"https://a.com?x"), ErrorKind::InvalidOrigin);
251        assert_eq!(k(b""), ErrorKind::InvalidOrigin);
252        assert!(matches!(o(b"http://[::1]:8080").host, Host::V6(_)));
253        let long = [b"https://".as_slice(), &[b'a'; 4096]].concat();
254        assert!(parse_origin(&long).is_ok());
255    }
256
257    #[test]
258    fn test_origin_suffix_attack_not_same() {
259        let a = o(b"https://example.com");
260        assert!(!a.same_origin(&o(b"https://example.com.evil.test")));
261        assert!(!a.same_origin(&o(b"https://evilexample.com")));
262        assert!(!a.same_origin(&o(b"http://example.com")));
263        assert!(!a.same_origin(&o(b"https://example.com:8443")));
264        assert!(a.same_origin(&o(b"https://EXAMPLE.com:443")));
265    }
266
267    #[test]
268    fn test_origin_trailing_slash_refused() {
269        assert_eq!(
270            parse_origin(b"https://example.com/").unwrap_err().kind(),
271            ErrorKind::InvalidOrigin
272        );
273    }
274
275    #[test]
276    fn test_origin_write() {
277        let mut buf = [0u8; 64];
278        let mut out = crate::SliceSink::new(&mut buf);
279        o(b"HTTP://[::1]:8080").write_to(&mut out).unwrap();
280        assert_eq!(out.written(), b"http://[::1]:8080");
281        assert_eq!(o(b"x-app://a").effective_port(), None);
282    }
283}
parse_net/origin.rs

parse_net/
origin.rs
