Skip to main content

qualia_core_db/bundle/stream/storage/
checkpoint.rs

1//! Fixed candidate checkpoint checksum. Decoding never authenticates a resume record.
2use super::bitmap::{geometry, validate_tail};
3use super::wire::*;
4use super::{
5    BITMAP_BYTES, CandidateBitmapPage, IDENTITY_BYTES, ResumeHint, StorageError as E,
6    StorageIdentity, decode_identity, encode_identity,
7};
8use crate::crypto::network::digest::sha384;
9use crate::net::qdnf::types::StrongDigest;
10pub const CHECKPOINT_BYTES: usize = 400;
11const MAGIC: &[u8; 8] = b"QBSCP01\0";
12/// The checksum is attacker-recomputable; all decoded fields remain untrusted hints.
13#[derive(Clone, Copy, Debug)]
14pub struct UntrustedCheckpoint {
15    identity: StorageIdentity,
16    page: u64,
17    sequence: u64,
18    payload_digest: StrongDigest,
19}
20impl UntrustedCheckpoint {
21    pub const fn identity(&self) -> &StorageIdentity {
22        &self.identity
23    }
24    pub const fn page_number(&self) -> u64 {
25        self.page
26    }
27    pub const fn sequence(&self) -> u64 {
28        self.sequence
29    }
30    pub fn bind_payload<'a>(
31        &self,
32        expected: &StorageIdentity,
33        expected_page: u64,
34        payload: &'a [u8; BITMAP_BYTES],
35    ) -> Result<ResumeHint<'a>, E> {
36        if self.identity != *expected {
37            return Err(E::IdentityMismatch);
38        }
39        if self.page != expected_page {
40            return Err(E::PageMismatch);
41        }
42        let (_, valid) = geometry(expected, expected_page)?;
43        if sha384(payload) != self.payload_digest {
44            return Err(E::DigestMismatch);
45        }
46        validate_tail(payload, valid)?;
47        Ok(ResumeHint {
48            identity: self.identity,
49            page: self.page,
50            sequence: self.sequence,
51            payload,
52        })
53    }
54}
55pub fn encode_checkpoint(
56    page: &CandidateBitmapPage<'_>,
57    sequence: u64,
58    out: &mut [u8],
59) -> Result<usize, E> {
60    let out = out.get_mut(..CHECKPOINT_BYTES).ok_or(E::Capacity)?;
61    out.fill(0);
62    out[..8].copy_from_slice(MAGIC);
63    out[8..10].copy_from_slice(&1u16.to_be_bytes());
64    encode_identity(page.identity(), &mut out[16..16 + IDENTITY_BYTES])?;
65    out[272..280].copy_from_slice(&page.page_number().to_be_bytes());
66    out[280..284].copy_from_slice(&(BITMAP_BYTES as u32).to_be_bytes());
67    out[288..336].copy_from_slice(sha384(page.payload()).as_bytes());
68    out[336..344].copy_from_slice(&sequence.to_be_bytes());
69    let digest = sha384(&out[..352]);
70    out[352..400].copy_from_slice(digest.as_bytes());
71    Ok(CHECKPOINT_BYTES)
72}
73pub fn decode_checkpoint(bytes: &[u8]) -> Result<UntrustedCheckpoint, E> {
74    if bytes.len() != CHECKPOINT_BYTES {
75        return Err(E::Length);
76    }
77    if &bytes[..8] != MAGIC {
78        return Err(E::Magic);
79    }
80    if u16_at(bytes, 8)? != 1 {
81        return Err(E::Version);
82    }
83    if u16_at(bytes, 10)? != 0 {
84        return Err(E::Flags);
85    }
86    zero(&bytes[12..16])?;
87    zero(&bytes[284..288])?;
88    zero(&bytes[344..352])?;
89    if u32_at(bytes, 280)? != BITMAP_BYTES as u32 {
90        return Err(E::Length);
91    }
92    if sha384(&bytes[..352]) != digest_at(bytes, 352)? {
93        return Err(E::DigestMismatch);
94    }
95    let identity = decode_identity(&bytes[16..272])?;
96    let page = u64_at(bytes, 272)?;
97    geometry(&identity, page)?;
98    Ok(UntrustedCheckpoint {
99        identity,
100        page,
101        sequence: u64_at(bytes, 336)?,
102        payload_digest: digest_at(bytes, 288)?,
103    })
104}