Skip to main content

qualia_core_db/net/qdnf/policy_labels/
join.rs

1//! Label join: max confidentiality, union compartments/restrictions, purpose conjunction.
2
3use super::types::{Confidentiality, LabelFields, MAX_COMPARTMENTS, MAX_JOIN_INPUTS, MAX_PURPOSES};
4use crate::net::qdnf::errors::QdnfError;
5use crate::net::qdnf::types::StrongDigest;
6
7/// Joins labels into `out`.
8pub 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
25/// Joins one label.
26pub 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        // No single issuer owns the joined constraint.
65        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}