hyprstream_core/storage/cas/
manifest.rs1use hyprstream_rpc::auth::mac::{ContentBoundLabel, LabeledObject, SecurityLabel};
10use hyprstream_rpc::cid::{decode_cid, encode_cid, Codec, HashAlgo};
11use serde::{Deserialize, Serialize};
12
13use super::CasError;
14
15pub const FILE_RECONSTRUCTION_CODEC: Codec = Codec::XetManifest;
20
21#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
29pub struct BlobManifest {
30 pub cid: String,
34
35 pub merkle: String,
39
40 pub xorb_hashes: Vec<String>,
42
43 pub bytes_stored: u64,
46
47 pub byte_len: u64,
49
50 pub security_label: SecurityLabel,
59}
60
61#[derive(Serialize)]
66struct ManifestPreimage<'a> {
67 merkle: &'a str,
68 xorb_hashes: &'a [String],
69 byte_len: u64,
70 security_label: SecurityLabel,
71}
72
73impl BlobManifest {
74 pub fn new(
76 merkle: String,
77 xorb_hashes: Vec<String>,
78 bytes_stored: u64,
79 byte_len: u64,
80 security_label: SecurityLabel,
81 ) -> Result<Self, CasError> {
82 let mut manifest = Self {
83 cid: String::new(),
84 merkle,
85 xorb_hashes,
86 bytes_stored,
87 byte_len,
88 security_label,
89 };
90 manifest.cid = manifest.recomputed_cid()?;
91 Ok(manifest)
92 }
93
94 fn preimage(&self) -> ManifestPreimage<'_> {
95 ManifestPreimage {
96 merkle: &self.merkle,
97 xorb_hashes: &self.xorb_hashes,
98 byte_len: self.byte_len,
99 security_label: self.security_label,
100 }
101 }
102
103 pub fn recomputed_cid(&self) -> Result<String, CasError> {
105 let bytes = serde_json::to_vec(&self.preimage())
106 .map_err(|e| CasError::Manifest(format!("serialize manifest preimage: {e}")))?;
107 let digest = blake3::hash(&bytes);
108 encode_cid(
109 FILE_RECONSTRUCTION_CODEC,
110 HashAlgo::Blake3,
111 digest.as_bytes(),
112 )
113 .map_err(|e| CasError::Cid(e.to_string()))
114 }
115}
116
117impl LabeledObject for BlobManifest {
118 fn security_label(&self) -> Option<SecurityLabel> {
119 Some(self.security_label)
120 }
121}
122
123impl ContentBoundLabel for BlobManifest {
124 fn content_id(&self) -> &[u8] {
125 self.cid.as_bytes()
126 }
127
128 fn verify_binding(&self) -> bool {
129 self.recomputed_cid().is_ok_and(|cid| cid == self.cid)
130 }
131}
132
133pub fn cid_from_merkle(algorithm: HashAlgo, merkle_hex: &str) -> Result<String, CasError> {
136 let digest = hex::decode(merkle_hex).map_err(|e| CasError::Hex(e.to_string()))?;
137 encode_cid(Codec::XetShard, algorithm, &digest).map_err(|e| CasError::Cid(e.to_string()))
138}
139
140pub fn merkle_from_address(address: &str) -> Result<String, CasError> {
151 if looks_like_legacy_hex(address) {
152 return Ok(address.to_ascii_lowercase());
153 }
154 let cid = decode_cid(address).map_err(|e| CasError::Cid(e.to_string()))?;
155 if cid.codec != Codec::XetShard {
156 return Err(CasError::Cid(
157 "manifest CID must be resolved through the sealed manifest store".into(),
158 ));
159 }
160 Ok(hex::encode(cid.multihash.digest))
161}
162
163pub(crate) fn looks_like_legacy_hex(address: &str) -> bool {
168 matches!(address.len(), 40 | 64) && address.bytes().all(|b| b.is_ascii_hexdigit())
169}
170
171#[cfg(test)]
172#[allow(clippy::unwrap_used, clippy::expect_used)]
173mod tests {
174 use super::*;
175
176 #[test]
177 fn cid_from_merkle_round_trips_via_address() {
178 let merkle = "ab".repeat(32);
180 let cid = cid_from_merkle(HashAlgo::Blake3, &merkle).unwrap();
181 assert!(cid.starts_with('b'), "canonical CIDv1 base32 prefix");
182 let back = merkle_from_address(&cid).unwrap();
183 assert_eq!(back, merkle);
184 }
185
186 #[test]
187 fn legacy_hex_merkle_passes_through() {
188 let merkle = "cd".repeat(32); assert_eq!(merkle_from_address(&merkle).unwrap(), merkle);
190 assert_eq!(merkle_from_address(&merkle.to_uppercase()).unwrap(), merkle);
192 let sha1 = "ef".repeat(20);
194 assert_eq!(merkle_from_address(&sha1).unwrap(), sha1);
195 }
196
197 #[test]
198 fn cid_and_legacy_hex_resolve_identically() {
199 let merkle = "12".repeat(32);
200 let cid = cid_from_merkle(HashAlgo::Blake3, &merkle).unwrap();
201 assert_eq!(
202 merkle_from_address(&cid).unwrap(),
203 merkle_from_address(&merkle).unwrap(),
204 "a CID and its legacy hex must resolve to the same store key"
205 );
206 }
207
208 #[test]
209 fn rejects_garbage_address() {
210 assert!(merkle_from_address("not-an-address").is_err());
212 assert!(cid_from_merkle(HashAlgo::Blake3, "zz").is_err());
213 }
214
215 #[test]
216 fn sealed_manifest_serializes_with_a_required_label() {
217 use hyprstream_rpc::auth::mac::{Assurance, CompartmentSet, Level};
218 let label =
219 SecurityLabel::new(Level::Internal, Assurance::Classical, CompartmentSet::EMPTY);
220 let m = BlobManifest::new("ab".repeat(32), vec!["cd".repeat(32)], 42, 100, label).unwrap();
221 let json = serde_json::to_string(&m).unwrap();
222 let back: BlobManifest = serde_json::from_str(&json).unwrap();
223 assert_eq!(back, m);
224 assert_eq!(back.security_label, label);
225 assert!(back.verify_binding());
226 }
227
228 #[test]
229 fn changing_a_label_rehashes_the_manifest_cid() {
230 use hyprstream_rpc::auth::mac::{Assurance, CompartmentSet, Level};
231 let internal =
232 SecurityLabel::new(Level::Internal, Assurance::Classical, CompartmentSet::EMPTY);
233 let secret = SecurityLabel::new(Level::Secret, Assurance::Classical, CompartmentSet::EMPTY);
234 let a = BlobManifest::new("ab".repeat(32), vec![], 0, 100, internal).unwrap();
235 let b = BlobManifest::new("ab".repeat(32), vec![], 0, 100, secret).unwrap();
236 assert_ne!(a.cid, b.cid, "relabeling must rehash the manifest");
237 }
238}