1use sha2::{Digest, Sha256};
9
10use crate::crypto::network::digest::sha384;
11use crate::net::peer::replication::manifest::{ByteRange, ContentManifest};
12use crate::net::peer::replication::scan::{Q42_QUINS_PER_SUPERBLOCK, Q42_SUPERBLOCK_BYTES};
13use crate::net::peer::runtime::ledger::{
14 ChargeRef, ReservationHandle, ReservationLedger, ResourceBudget,
15};
16use crate::net::qdnf::errors::QdnfError;
17use crate::net::qdnf::types::{Generation, StrongDigest};
18
19pub const MAX_BLOCKS: usize = 8;
21pub const MAX_BLOCK_BYTES: u32 = 16 * 1024;
23pub const SUPERBLOCK_CHUNKS_MAX: usize = 3;
25
26const ADMIT_WORK: u64 = 1;
27const ADMIT_IO: u64 = 1;
28const RETRY_WORK: u64 = 1;
29const RETRY_IO: u64 = 1;
30
31#[derive(Clone, Copy)]
32struct Slot {
33 occupied: bool,
34 verified: bool,
35 digest: StrongDigest,
36 expected: StrongDigest,
38 block_index: u8,
39 generation: Generation,
40 range: ByteRange,
41 charge: ChargeRef,
42}
43
44pub struct TransferTable {
46 slots: [Slot; MAX_BLOCKS],
47}
48
49impl TransferTable {
50 pub const fn new() -> Self {
52 Self {
53 slots: [Slot {
54 occupied: false,
55 verified: false,
56 digest: StrongDigest::ZERO,
57 expected: StrongDigest::ZERO,
58 block_index: 0,
59 generation: Generation::ZERO,
60 range: ByteRange { offset: 0, len: 0 },
61 charge: ChargeRef::EMPTY,
62 }; MAX_BLOCKS],
63 }
64 }
65
66 pub fn occupied_count(&self) -> usize {
68 let mut n = 0usize;
69 let mut i = 0usize;
70 while i < MAX_BLOCKS {
71 if self.slots[i].occupied {
72 n += 1;
73 }
74 i += 1;
75 }
76 n
77 }
78}
79
80pub fn admit_block(
87 table: &mut TransferTable,
88 ledger: &mut ReservationLedger,
89 manifest_digest: StrongDigest,
90 block_index: u8,
91 len: u32,
92 generation: Generation,
93) -> Result<(), QdnfError> {
94 admit_block_with_digest(
95 table,
96 ledger,
97 manifest_digest,
98 block_index,
99 len,
100 generation,
101 StrongDigest::ZERO,
102 )
103}
104
105pub fn admit_block_with_digest(
107 table: &mut TransferTable,
108 ledger: &mut ReservationLedger,
109 manifest_digest: StrongDigest,
110 block_index: u8,
111 len: u32,
112 generation: Generation,
113 expected: StrongDigest,
114) -> Result<(), QdnfError> {
115 admit_range(
116 table,
117 ledger,
118 manifest_digest,
119 block_index,
120 ByteRange { offset: 0, len },
121 generation,
122 expected,
123 )
124}
125
126pub fn admit_manifest_block(
128 table: &mut TransferTable,
129 ledger: &mut ReservationLedger,
130 manifest: &ContentManifest,
131 block_index: u8,
132 generation: Generation,
133) -> Result<(), QdnfError> {
134 let range = manifest_block_range(manifest, block_index)?;
135 admit_range(
136 table,
137 ledger,
138 manifest.digest,
139 block_index,
140 range,
141 generation,
142 StrongDigest::ZERO,
143 )
144}
145
146pub fn manifest_block_range(
148 manifest: &ContentManifest,
149 block_index: u8,
150) -> Result<ByteRange, QdnfError> {
151 if block_index as usize >= MAX_BLOCKS {
152 return Err(QdnfError::Range);
153 }
154 let range = manifest.range_at(block_index as usize)?;
155 check_len(range.len)?;
156 Ok(range)
157}
158
159pub fn retry_block(
162 table: &mut TransferTable,
163 ledger: &mut ReservationLedger,
164 manifest_digest: StrongDigest,
165 block_index: u8,
166 generation: Generation,
167) -> Result<(), QdnfError> {
168 if manifest_digest == StrongDigest::ZERO {
169 return Err(QdnfError::Malformed);
170 }
171 match find_slot(table, &manifest_digest, block_index, generation) {
172 Some(_) => {
173 let handle = ledger.reserve(retry_budget(), true)?;
174 let _ = handle;
175 Ok(())
176 }
177 None => Err(QdnfError::Incomplete),
178 }
179}
180
181pub fn verify_block(
190 table: &mut TransferTable,
191 manifest_digest: StrongDigest,
192 block_index: u8,
193 generation: Generation,
194 payload: &[u8],
195) -> Result<(), QdnfError> {
196 if manifest_digest == StrongDigest::ZERO {
197 return Err(QdnfError::Malformed);
198 }
199 let idx =
200 find_slot(table, &manifest_digest, block_index, generation).ok_or(QdnfError::Incomplete)?;
201 let range_len = table.slots[idx].range.len;
202 if range_len == 0 {
203 return Err(QdnfError::Range);
204 }
205 if payload.is_empty() {
206 return Err(QdnfError::Malformed);
207 }
208 if payload.len() != range_len as usize {
209 return Err(QdnfError::Range);
210 }
211 let hashed = sha384(payload);
212 let want = if table.slots[idx].expected != StrongDigest::ZERO {
213 table.slots[idx].expected
214 } else {
215 table.slots[idx].digest
216 };
217 if hashed != want {
218 table.slots[idx].verified = false;
219 return Err(QdnfError::Conflict);
220 }
221 table.slots[idx].verified = true;
222 Ok(())
223}
224
225pub fn block_verified(
227 table: &TransferTable,
228 manifest_digest: StrongDigest,
229 block_index: u8,
230 generation: Generation,
231) -> bool {
232 match find_slot(table, &manifest_digest, block_index, generation) {
233 Some(i) => table.slots[i].verified,
234 None => false,
235 }
236}
237
238pub fn release_block(
240 table: &mut TransferTable,
241 ledger: &mut ReservationLedger,
242 manifest_digest: StrongDigest,
243 block_index: u8,
244 generation: Generation,
245) -> Result<(), QdnfError> {
246 if manifest_digest == StrongDigest::ZERO {
247 return Err(QdnfError::Malformed);
248 }
249 let idx =
250 find_slot(table, &manifest_digest, block_index, generation).ok_or(QdnfError::Incomplete)?;
251 let charged = table.slots[idx].charge;
252 ledger.release(ReservationHandle::from_ref(charged))?;
253 table.slots[idx].occupied = false;
254 table.slots[idx].verified = false;
255 Ok(())
256}
257
258#[inline]
260pub fn shared_receive_storage_verify_is_one_charge() -> bool {
261 true
262}
263
264#[inline]
266pub fn retries_charge_parent() -> bool {
267 true
268}
269
270#[repr(C)]
275#[derive(Clone, Copy, Debug, PartialEq, Eq)]
276pub struct SuperBlockManifestBridge {
277 pub manifest_digest: StrongDigest,
278 pub chunk_digests: [StrongDigest; SUPERBLOCK_CHUNKS_MAX],
279 pub chunk_lens: [u32; SUPERBLOCK_CHUNKS_MAX],
280 pub chunk_count: u8,
281 pub superblock_sha256: [u8; 32],
282 pub total_superblock_bytes: u32,
283}
284
285pub fn verify_chunk_to_superblock_bridge(
289 bridge: &SuperBlockManifestBridge,
290 chunks: &[&[u8]],
291) -> Result<usize, QdnfError> {
292 if bridge.manifest_digest == StrongDigest::ZERO {
293 return Err(QdnfError::Malformed);
294 }
295 let count = bridge.chunk_count as usize;
296 if count == 0 || count > SUPERBLOCK_CHUNKS_MAX || count != chunks.len() {
297 return Err(QdnfError::Range);
298 }
299 if bridge.total_superblock_bytes == 0
300 || bridge.total_superblock_bytes as usize > Q42_SUPERBLOCK_BYTES
301 {
302 return Err(QdnfError::Range);
303 }
304
305 let mut sha256_hasher = Sha256::new();
306 let mut total_bytes = 0usize;
307 let max_quin_bytes = Q42_QUINS_PER_SUPERBLOCK * 48;
308 let mut carry = [0u8; 48];
309 let mut carry_len = 0usize;
310 let mut verified_quins = 0usize;
311
312 let mut c_idx = 0usize;
313 while c_idx < count {
314 let chunk = chunks[c_idx];
315 let expected_len = bridge.chunk_lens[c_idx];
316 check_len(expected_len)?;
317 if chunk.len() != expected_len as usize {
318 return Err(QdnfError::Range);
319 }
320 if sha384(chunk) != bridge.chunk_digests[c_idx] {
321 return Err(QdnfError::Conflict);
322 }
323 sha256_hasher.update(chunk);
324
325 let mut b_idx = 0usize;
326 while b_idx < chunk.len() {
327 if total_bytes < max_quin_bytes {
328 carry[carry_len] = chunk[b_idx];
329 carry_len += 1;
330 if carry_len == 48 {
331 if !quin_bytes_have_valid_5field_parity(&carry) {
332 return Err(QdnfError::Conflict);
333 }
334 verified_quins += 1;
335 carry_len = 0;
336 }
337 }
338 total_bytes += 1;
339 b_idx += 1;
340 }
341 c_idx += 1;
342 }
343
344 if total_bytes != bridge.total_superblock_bytes as usize {
345 return Err(QdnfError::Range);
346 }
347 let actual_sha256 = sha256_hasher.finalize();
348 if actual_sha256.as_slice() != bridge.superblock_sha256.as_slice() {
349 return Err(QdnfError::Conflict);
350 }
351 Ok(verified_quins)
352}
353
354#[inline]
355fn quin_bytes_have_valid_5field_parity(b: &[u8; 48]) -> bool {
356 let s = u64::from_le_bytes([b[0], b[1], b[2], b[3], b[4], b[5], b[6], b[7]]);
357 let p = u64::from_le_bytes([b[8], b[9], b[10], b[11], b[12], b[13], b[14], b[15]]);
358 let o = u64::from_le_bytes([b[16], b[17], b[18], b[19], b[20], b[21], b[22], b[23]]);
359 let c = u64::from_le_bytes([b[24], b[25], b[26], b[27], b[28], b[29], b[30], b[31]]);
360 let m = u64::from_le_bytes([b[32], b[33], b[34], b[35], b[36], b[37], b[38], b[39]]);
361 let parity = u64::from_le_bytes([b[40], b[41], b[42], b[43], b[44], b[45], b[46], b[47]]);
362 (s ^ p ^ o ^ c ^ m) == parity
363}
364
365fn check_len(len: u32) -> Result<(), QdnfError> {
366 if len == 0 || len > MAX_BLOCK_BYTES {
367 return Err(QdnfError::Range);
368 }
369 Ok(())
370}
371
372fn admit_budget(len: u32) -> ResourceBudget {
373 ResourceBudget {
374 bytes: u64::from(len),
375 work: ADMIT_WORK,
376 io: ADMIT_IO,
377 }
378}
379
380fn retry_budget() -> ResourceBudget {
381 ResourceBudget {
382 bytes: 0,
383 work: RETRY_WORK,
384 io: RETRY_IO,
385 }
386}
387
388fn admit_range(
389 table: &mut TransferTable,
390 ledger: &mut ReservationLedger,
391 digest: StrongDigest,
392 block_index: u8,
393 range: ByteRange,
394 generation: Generation,
395 expected: StrongDigest,
396) -> Result<(), QdnfError> {
397 if digest == StrongDigest::ZERO {
398 return Err(QdnfError::Malformed);
399 }
400 if block_index as usize >= MAX_BLOCKS {
401 return Err(QdnfError::Range);
402 }
403 check_len(range.len)?;
404 if find_slot(table, &digest, block_index, generation).is_some() {
405 return Ok(());
406 }
407 let free = find_free(table).ok_or(QdnfError::Capacity)?;
408 let charged = admit_budget(range.len);
409 let handle = ledger.reserve(charged, true)?;
410 table.slots[free] = Slot {
411 occupied: true,
412 verified: false,
413 digest,
414 expected,
415 block_index,
416 generation,
417 range,
418 charge: handle.as_ref(),
419 };
420 Ok(())
421}
422
423fn find_slot(
424 table: &TransferTable,
425 digest: &StrongDigest,
426 block_index: u8,
427 generation: Generation,
428) -> Option<usize> {
429 let mut i = 0usize;
430 while i < MAX_BLOCKS {
431 let s = &table.slots[i];
432 if s.occupied
433 && s.digest == *digest
434 && s.block_index == block_index
435 && s.generation == generation
436 {
437 return Some(i);
438 }
439 i += 1;
440 }
441 None
442}
443
444fn find_free(table: &TransferTable) -> Option<usize> {
445 let mut i = 0usize;
446 while i < MAX_BLOCKS {
447 if !table.slots[i].occupied {
448 return Some(i);
449 }
450 i += 1;
451 }
452 None
453}
454
455#[cfg(test)]
456mod tests {
457 use super::*;
458
459 fn digest(tag: u8) -> StrongDigest {
460 let mut d = StrongDigest::ZERO;
461 d.0[0] = tag;
462 d
463 }
464
465 fn fill_payload(buf: &mut [u8], tag: u8) -> StrongDigest {
466 let mut i = 0usize;
467 while i < buf.len() {
468 buf[i] = tag;
469 i += 1;
470 }
471 sha384(buf)
472 }
473
474 fn slot_verified(
475 table: &TransferTable,
476 d: StrongDigest,
477 block_index: u8,
478 generation: Generation,
479 ) -> bool {
480 match find_slot(table, &d, block_index, generation) {
481 Some(i) => table.slots[i].verified,
482 None => false,
483 }
484 }
485
486 fn fat_ledger() -> ReservationLedger {
487 let cap = ResourceBudget {
488 bytes: u64::from(MAX_BLOCK_BYTES) * MAX_BLOCKS as u64 * 4,
489 work: 64,
490 io: 64,
491 };
492 ReservationLedger::new(cap, cap, cap, cap, cap)
493 }
494
495 fn tight_ledger() -> ReservationLedger {
496 let cap = ResourceBudget {
497 bytes: 0,
498 work: 64,
499 io: 64,
500 };
501 ReservationLedger::new(cap, cap, cap, cap, cap)
502 }
503
504 #[test]
505 fn ninth_block_is_capacity() {
506 let mut table = TransferTable::new();
507 let mut ledger = fat_ledger();
508 let gen = Generation(1);
509 let mut i = 0u8;
510 while i < MAX_BLOCKS as u8 {
511 admit_block(&mut table, &mut ledger, digest(i + 1), 0, 32, gen).unwrap();
512 i += 1;
513 }
514 assert_eq!(table.occupied_count(), MAX_BLOCKS);
515 assert_eq!(
516 admit_block(&mut table, &mut ledger, digest(9), 0, 32, gen),
517 Err(QdnfError::Capacity)
518 );
519 assert_eq!(table.occupied_count(), MAX_BLOCKS);
520 }
521
522 #[test]
523 fn len_zero_and_over_max_are_range() {
524 let mut table = TransferTable::new();
525 let mut ledger = fat_ledger();
526 let gen = Generation(1);
527 assert_eq!(
528 admit_block(&mut table, &mut ledger, digest(1), 0, 0, gen),
529 Err(QdnfError::Range)
530 );
531 assert_eq!(
532 admit_block(
533 &mut table,
534 &mut ledger,
535 digest(1),
536 0,
537 MAX_BLOCK_BYTES + 1,
538 gen
539 ),
540 Err(QdnfError::Range)
541 );
542 admit_block(&mut table, &mut ledger, digest(1), 0, MAX_BLOCK_BYTES, gen).unwrap();
543 assert_eq!(table.occupied_count(), 1);
544 }
545
546 #[test]
547 fn retry_charges_additional_io_on_parent() {
548 assert!(retries_charge_parent());
549 let mut table = TransferTable::new();
550 let mut ledger = fat_ledger();
551 let gen = Generation(2);
552 admit_block(&mut table, &mut ledger, digest(3), 1, 64, gen).unwrap();
553 let io_before = ledger.used().host.io;
554 let bytes_before = ledger.used().host.bytes;
555 retry_block(&mut table, &mut ledger, digest(3), 1, gen).unwrap();
556 assert!(ledger.used().host.io > io_before);
557 assert_eq!(ledger.used().host.bytes, bytes_before);
558 assert_eq!(table.occupied_count(), 1);
559 assert_eq!(
560 retry_block(&mut table, &mut ledger, digest(4), 1, gen),
561 Err(QdnfError::Incomplete)
562 );
563 }
564
565 #[test]
566 fn old_and_new_generation_both_reserved() {
567 let mut table = TransferTable::new();
568 let mut ledger = fat_ledger();
569 let old = Generation(1);
570 let new = Generation(2);
571 let len = 48u32;
572 let mut payload = [0u8; 48];
573 let expected = fill_payload(&mut payload, 0x51);
574 admit_block_with_digest(&mut table, &mut ledger, digest(5), 0, len, old, expected).unwrap();
575 admit_block_with_digest(&mut table, &mut ledger, digest(5), 0, len, new, expected).unwrap();
576 assert_eq!(table.occupied_count(), 2);
577 assert_eq!(ledger.used().host.bytes, u64::from(len) * 2);
578 release_block(&mut table, &mut ledger, digest(5), 0, old).unwrap();
579 assert_eq!(table.occupied_count(), 1);
580 assert_eq!(ledger.used().host.bytes, u64::from(len));
581 verify_block(&mut table, digest(5), 0, new, &payload).unwrap();
582 assert!(slot_verified(&table, digest(5), 0, new));
583 assert_eq!(
584 verify_block(&mut table, digest(5), 0, old, &payload),
585 Err(QdnfError::Incomplete)
586 );
587 }
588
589 #[test]
590 fn verify_without_admit_is_incomplete() {
591 let mut table = TransferTable::new();
592 assert_eq!(
593 verify_block(&mut table, digest(1), 0, Generation(1), &[0u8; 16]),
594 Err(QdnfError::Incomplete)
595 );
596 }
597
598 #[test]
599 fn zero_digest_is_malformed() {
600 let mut table = TransferTable::new();
601 let mut ledger = fat_ledger();
602 let z = StrongDigest::ZERO;
603 let gen = Generation(1);
604 assert_eq!(
605 admit_block(&mut table, &mut ledger, z, 0, 8, gen),
606 Err(QdnfError::Malformed)
607 );
608 assert_eq!(table.occupied_count(), 0);
609 assert_eq!(
610 retry_block(&mut table, &mut ledger, z, 0, gen),
611 Err(QdnfError::Malformed)
612 );
613 assert_eq!(
614 verify_block(&mut table, z, 0, gen, &[1u8; 8]),
615 Err(QdnfError::Malformed)
616 );
617 }
618
619 #[test]
620 fn shared_receive_storage_verify_is_one_charge_true() {
621 assert!(shared_receive_storage_verify_is_one_charge());
622 let mut table = TransferTable::new();
623 let mut ledger = fat_ledger();
624 let gen = Generation(1);
625 let ranges = [ByteRange { offset: 0, len: 16 }];
626 let m = ContentManifest::bind(digest(1), 0, 64, &ranges).unwrap();
627 let range = manifest_block_range(&m, 0).unwrap();
628 let mut payload = [0u8; 16];
629 let expected = fill_payload(&mut payload, 0x10);
630 admit_block_with_digest(
631 &mut table,
632 &mut ledger,
633 m.digest,
634 0,
635 range.len,
636 gen,
637 expected,
638 )
639 .unwrap();
640 let after_admit = ledger.used().host;
641 assert_eq!(after_admit.bytes, u64::from(range.len));
642 assert_eq!(after_admit.work, ADMIT_WORK);
643 assert_eq!(after_admit.io, ADMIT_IO);
644 verify_block(&mut table, m.digest, 0, gen, &payload).unwrap();
645 assert!(slot_verified(&table, m.digest, 0, gen));
646 assert_eq!(ledger.used().host, after_admit);
647 let mut table2 = TransferTable::new();
649 let mut ledger2 = fat_ledger();
650 admit_manifest_block(&mut table2, &mut ledger2, &m, 0, gen).unwrap();
651 assert_eq!(ledger2.used().host.bytes, u64::from(range.len));
652 }
653
654 #[test]
655 fn exhausted_ledger_leaves_table_unchanged() {
656 let mut table = TransferTable::new();
657 let mut ledger = tight_ledger();
658 let before = table.occupied_count();
659 let used_before = ledger.used();
660 assert_eq!(
661 admit_block(&mut table, &mut ledger, digest(1), 0, 16, Generation(1)),
662 Err(QdnfError::BudgetExhausted)
663 );
664 assert_eq!(table.occupied_count(), before);
665 assert_eq!(ledger.used(), used_before);
666 }
667
668 #[test]
669 fn matching_payload_sets_verified() {
670 let mut table = TransferTable::new();
671 let mut ledger = fat_ledger();
672 let gen = Generation(1);
673 let mut payload = [0u8; 32];
674 let expected = fill_payload(&mut payload, 0xAB);
675 admit_block_with_digest(&mut table, &mut ledger, digest(7), 0, 32, gen, expected).unwrap();
676 assert!(!slot_verified(&table, digest(7), 0, gen));
677 assert!(!block_verified(&table, digest(7), 0, gen));
678 verify_block(&mut table, digest(7), 0, gen, &payload).unwrap();
679 assert!(slot_verified(&table, digest(7), 0, gen));
680 assert!(block_verified(&table, digest(7), 0, gen));
681 }
682
683 #[test]
684 fn wrong_payload_digest_is_conflict_and_verified_stays_false() {
685 let mut table = TransferTable::new();
686 let mut ledger = fat_ledger();
687 let gen = Generation(1);
688 let mut good = [0u8; 32];
689 let expected = fill_payload(&mut good, 0x01);
690 let mut bad = [0u8; 32];
691 fill_payload(&mut bad, 0x02);
692 admit_block_with_digest(&mut table, &mut ledger, digest(8), 0, 32, gen, expected).unwrap();
693 assert_eq!(
694 verify_block(&mut table, digest(8), 0, gen, &bad),
695 Err(QdnfError::Conflict)
696 );
697 assert!(!slot_verified(&table, digest(8), 0, gen));
698 verify_block(&mut table, digest(8), 0, gen, &good).unwrap();
699 assert!(slot_verified(&table, digest(8), 0, gen));
700 }
701
702 #[test]
703 fn empty_payload_with_nonzero_len_is_malformed() {
704 let mut table = TransferTable::new();
705 let mut ledger = fat_ledger();
706 let gen = Generation(1);
707 let mut payload = [0u8; 8];
708 let expected = fill_payload(&mut payload, 0x03);
709 admit_block_with_digest(&mut table, &mut ledger, digest(9), 0, 8, gen, expected).unwrap();
710 assert_eq!(
711 verify_block(&mut table, digest(9), 0, gen, &[]),
712 Err(QdnfError::Malformed)
713 );
714 assert!(!slot_verified(&table, digest(9), 0, gen));
715 }
716
717 #[test]
718 fn payload_len_mismatch_is_range() {
719 let mut table = TransferTable::new();
720 let mut ledger = fat_ledger();
721 let gen = Generation(1);
722 let mut payload = [0u8; 8];
723 let expected = fill_payload(&mut payload, 0x04);
724 admit_block_with_digest(&mut table, &mut ledger, digest(10), 0, 8, gen, expected).unwrap();
725 assert_eq!(
726 verify_block(&mut table, digest(10), 0, gen, &[0u8; 4]),
727 Err(QdnfError::Range)
728 );
729 assert!(!slot_verified(&table, digest(10), 0, gen));
730 }
731
732 #[test]
733 fn r08_chunk_to_superblock_manifest_bridge_verifies_sha384_sha256_and_quin_parity() {
734 let mut chunk0 = [0u8; 48];
736 let s0 = 0x101u64;
737 let p0 = 0x202u64;
738 let o0 = 0x303u64;
739 let c0 = 0x404u64;
740 let m0 = 0x505u64;
741 let par0 = s0 ^ p0 ^ o0 ^ c0 ^ m0;
742 chunk0[0..8].copy_from_slice(&s0.to_le_bytes());
743 chunk0[8..16].copy_from_slice(&p0.to_le_bytes());
744 chunk0[16..24].copy_from_slice(&o0.to_le_bytes());
745 chunk0[24..32].copy_from_slice(&c0.to_le_bytes());
746 chunk0[32..40].copy_from_slice(&m0.to_le_bytes());
747 chunk0[40..48].copy_from_slice(&par0.to_le_bytes());
748
749 let chunk1 = [0u8; 48]; let mut sha256_hasher = Sha256::new();
752 sha256_hasher.update(&chunk0);
753 sha256_hasher.update(&chunk1);
754 let mut sb_sha256 = [0u8; 32];
755 sb_sha256.copy_from_slice(&sha256_hasher.finalize());
756
757 let bridge = SuperBlockManifestBridge {
758 manifest_digest: digest(0x77),
759 chunk_digests: [sha384(&chunk0), sha384(&chunk1), StrongDigest::ZERO],
760 chunk_lens: [48, 48, 0],
761 chunk_count: 2,
762 superblock_sha256: sb_sha256,
763 total_superblock_bytes: 96,
764 };
765
766 let slices: [&[u8]; 2] = [&chunk0, &chunk1];
767 assert_eq!(verify_chunk_to_superblock_bridge(&bridge, &slices), Ok(2));
768
769 let mut bad_bridge = bridge;
771 bad_bridge.superblock_sha256[0] ^= 0xFF;
772 assert_eq!(
773 verify_chunk_to_superblock_bridge(&bad_bridge, &slices),
774 Err(QdnfError::Conflict)
775 );
776 }
777}