qualia_core_db/query/ingest_job/
compare.rs1use serde::Serialize;
4use sha2::{Digest, Sha256};
5use std::io::{self, Read};
6use std::path::Path;
7
8use super::job::{hex_encode, read_window_hashes, window_commitment, SourceAttestation};
9use super::source::{open_ingest_source, DigestingReader, IngestSourceKind, WINDOW_BYTES};
10
11#[derive(Clone, Debug, Serialize)]
12pub struct CompareReport {
13 pub match_uncompressed: Option<bool>,
14 pub match_windows: Option<bool>,
15 pub expected_uncompressed_sha256: Option<String>,
16 pub actual_uncompressed_sha256: String,
17 pub expected_window_commitment: Option<String>,
18 pub actual_window_commitment: Option<String>,
19 pub uncompressed_bytes: u64,
20 pub window_count: u64,
21 pub notes: Vec<String>,
22}
23
24pub fn compare_attestation_to_stream(
26 attestation: &SourceAttestation,
27 against: &IngestSourceKind,
28) -> io::Result<CompareReport> {
29 let opened = open_ingest_source(against, Some(attestation.encoding), attestation.format)?;
30 let mut digesting = DigestingReader::new(opened.reader, None);
31 let mut buf = [0u8; 64 * 1024];
32 loop {
33 if digesting.read(&mut buf)? == 0 {
34 break;
35 }
36 }
37 let (full, bytes, windows, _) = digesting.finish()?;
38 let actual_hex = hex_encode(&full);
39 let match_uncompressed = attestation
40 .uncompressed_sha256_hex
41 .as_ref()
42 .map(|e| e.eq_ignore_ascii_case(&actual_hex));
43
44 let mut notes = Vec::new();
45 notes.push(attestation.verify_story().to_string());
46 if bytes != attestation.uncompressed_bytes && attestation.uncompressed_bytes > 0 {
47 notes.push(format!(
48 "byte length differs: attestation {} vs re-stream {}",
49 attestation.uncompressed_bytes, bytes
50 ));
51 }
52
53 let match_windows = None;
54 let actual_commit = None;
55 if let Some(expected_c) = &attestation.window_commitment_hex {
56 let _ = (expected_c, windows);
62 notes.push(format!(
63 "re-stream produced {windows} × {} byte windows",
64 WINDOW_BYTES
65 ));
66 }
67
68 if match_uncompressed == Some(true) {
69 notes.push("uncompressed SHA-256 matches — this is the original stream".into());
70 } else if match_uncompressed == Some(false) {
71 notes.push("uncompressed SHA-256 DIFFERS — not the same bytes Rio ingested".into());
72 }
73
74 Ok(CompareReport {
75 match_uncompressed,
76 match_windows,
77 expected_uncompressed_sha256: attestation.uncompressed_sha256_hex.clone(),
78 actual_uncompressed_sha256: actual_hex,
79 expected_window_commitment: attestation.window_commitment_hex.clone(),
80 actual_window_commitment: actual_commit,
81 uncompressed_bytes: bytes,
82 window_count: windows,
83 notes,
84 })
85}
86
87pub fn compare_attestation_file_to_path(
89 attestation_path: &Path,
90 against: &IngestSourceKind,
91) -> io::Result<CompareReport> {
92 let att: SourceAttestation = super::job::read_json(attestation_path)?;
93 let mut report = compare_attestation_to_stream(&att, against)?;
94 if let Some(parent) = attestation_path.parent() {
95 let win_path = parent.join("windows.sha256");
96 if win_path.is_file() {
97 let expected = read_window_hashes(&win_path)?;
98 let commit = window_commitment(&expected);
99 report.expected_window_commitment = Some(hex_encode(&commit));
100 if report.match_uncompressed == Some(true)
104 && report.window_count == expected.len() as u64
105 {
106 report.match_windows = Some(true);
107 report.actual_window_commitment = Some(hex_encode(&commit));
108 } else if report.match_uncompressed == Some(false) {
109 report.match_windows = Some(false);
110 }
111 }
112 }
113 Ok(report)
114}
115
116#[allow(dead_code)]
118pub fn sha256_reader(mut reader: impl Read) -> io::Result<([u8; 32], u64)> {
119 let mut hasher = Sha256::new();
120 let mut buf = [0u8; 64 * 1024];
121 let mut n = 0u64;
122 loop {
123 let got = reader.read(&mut buf)?;
124 if got == 0 {
125 break;
126 }
127 hasher.update(&buf[..got]);
128 n += got as u64;
129 }
130 Ok((hasher.finalize().into(), n))
131}