qualia_core_db/bundle/stream/protection/
seal.rs1use super::{
3 metadata::{self, Erase, PrivateReferences},
4 publisher::{CandidateSink, ProtectedPublisher, PublisherError as E},
5};
6use crate::bundle::stream::proof::{ProofError, Representation, TreeBuilder, TreeSpec};
7use crate::crypto::network::{errors::CryptoError, object_stream::*};
8use crate::net::qdnf::types::StrongDigest;
9use crate::specialized_libs::cryptographic_library::ManagedObjectSealer;
10use sha2::{Digest, Sha384};
11impl ProtectedPublisher<'_, '_, '_, '_> {
12 pub fn seal_next_object(
13 &mut self,
14 scratch: &mut [u8],
15 sink: &mut impl CandidateSink,
16 ) -> Result<(), E> {
17 let erased_leaf = Erase { bytes: scratch };
18 if !self.header_staged
19 || self.next >= self.geometry.object_count()
20 || self.metadata_root.is_some()
21 {
22 return Err(E::State);
23 }
24 self.attempt(|p| {
25 let sorted = p.next;
26 let mapping = p.geometry.mappings[sorted];
27 let bytes = p
28 .geometry
29 .source
30 .object_bytes(mapping.source_slot)
31 .map_err(|_| E::Source)?;
32 let mut page = [0; 1560];
33 let r = p.geometry.encode_page(sorted / PAGE_ROWS, &mut page)?;
34 let geometry = GeometryPage::parse(&page[..r.length as usize]).map_err(|_| E::Codec)?;
35 let mut sealer = p
36 .publication
37 .begin_object(geometry, sorted % PAGE_ROWS)
38 .map_err(|_| E::Crypto)?;
39 let root = seal_bytes(&mut sealer, bytes, mapping.digest, erased_leaf.bytes, sink)?;
40 sealer.finish().map_err(|_| E::Crypto)?;
41 p.roots[sorted] = RootRow {
42 id: mapping.id,
43 root,
44 };
45 p.next += 1;
46 Ok(())
47 })
48 }
49 pub fn seal_metadata(
50 &mut self,
51 refs: PrivateReferences,
52 private_scratch: &mut [u8],
53 leaf_scratch: &mut [u8],
54 sink: &mut impl CandidateSink,
55 ) -> Result<(), E> {
56 let erased_leaf = Erase {
57 bytes: leaf_scratch,
58 };
59 let erased = Erase {
61 bytes: private_scratch,
62 };
63 if !self.header_staged
64 || self.next != self.geometry.object_count()
65 || self.metadata_root.is_some()
66 {
67 return Err(E::State);
68 }
69 self.attempt(|p| {
70 p.publication
71 .with_current_effect(|| Ok(()))
72 .map_err(|_| E::Crypto)?;
73 metadata::write(&p.geometry, &p.publication, p.context, refs, erased.bytes)?;
74 let expected = crate::crypto::network::digest::sha384(erased.bytes);
75 let mut sealer = p.publication.begin_metadata().map_err(|_| E::Crypto)?;
76 let root = seal_bytes(&mut sealer, erased.bytes, expected, erased_leaf.bytes, sink)?;
77 sealer.finish().map_err(|_| E::Crypto)?;
78 p.metadata_root = Some(root);
79 Ok(())
80 })
81 }
82}
83fn seal_bytes(
84 sealer: &mut ManagedObjectSealer<'_, '_>,
85 bytes: &[u8],
86 expected: StrongDigest,
87 scratch: &mut [u8],
88 sink: &mut impl CandidateSink,
89) -> Result<StrongDigest, E> {
90 let erased = Erase { bytes: scratch };
91 if erased.bytes.len() != LEAF_BYTES as usize + 16 {
92 return Err(E::Capacity);
93 }
94 let scope = sealer.scope();
95 if scope.length() != bytes.len() as u64 {
96 return Err(E::Source);
97 }
98 let spec = TreeSpec::new(
99 scope.context(),
100 scope.id(),
101 scope.generation(),
102 Representation::Ciphertext,
103 scope.epoch(),
104 scope.length(),
105 )
106 .map_err(|_| E::Proof)?;
107 let mut tree = TreeBuilder::new(spec);
108 let mut hash = Sha384::new();
109 for (index, plain) in bytes.chunks(LEAF_BYTES as usize).enumerate() {
110 let n = plain.len();
111 erased.bytes[..n].copy_from_slice(plain);
112 hash.update(&erased.bytes[..n]);
113 let (cipher, tail) = erased.bytes.split_at_mut(n);
114 let tag: &mut [u8; 16] = (&mut tail[..16]).try_into().map_err(|_| E::Capacity)?;
115 if sealer.seal_next(cipher, tag).map_err(|_| E::Crypto)? != index as u64 {
116 return Err(E::State);
117 }
118 tree.append(&erased.bytes[..n + 16], |node| {
119 sealer
120 .with_current_effect(|| {
121 sink.outboard(&spec, node)
122 .map_err(|_| CryptoError::CryptoFailure)
123 })
124 .map_err(|_| ProofError::Sink)
125 })
126 .map_err(|_| E::Sink)?;
127 sealer
128 .with_current_effect(|| {
129 sink.ciphertext(scope, index as u64, &erased.bytes[..n + 16])
130 .map_err(|_| CryptoError::CryptoFailure)
131 })
132 .map_err(|_| E::Sink)?;
133 }
134 if hash.finalize().as_slice() != expected.0.as_slice() {
135 return Err(E::Source);
136 }
137 tree.finish(|node| {
138 sealer
139 .with_current_effect(|| {
140 sink.outboard(&spec, node)
141 .map_err(|_| CryptoError::CryptoFailure)
142 })
143 .map_err(|_| ProofError::Sink)
144 })
145 .map_err(|_| E::Sink)
146}