qualia_core_db/net/qdnf/policy_labels/
declassify.rs1use super::decode::encode_label_into;
4use super::release::release_derivation;
5use super::types::{Confidentiality, LabelFields, VerifiedLabel, MAX_LABEL_BYTES};
6use super::verify::verify_label;
7use crate::net::qdnf::errors::QdnfError;
8use crate::net::qdnf::types::StrongDigest;
9
10#[derive(Clone, Copy, Debug, PartialEq, Eq)]
12pub struct DeclassifyRecord {
13 pub derived: VerifiedLabel,
14 pub parent_digest: StrongDigest,
15 pub authority: StrongDigest,
16 pub issued_at: u64,
17}
18
19pub fn declassify(
22 original: &VerifiedLabel,
23 authority: StrongDigest,
24 now: u64,
25) -> Result<VerifiedLabel, QdnfError> {
26 Ok(declassify_record(original, authority, now)?.derived)
27}
28
29pub fn declassify_record(
31 original: &VerifiedLabel,
32 authority: StrongDigest,
33 now: u64,
34) -> Result<DeclassifyRecord, QdnfError> {
35 declassify_to(original, authority, now, Confidentiality::C0Public)
36}
37
38pub fn declassify_to(
40 original: &VerifiedLabel,
41 authority: StrongDigest,
42 now: u64,
43 target: Confidentiality,
44) -> Result<DeclassifyRecord, QdnfError> {
45 if now == 0 {
46 return Err(QdnfError::Malformed);
47 }
48 if authority.is_zero() {
49 return Err(QdnfError::Unauthorized);
50 }
51 let mut proposed = *original.fields();
52 proposed.confidentiality = target;
53 let released = release_derivation(original, &proposed, authority)?;
54 let derived = bind_derivation(&released)?;
55 Ok(DeclassifyRecord {
56 derived,
57 parent_digest: original.exact_bytes_digest(),
58 authority,
59 issued_at: now,
60 })
61}
62
63fn bind_derivation(fields: &LabelFields) -> Result<VerifiedLabel, QdnfError> {
64 let mut buf = [0u8; MAX_LABEL_BYTES];
65 let n = encode_label_into(fields, &mut buf)?;
66 verify_label(*fields, &buf[..n])
67}
68
69#[cfg(test)]
70mod tests {
71 use super::*;
72 use crate::net::qdnf::policy_labels::types::{LabelFields, NO_TRAINING};
73
74 fn issuer(b: u8) -> StrongDigest {
75 let mut d = StrongDigest::ZERO;
76 d.0[0] = b;
77 d.0[47] = 1;
78 d
79 }
80
81 fn verified(conf: Confidentiality, iss: StrongDigest, restrictions: u16) -> VerifiedLabel {
82 let mut fields = LabelFields::request(conf, iss);
83 fields.restriction_bits = restrictions;
84 if conf.requires_audience() {
85 fields.audience = iss;
86 }
87 let mut buf = [0u8; 256];
88 let n = encode_label_into(&fields, &mut buf).unwrap();
89 verify_label(fields, &buf[..n]).unwrap()
90 }
91
92 #[test]
93 fn matching_issuer_declassifies_to_public() {
94 let original = verified(Confidentiality::C2Sensitive, issuer(1), NO_TRAINING);
95 let record = declassify_to(&original, issuer(1), 100, Confidentiality::C0Public).unwrap();
96 assert_eq!(record.derived.confidentiality(), Confidentiality::C0Public);
97 assert_eq!(record.parent_digest, original.exact_bytes_digest());
98 assert_eq!(original.confidentiality(), Confidentiality::C2Sensitive);
99 assert_eq!(
100 record.derived.fields().restriction_bits & NO_TRAINING,
101 NO_TRAINING
102 );
103 assert_ne!(
104 record.derived.exact_bytes_digest(),
105 original.exact_bytes_digest()
106 );
107 assert!(declassify(&original, issuer(1), 100).is_ok());
108 }
109
110 #[test]
111 fn foreign_issuer_cannot_declassify() {
112 let original = verified(Confidentiality::C2Sensitive, issuer(1), NO_TRAINING);
113 assert_eq!(
114 declassify(&original, issuer(2), 100),
115 Err(QdnfError::Denied)
116 );
117 }
118
119 #[test]
120 fn zero_authority_is_unauthorized() {
121 let original = verified(Confidentiality::C1Private, issuer(1), 0);
122 assert_eq!(
123 declassify(&original, StrongDigest::ZERO, 100),
124 Err(QdnfError::Unauthorized)
125 );
126 }
127
128 #[test]
129 fn forged_release_raising_confidentiality_is_denied() {
130 let original = verified(Confidentiality::C1Private, issuer(1), 0);
131 assert_eq!(
132 declassify_to(&original, issuer(1), 100, Confidentiality::C3Compartmented).unwrap_err(),
133 QdnfError::Denied
134 );
135 }
136
137 #[test]
138 fn original_label_object_is_unchanged() {
139 let original = verified(Confidentiality::C2Sensitive, issuer(1), NO_TRAINING);
140 let before = original;
141 let _ = declassify(&original, issuer(1), 50).unwrap();
142 assert_eq!(original, before);
143 assert_eq!(original.confidentiality(), Confidentiality::C2Sensitive);
144 }
145}