qualia_core_db/net/peer/replication/
projection.rs1use crate::crypto::network::digest::sha384;
8use crate::net::peer::replication::originals::{projection_replaces_original, OriginalObject};
9use crate::net::qdnf::errors::QdnfError;
10use crate::net::qdnf::types::{Generation, StrongDigest};
11
12#[repr(C)]
14#[derive(Clone, Copy, Debug, PartialEq, Eq)]
15pub struct Projection {
16 pub from: StrongDigest,
17 pub digest: StrongDigest,
18}
19
20pub fn derive_projection(
24 orig: &OriginalObject,
25 proj_bytes: &[u8],
26) -> Result<Projection, QdnfError> {
27 if orig.digest == StrongDigest::ZERO || orig.len == 0 {
28 return Err(QdnfError::Malformed);
29 }
30 if proj_bytes.is_empty() {
31 return Err(QdnfError::Malformed);
32 }
33 let digest = sha384(proj_bytes);
34 let _ = projection_replaces_original();
35 Ok(Projection {
36 from: orig.digest,
37 digest,
38 })
39}
40
41pub fn plan_delta(view_authorised: bool, cross_tenant: bool) -> Result<(), QdnfError> {
44 let view_gen = if view_authorised {
45 Generation(1)
46 } else {
47 Generation(0)
48 };
49 plan_delta_at(view_gen, Generation(1), cross_tenant)
50}
51
52pub fn plan_delta_at(
55 view_gen: Generation,
56 live_gen: Generation,
57 cross_tenant: bool,
58) -> Result<(), QdnfError> {
59 if cross_tenant {
60 return Err(QdnfError::Denied);
61 }
62 if view_gen != live_gen {
63 return Err(QdnfError::Unauthorized);
64 }
65 Ok(())
66}
67
68#[inline]
70pub fn membership_oracle_from_dedup() -> bool {
71 false
72}
73
74#[cfg(test)]
75mod tests {
76 use super::*;
77 use crate::net::peer::replication::originals::store_original;
78
79 #[test]
80 fn original_is_not_projection() {
81 let orig_bytes = b"original-object-bytes";
82 let proj_bytes = b"derived-projection";
83 let orig = store_original(orig_bytes, 64).unwrap();
84 let proj = derive_projection(&orig, proj_bytes).unwrap();
85 assert_eq!(proj.from, orig.digest);
86 assert_ne!(proj.digest, orig.digest);
87 assert!(!projection_replaces_original());
88 assert_ne!(proj.digest, proj.from);
89 }
90
91 #[test]
92 fn unauthorized_view_is_unauthorized() {
93 assert_eq!(plan_delta(false, false), Err(QdnfError::Unauthorized));
94 assert_eq!(
95 plan_delta_at(Generation(1), Generation(2), false),
96 Err(QdnfError::Unauthorized)
97 );
98 plan_delta(true, false).unwrap();
99 plan_delta_at(Generation(4), Generation(4), false).unwrap();
100 }
101
102 #[test]
103 fn cross_tenant_is_denied() {
104 assert_eq!(plan_delta(true, true), Err(QdnfError::Denied));
105 assert_eq!(
106 plan_delta_at(Generation(1), Generation(1), true),
107 Err(QdnfError::Denied)
108 );
109 assert!(!membership_oracle_from_dedup());
110 }
111
112 #[test]
113 fn empty_projection_is_malformed() {
114 let orig = store_original(b"abc", 8).unwrap();
115 assert_eq!(derive_projection(&orig, b""), Err(QdnfError::Malformed));
116 }
117}