Skip to main content

qualia_core_db/bundle/stream/protection/
finish.rs

1//! Final structural inventory and same-owner candidate signing; no rights minting.
2use 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            // The crypto Inventory intentionally does not validate empty roots.
25            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    /// A signed candidate remains unrecognized until actual publisher pin and
108    /// application-policy verification; this is not durable/public promotion.
109    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}