Skip to main content

qualia_core_db/bundle/stream/protection/
seal.rs

1//! Ciphertext and proof construction from actual managed monotonic sealers.
2use 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        // Erase the entire caller-provided private buffer on every return/unwind.
60        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}