qualia_core_db/net/qdnf/policy_labels/
decode.rs1use super::types::{Confidentiality, LabelFields, MAX_COMPARTMENTS, MAX_LABEL_BYTES, MAX_PURPOSES};
4use crate::net::qdnf::errors::QdnfError;
5use crate::net::qdnf::types::StrongDigest;
6
7pub const HEADER_LEN: usize = 1 + 1 + 2 + 1 + 1 + 48 + 48;
10
11pub 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
94pub 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}