Skip to main content

qualia_core_db/net/qdnf/policy_labels/
verify.rs

1//! Verify exact original bytes into a [`VerifiedLabel`]. No “signed” boolean.
2
3use super::decode::decode_label_into;
4use super::types::{LabelFields, VerifiedLabel};
5use crate::crypto::network::digest::sha384;
6use crate::net::qdnf::errors::QdnfError;
7use crate::net::qdnf::types::StrongDigest;
8
9/// Bind untrusted fields to exact original bytes. Fields must decode from
10/// `original_bytes`; a digest without those bytes is malformed.
11pub fn verify_label(
12    fields: LabelFields,
13    original_bytes: &[u8],
14) -> Result<VerifiedLabel, QdnfError> {
15    if original_bytes.is_empty() {
16        return Err(QdnfError::Malformed);
17    }
18    if fields.issuer.is_zero() {
19        return Err(QdnfError::Unauthorized);
20    }
21    if fields.confidentiality.is_unknown() {
22        return Err(QdnfError::Conflict);
23    }
24    if fields.confidentiality.requires_audience() && fields.audience.is_zero() {
25        return Err(QdnfError::Conflict);
26    }
27    let mut decoded = LabelFields::blank();
28    decode_label_into(original_bytes, &mut decoded)?;
29    if decoded != fields {
30        return Err(QdnfError::Conflict);
31    }
32    let digest = sha384(original_bytes);
33    if digest.is_zero() {
34        return Err(QdnfError::CryptoFailure);
35    }
36    Ok(VerifiedLabel::from_verified(decoded, digest))
37}
38
39/// Verifies `label-digest`.
40pub fn verify_label_digest(
41    fields: LabelFields,
42    original_bytes: &[u8],
43    expected: StrongDigest,
44) -> Result<VerifiedLabel, QdnfError> {
45    let label = verify_label(fields, original_bytes)?;
46    if label.exact_bytes_digest() != expected {
47        return Err(QdnfError::Conflict);
48    }
49    Ok(label)
50}
51
52#[cfg(test)]
53mod tests {
54    use super::*;
55    use crate::net::qdnf::policy_labels::decode::encode_label_into;
56    use crate::net::qdnf::policy_labels::types::Confidentiality;
57
58    fn encode(fields: &LabelFields) -> ([u8; 256], usize) {
59        let mut buf = [0u8; 256];
60        let n = encode_label_into(fields, &mut buf).unwrap();
61        (buf, n)
62    }
63
64    #[test]
65    fn empty_bytes_are_malformed() {
66        let fields = LabelFields::request(Confidentiality::C1Private, StrongDigest([1u8; 48]));
67        assert_eq!(verify_label(fields, b"").unwrap_err(), QdnfError::Malformed);
68    }
69
70    #[test]
71    fn fields_must_match_decoded_bytes() {
72        let fields = LabelFields::request(Confidentiality::C1Private, StrongDigest([1u8; 48]));
73        let mut other = fields;
74        other.confidentiality = Confidentiality::C0Public;
75        let (buf, n) = encode(&other);
76        assert_eq!(
77            verify_label(fields, &buf[..n]).unwrap_err(),
78            QdnfError::Conflict
79        );
80    }
81}