qualia_core_db/net/qdnf/policy_labels/
join.rs1use super::types::{Confidentiality, LabelFields, MAX_COMPARTMENTS, MAX_JOIN_INPUTS, MAX_PURPOSES};
4use crate::net::qdnf::errors::QdnfError;
5use crate::net::qdnf::types::StrongDigest;
6
7pub fn join_labels_into(
9 request: &LabelFields,
10 deps: &[LabelFields],
11 out: &mut LabelFields,
12) -> Result<(), QdnfError> {
13 if deps.len() > MAX_JOIN_INPUTS {
14 return Err(QdnfError::Capacity);
15 }
16 *out = *request;
17 let mut i = 0usize;
18 while i < deps.len() {
19 join_one(out, &deps[i])?;
20 i += 1;
21 }
22 Ok(())
23}
24
25pub fn join_one(acc: &mut LabelFields, dep: &LabelFields) -> Result<(), QdnfError> {
27 let a = acc.confidentiality.lattice_rank()?;
28 let b = dep.confidentiality.lattice_rank()?;
29 acc.confidentiality = if b > a {
30 dep.confidentiality
31 } else {
32 acc.confidentiality
33 };
34 if acc.confidentiality == Confidentiality::Unknown
35 || dep.confidentiality == Confidentiality::Unknown
36 {
37 return Err(QdnfError::Conflict);
38 }
39 union_sorted(
40 &mut acc.compartments,
41 &mut acc.compartment_count,
42 dep.compartments(),
43 MAX_COMPARTMENTS,
44 )?;
45 intersect_purposes(acc, dep)?;
46 acc.restriction_bits |= dep.restriction_bits;
47 join_audience(acc, dep)?;
48 join_issuer(acc, dep);
49 if acc.confidentiality.requires_audience() && acc.audience.is_zero() {
50 return Err(QdnfError::Conflict);
51 }
52 Ok(())
53}
54
55fn join_issuer(acc: &mut LabelFields, dep: &LabelFields) {
56 if dep.issuer.is_zero() {
57 return;
58 }
59 if acc.issuer.is_zero() {
60 acc.issuer = dep.issuer;
61 return;
62 }
63 if acc.issuer != dep.issuer {
64 acc.issuer = StrongDigest::ZERO;
66 }
67}
68
69fn join_audience(acc: &mut LabelFields, dep: &LabelFields) -> Result<(), QdnfError> {
70 if acc.audience.is_zero() {
71 acc.audience = dep.audience;
72 return Ok(());
73 }
74 if dep.audience.is_zero() {
75 return Ok(());
76 }
77 if acc.audience != dep.audience {
78 return Err(QdnfError::Conflict);
79 }
80 Ok(())
81}
82
83fn union_sorted(
84 dst: &mut [StrongDigest],
85 count: &mut u8,
86 extra: &[StrongDigest],
87 cap: usize,
88) -> Result<(), QdnfError> {
89 sort_prefix(dst, *count as usize);
90 let mut e = 0usize;
91 while e < extra.len() {
92 let item = extra[e];
93 if item.is_zero() {
94 return Err(QdnfError::Malformed);
95 }
96 insert_sorted_unique(dst, count, cap, item)?;
97 e += 1;
98 }
99 Ok(())
100}
101
102fn sort_prefix(buf: &mut [StrongDigest], n: usize) {
103 let mut i = 1usize;
104 while i < n {
105 let key = buf[i];
106 let mut j = i;
107 while j > 0 && buf[j - 1].0 > key.0 {
108 buf[j] = buf[j - 1];
109 j -= 1;
110 }
111 buf[j] = key;
112 i += 1;
113 }
114}
115
116fn insert_sorted_unique(
117 buf: &mut [StrongDigest],
118 count: &mut u8,
119 cap: usize,
120 item: StrongDigest,
121) -> Result<(), QdnfError> {
122 let n = *count as usize;
123 let mut i = 0usize;
124 while i < n {
125 if buf[i] == item {
126 return Ok(());
127 }
128 if buf[i].0 > item.0 {
129 if n >= cap {
130 return Err(QdnfError::Capacity);
131 }
132 let mut j = n;
133 while j > i {
134 buf[j] = buf[j - 1];
135 j -= 1;
136 }
137 buf[i] = item;
138 *count = count.checked_add(1).ok_or(QdnfError::Capacity)?;
139 return Ok(());
140 }
141 i += 1;
142 }
143 if n >= cap {
144 return Err(QdnfError::Capacity);
145 }
146 buf[n] = item;
147 *count = count.checked_add(1).ok_or(QdnfError::Capacity)?;
148 Ok(())
149}
150
151fn intersect_purposes(acc: &mut LabelFields, dep: &LabelFields) -> Result<(), QdnfError> {
152 if acc.purpose_count == 0 {
153 let n = dep.purpose_count as usize;
154 if n > MAX_PURPOSES {
155 return Err(QdnfError::Capacity);
156 }
157 let mut i = 0usize;
158 while i < n {
159 acc.purposes[i] = dep.purposes[i];
160 i += 1;
161 }
162 acc.purpose_count = dep.purpose_count;
163 return Ok(());
164 }
165 if dep.purpose_count == 0 {
166 return Ok(());
167 }
168 let mut kept = [StrongDigest::ZERO; MAX_PURPOSES];
169 let mut k = 0u8;
170 let mut i = 0usize;
171 while i < acc.purpose_count as usize {
172 let mut j = 0usize;
173 while j < dep.purpose_count as usize {
174 if acc.purposes[i] == dep.purposes[j] {
175 kept[k as usize] = acc.purposes[i];
176 k = k.saturating_add(1);
177 break;
178 }
179 j += 1;
180 }
181 i += 1;
182 }
183 if k == 0 {
184 return Err(QdnfError::Conflict);
185 }
186 acc.purposes = kept;
187 acc.purpose_count = k;
188 Ok(())
189}