Skip to main content

qualia_core_db/net/qdnf/resolve/qsr/
roots.rs

1//! Snapshot / compiler / index root binding for QSR.
2//!
3//! `snapshot_root` is SHA-384 over a domain-separated transcript of generation
4//! then each occupied key||value pair in insert order. An empty snapshot has a
5//! defined digest; it is never [`StrongDigest::ZERO`]. Binding these roots is
6//! not a completeness proof.
7
8use super::traversal::QsrSnapshot;
9use crate::crypto::network::transcript::Transcript;
10use crate::net::qdnf::errors::QdnfError;
11use crate::net::qdnf::types::StrongDigest;
12
13/// Transcript domain for the source snapshot root (not the compiler or index).
14pub const SNAPSHOT_ROOT_DOMAIN: &[u8] = b"qdnf:qsr:snapshot-root:v1";
15
16/// Pinned source snapshot, compiler/profile, and published index roots.
17#[repr(C)]
18#[derive(Clone, Copy, Debug, PartialEq, Eq)]
19pub struct IndexRoots {
20    /// SHA-384 over snapshot pairs (domain separated).
21    pub snapshot_root: StrongDigest,
22    pub compiler_digest: StrongDigest,
23    pub index_root: StrongDigest,
24}
25
26/// Bind compiler and index digests to the snapshot's independently hashed root.
27pub fn bind_roots(
28    snapshot: &QsrSnapshot,
29    compiler_digest: StrongDigest,
30    index_root: StrongDigest,
31) -> Result<IndexRoots, QdnfError> {
32    Ok(IndexRoots {
33        snapshot_root: snapshot_root(snapshot)?,
34        compiler_digest,
35        index_root,
36    })
37}
38
39/// Domain-separated snapshot digest. Empty maps are defined and non-zero.
40pub fn snapshot_root(snapshot: &QsrSnapshot) -> Result<StrongDigest, QdnfError> {
41    let mut t = Transcript::new();
42    t.append(b"v", SNAPSHOT_ROOT_DOMAIN)?;
43    t.append(b"generation", &snapshot.generation().0.to_be_bytes())?;
44    let mut i = 0usize;
45    while i < snapshot.len() {
46        let (key, value) = snapshot.pair_at(i).ok_or(QdnfError::Malformed)?;
47        let mut pair = [0u8; 96];
48        pair[..48].copy_from_slice(&key.0);
49        pair[48..].copy_from_slice(&value.0);
50        t.append(b"kv", &pair)?;
51        i += 1;
52    }
53    let digest = t.digest();
54    if digest.is_zero() {
55        return Err(QdnfError::CryptoFailure);
56    }
57    Ok(digest)
58}
59
60#[cfg(test)]
61mod tests {
62    use super::*;
63    use crate::net::qdnf::types::Generation;
64
65    #[test]
66    fn empty_snapshot_root_is_defined_and_not_zero() {
67        let snap = QsrSnapshot::empty(Generation(1));
68        let a = snapshot_root(&snap).unwrap();
69        let b = snapshot_root(&snap).unwrap();
70        assert_eq!(a, b);
71        assert_ne!(a, StrongDigest::ZERO);
72        let bound = bind_roots(&snap, StrongDigest::ZERO, StrongDigest::ZERO).unwrap();
73        assert_eq!(bound.snapshot_root, a);
74    }
75
76    #[test]
77    fn generation_and_pairs_are_bound() {
78        let empty_g1 = QsrSnapshot::empty(Generation(1));
79        let empty_g2 = QsrSnapshot::empty(Generation(2));
80        assert_ne!(
81            snapshot_root(&empty_g1).unwrap(),
82            snapshot_root(&empty_g2).unwrap()
83        );
84
85        let mut with_pair = QsrSnapshot::empty(Generation(1));
86        let mut key = StrongDigest::ZERO;
87        let mut value = StrongDigest::ZERO;
88        key.0[0] = 1;
89        value.0[47] = 2;
90        with_pair.insert(key, value).unwrap();
91        assert_ne!(
92            snapshot_root(&empty_g1).unwrap(),
93            snapshot_root(&with_pair).unwrap()
94        );
95    }
96}