Skip to main content

qualia_core_db/net/qdnf/frame/
extensions.rs

1//! Authenticated header extensions. Nested parse steps are bounded.
2
3use super::errors::FrameError;
4
5pub const MAX_EXTENSIONS: usize = 8;
6pub const MAX_EXTENSION_BYTES: usize = 256;
7
8/// Type-length-value extension after the base header.
9#[repr(C)]
10#[derive(Clone, Copy, Debug, PartialEq, Eq)]
11pub struct Extension {
12    pub kind: u16,
13    pub critical: bool,
14    pub len: u16,
15}
16
17/// Parse extensions from `src` (the region between base header and payload).
18/// Unknown non-critical extensions are counted and skipped. Unknown critical
19/// extensions fail.
20pub fn parse_extensions(src: &[u8], out: &mut [Extension]) -> Result<usize, FrameError> {
21    if src.len() > MAX_EXTENSION_BYTES {
22        return Err(FrameError::Capacity);
23    }
24    let mut offset = 0usize;
25    let mut count = 0usize;
26    let mut steps = 0usize;
27    while offset < src.len() {
28        steps = steps.checked_add(1).ok_or(FrameError::Range)?;
29        if steps > MAX_EXTENSIONS {
30            return Err(FrameError::Capacity);
31        }
32        let remaining = src.len() - offset;
33        if remaining < 4 {
34            return Err(FrameError::Truncated);
35        }
36        let kind = u16::from_be_bytes([src[offset], src[offset + 1]]);
37        let len = u16::from_be_bytes([src[offset + 2], src[offset + 3]]);
38        let body_end = offset
39            .checked_add(4)
40            .and_then(|o| o.checked_add(len as usize))
41            .ok_or(FrameError::Range)?;
42        if body_end > src.len() {
43            return Err(FrameError::Truncated);
44        }
45        let critical = kind & 0x8000 != 0;
46        let kind_id = kind & 0x7fff;
47        if critical && !known_extension(kind_id) {
48            return Err(FrameError::CriticalExtension);
49        }
50        if count < out.len() {
51            out[count] = Extension {
52                kind: kind_id,
53                critical,
54                len,
55            };
56            count += 1;
57        } else {
58            return Err(FrameError::Capacity);
59        }
60        offset = body_end;
61    }
62    Ok(count)
63}
64
65const fn known_extension(kind: u16) -> bool {
66    matches!(kind, 1 | 2 | 3)
67}
68
69#[cfg(test)]
70mod tests {
71    use super::*;
72
73    #[test]
74    fn unknown_critical_fails() {
75        let src = [0x80, 0x99, 0x00, 0x00];
76        let mut out = [Extension {
77            kind: 0,
78            critical: false,
79            len: 0,
80        }; 4];
81        assert_eq!(
82            parse_extensions(&src, &mut out),
83            Err(FrameError::CriticalExtension)
84        );
85    }
86
87    #[test]
88    fn known_non_critical_is_counted() {
89        let src = [0x00, 0x01, 0x00, 0x00];
90        let mut out = [Extension {
91            kind: 0,
92            critical: false,
93            len: 0,
94        }; 4];
95        assert_eq!(parse_extensions(&src, &mut out).unwrap(), 1);
96        assert_eq!(out[0].kind, 1);
97    }
98}