qualia_core_db/bundle/stream/protection/
finish.rs1use super::publisher::{
3 Artifact, CandidateSink, ProtectedCandidate, ProtectedPublisher, PublisherError as E,
4};
5use crate::bundle::stream::proof::{empty_root, Representation, TreeSpec};
6use crate::crypto::network::{cose, digest::sha384, errors::CryptoError, object_stream::*};
7use crate::specialized_libs::cryptographic_library::PairedSigningRequest;
8use zeroize::Zeroizing;
9impl ProtectedPublisher<'_, '_, '_, '_> {
10 pub fn finish(
11 &mut self,
12 out: &mut [u8],
13 sink: &mut impl CandidateSink,
14 ) -> Result<ProtectedCandidate, E> {
15 if self.candidate.is_some() || self.next != self.geometry.object_count() {
16 return Err(E::State);
17 }
18 self.attempt(|p| {
19 let metadata_root = p.metadata_root.ok_or(E::State)?;
20 if sha384(p.geometry.source.source_bytes()) != p.geometry.source_digest {
21 return Err(E::Source);
22 }
23 let fields = p.context.fields();
24 for (row, m) in p.roots.iter().zip(p.geometry.mappings) {
26 let length = p.geometry.source.objects()[m.source_slot].length();
27 if row.id != m.id {
28 return Err(E::Source);
29 }
30 if length == 0 {
31 let spec = TreeSpec::new(
32 p.context.id(),
33 m.id,
34 fields.generation,
35 Representation::Ciphertext,
36 fields.key_epoch,
37 0,
38 )
39 .map_err(|_| E::Proof)?;
40 if row.root != empty_root(&spec).map_err(|_| E::Proof)? {
41 return Err(E::Proof);
42 }
43 }
44 }
45 let mut roots = [0; 6728];
46 for page in 0..p.context.page_count() {
47 let start = page * PAGE_ROWS;
48 let end = (start + PAGE_ROWS).min(p.roots.len());
49 let n = encode_roots(
50 p.context.id(),
51 page as u16,
52 &p.roots[start..end],
53 &mut roots,
54 )
55 .map_err(|_| E::Codec)?;
56 p.root_refs[page] = PageRef {
57 page: page as u16,
58 rows: (end - start) as u16,
59 length: n as u32,
60 digest: sha384(&roots[..n]),
61 };
62 }
63 let n = encode_descriptor(p.context, metadata_root, p.root_refs, out)
64 .map_err(|_| E::Codec)?;
65 let descriptor = Descriptor::parse(&out[..n]).map_err(|_| E::Codec)?;
66 let mut inventory = Inventory::new(descriptor);
67 let mut geometry = [0; 1560];
68 for page in 0..p.context.page_count() {
69 let g = p.geometry.encode_page(page, &mut geometry)?;
70 let start = page * PAGE_ROWS;
71 let end = (start + PAGE_ROWS).min(p.roots.len());
72 let rn = encode_roots(
73 p.context.id(),
74 page as u16,
75 &p.roots[start..end],
76 &mut roots,
77 )
78 .map_err(|_| E::Codec)?;
79 inventory
80 .accept(
81 GeometryPage::parse(&geometry[..g.length as usize])
82 .map_err(|_| E::Codec)?,
83 RootPage::parse(&roots[..rn]).map_err(|_| E::Codec)?,
84 )
85 .map_err(|_| E::Codec)?;
86 p.publication
87 .with_current_effect(|| {
88 sink.artifact(Artifact::Roots, page as u16, &roots[..rn])
89 .map_err(|_| CryptoError::CryptoFailure)
90 })
91 .map_err(|_| E::Sink)?;
92 }
93 inventory.complete().map_err(|_| E::Codec)?;
94 p.publication
95 .with_current_effect(|| {
96 sink.artifact(Artifact::Descriptor, 0, descriptor.encoded())
97 .map_err(|_| CryptoError::CryptoFailure)
98 })
99 .map_err(|_| E::Sink)?;
100 p.candidate = Some(descriptor.id());
101 Ok(ProtectedCandidate {
102 descriptor: descriptor.id(),
103 context: p.context.id(),
104 })
105 })
106 }
107 pub fn sign_candidate(
110 &mut self,
111 descriptor: &[u8],
112 request: PairedSigningRequest<'_>,
113 workspace: &mut cose::Workspace,
114 sink: &mut impl CandidateSink,
115 ) -> Result<(), E> {
116 if self.proof_staged {
117 return Err(E::State);
118 }
119 self.attempt(|p| {
120 let descriptor = Descriptor::parse(descriptor).map_err(|_| E::Codec)?;
121 if p.candidate != Some(descriptor.id()) {
122 return Err(E::Source);
123 }
124 let mut proof = Zeroizing::new([0; cose::MAX_ENVELOPE_BYTES]);
125 let n = p
126 .publication
127 .sign_descriptor(descriptor, request, workspace, &mut proof[..])
128 .map_err(|_| E::Crypto)?;
129 p.publication
130 .with_current_effect(|| {
131 sink.artifact(Artifact::PublisherProof, 0, &proof[..n])
132 .map_err(|_| CryptoError::CryptoFailure)
133 })
134 .map_err(|_| E::Sink)?;
135 p.proof_staged = true;
136 Ok(())
137 })
138 }
139}