Skip to main content

qualia_core_db/net/qdnf/policy_labels/
decode.rs

1//! Decode untrusted label bytes into [`LabelFields`].
2
3use super::types::{Confidentiality, LabelFields, MAX_COMPARTMENTS, MAX_LABEL_BYTES, MAX_PURPOSES};
4use crate::net::qdnf::errors::QdnfError;
5use crate::net::qdnf::types::StrongDigest;
6
7/// Layout: version(1) || conf(1) || restrictions(2) || n_comp(1) || n_purp(1)
8/// || audience(48) || issuer(48) || compartments || purposes.
9pub const HEADER_LEN: usize = 1 + 1 + 2 + 1 + 1 + 48 + 48;
10
11/// Decodes `label-into`.
12pub fn decode_label_into(original: &[u8], out: &mut LabelFields) -> Result<(), QdnfError> {
13    *out = LabelFields::blank();
14    if original.is_empty() {
15        return Err(QdnfError::Malformed);
16    }
17    if original.len() > MAX_LABEL_BYTES {
18        return Err(QdnfError::Capacity);
19    }
20    if original.len() < HEADER_LEN {
21        return Err(QdnfError::Truncated);
22    }
23    if original[0] != 1 {
24        return Err(QdnfError::Unsupported);
25    }
26    out.confidentiality = Confidentiality::from_wire(original[1])?;
27    out.restriction_bits = u16::from_be_bytes([original[2], original[3]]);
28    let n_comp = original[4] as usize;
29    let n_purp = original[5] as usize;
30    if n_comp > MAX_COMPARTMENTS || n_purp > MAX_PURPOSES {
31        return Err(QdnfError::Capacity);
32    }
33    let extra = n_comp
34        .checked_mul(48)
35        .and_then(|c| n_purp.checked_mul(48).and_then(|p| c.checked_add(p)))
36        .ok_or(QdnfError::Range)?;
37    let need = HEADER_LEN.checked_add(extra).ok_or(QdnfError::Range)?;
38    if original.len() != need {
39        return Err(QdnfError::Malformed);
40    }
41    out.audience = copy_digest(&original[6..54])?;
42    out.issuer = copy_digest(&original[54..102])?;
43    if out.issuer.is_zero() {
44        return Err(QdnfError::Malformed);
45    }
46    let mut off = HEADER_LEN;
47    let mut i = 0usize;
48    while i < n_comp {
49        let d = copy_digest(&original[off..off + 48])?;
50        if d.is_zero() {
51            return Err(QdnfError::Malformed);
52        }
53        let mut j = 0usize;
54        while j < i {
55            if out.compartments[j] == d {
56                return Err(QdnfError::Overlap);
57            }
58            j += 1;
59        }
60        out.compartments[i] = d;
61        off += 48;
62        i += 1;
63    }
64    out.compartment_count = n_comp as u8;
65    let mut p = 0usize;
66    while p < n_purp {
67        let d = copy_digest(&original[off..off + 48])?;
68        if d.is_zero() {
69            return Err(QdnfError::Malformed);
70        }
71        let mut j = 0usize;
72        while j < p {
73            if out.purposes[j] == d {
74                return Err(QdnfError::Overlap);
75            }
76            j += 1;
77        }
78        out.purposes[p] = d;
79        off += 48;
80        p += 1;
81    }
82    out.purpose_count = n_purp as u8;
83    Ok(())
84}
85
86fn copy_digest(bytes: &[u8]) -> Result<StrongDigest, QdnfError> {
87    StrongDigest::from_bytes(bytes)
88}
89
90fn write_digest(dst: &mut [u8], digest: StrongDigest) {
91    dst.copy_from_slice(&digest.0);
92}
93
94/// Encode `fields` to exact original bytes for verification.
95pub fn encode_label_into(fields: &LabelFields, dst: &mut [u8]) -> Result<usize, QdnfError> {
96    let n_comp = fields.compartment_count as usize;
97    let n_purp = fields.purpose_count as usize;
98    if n_comp > MAX_COMPARTMENTS || n_purp > MAX_PURPOSES {
99        return Err(QdnfError::Capacity);
100    }
101    let extra = n_comp
102        .checked_mul(48)
103        .and_then(|c| n_purp.checked_mul(48).and_then(|p| c.checked_add(p)))
104        .ok_or(QdnfError::Range)?;
105    let need = HEADER_LEN.checked_add(extra).ok_or(QdnfError::Range)?;
106    if need > MAX_LABEL_BYTES {
107        return Err(QdnfError::Capacity);
108    }
109    if dst.len() < need {
110        return Err(QdnfError::Capacity);
111    }
112    dst[0] = 1;
113    dst[1] = fields.confidentiality.to_wire();
114    let rb = fields.restriction_bits.to_be_bytes();
115    dst[2] = rb[0];
116    dst[3] = rb[1];
117    dst[4] = fields.compartment_count;
118    dst[5] = fields.purpose_count;
119    write_digest(&mut dst[6..54], fields.audience);
120    write_digest(&mut dst[54..102], fields.issuer);
121    let mut off = HEADER_LEN;
122    let mut i = 0usize;
123    while i < n_comp {
124        write_digest(&mut dst[off..off + 48], fields.compartments[i]);
125        off += 48;
126        i += 1;
127    }
128    let mut p = 0usize;
129    while p < n_purp {
130        write_digest(&mut dst[off..off + 48], fields.purposes[p]);
131        off += 48;
132        p += 1;
133    }
134    Ok(need)
135}