Skip to main content

qualia_core_db/net/qdnf/policy_labels/
declassify.rs

1//! Reviewed declassification as a new derivation. The original label is preserved.
2
3use 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/// Provenance for a reviewed release. Original bytes stay bound to `parent`.
11#[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
19/// Create a new derivation. Confidentiality may lower only when `authority`
20/// matches the originating issuer (release authority). Foreign issuers Denied.
21pub 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
29/// Same gate as [`declassify`], with parent digest retained for provenance.
30pub 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
38/// Lower (or keep) confidentiality to `target` under matching release authority.
39pub 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}