feat : Added 4 kb block hashes with a ranged read that only verifies the blocks it touch

Author: abhiprd2000

src/vfs.rs

@@ -2,7 +2,9 @@ use alloc::vec::Vec;
 use alloc::string::String;
 use crate::provenance::provenance_hash;
 use crate::println;
-use crate::task::CryptoVerificationJob;
+
+/// Provenance block granularity (standard 4 KiB, matching fs-verity/dm-verity).
+pub const BLOCK_SIZE: usize = 4096;
 
 #[derive(Debug, Clone)]
 pub enum FileType {
@@ -15,26 +17,72 @@ pub struct FileNode {
     pub name: String,
     pub file_type: FileType,
     pub data: Vec<u8>,
+    /// Whole-file BLAKE3 (baseline path; goes stale after a partial write_block).
     pub provenance_hash: [u8; 32],
+    /// Per-BLOCK_SIZE BLAKE3 leaves; a range read verifies only touched blocks.
+    pub block_hashes: Vec<[u8; 32]>,
+    /// BLAKE3 Merkle root over the leaves, recomputed lazily when dirty.
+    merkle_root: [u8; 32],
+    root_dirty: bool,
+}
+
+/// One BLAKE3 hash per BLOCK_SIZE chunk (last chunk may be short).
+fn compute_block_hashes(data: &[u8]) -> Vec<[u8; 32]> {
+    data.chunks(BLOCK_SIZE).map(|c| provenance_hash(c)).collect()
+}
+
+/// BLAKE3 Merkle root over the leaves: pairs hashed bottom-up, a lone node is
+/// promoted unchanged. Empty input -> zero root.
+fn compute_merkle_root(leaves: &[[u8; 32]]) -> [u8; 32] {
+    if leaves.is_empty() {
+        return [0u8; 32];
+    }
+    let mut level: Vec<[u8; 32]> = leaves.to_vec();
+    while level.len() > 1 {
+        let mut next: Vec<[u8; 32]> = Vec::with_capacity((level.len() + 1) / 2);
+        let mut i = 0;
+        while i < level.len() {
+            if i + 1 < level.len() {
+                let mut buf = [0u8; 64];
+                buf[..32].copy_from_slice(&level[i]);
+                buf[32..].copy_from_slice(&level[i + 1]);
+                next.push(provenance_hash(&buf));
+            } else {
+                next.push(level[i]);
+            }
+            i += 2;
+        }
+        level = next;
+    }
+    level[0]
 }
 
 impl FileNode {
     pub fn new_file(name: &str, data: &[u8]) -> Self {
         let hash = provenance_hash(data);
+        let block_hashes = compute_block_hashes(data);
+        let merkle_root = compute_merkle_root(&block_hashes);
         FileNode {
             name: String::from(name),
             file_type: FileType::Regular,
             data: Vec::from(data),
             provenance_hash: hash,
+            block_hashes,
+            merkle_root,
+            root_dirty: false,
         }
     }
 
     pub fn new_file_untrusted(name: &str, data: &[u8]) -> Self {
+        let nblocks = (data.len() + BLOCK_SIZE - 1) / BLOCK_SIZE;
         FileNode {
             name: String::from(name),
             file_type: FileType::Regular,
             data: Vec::from(data),
             provenance_hash: [0u8; 32], // deliberately invalid — always fails verify()
+            block_hashes: alloc::vec![[0u8; 32]; nblocks], // also fails verify_range()
+            merkle_root: [0u8; 32],
+            root_dirty: false,
         }
     }
 
@@ -44,6 +92,9 @@ impl FileNode {
             file_type: FileType::Directory,
             data: Vec::new(),
             provenance_hash: [0u8; 32],
+            block_hashes: Vec::new(),
+            merkle_root: [0u8; 32],
+            root_dirty: false,
         }
     }
 
@@ -53,6 +104,54 @@ impl FileNode {
             &self.provenance_hash
         )
     }
+
+    /// Block-level: verify only the leaves overlapping [offset, offset+len).
+    pub fn verify_range(&self, offset: usize, len: usize) -> bool {
+        if len == 0 {
+            return true;
+        }
+        let end = core::cmp::min(offset + len, self.data.len());
+        if offset >= end {
+            return false;
+        }
+        let start_block = offset / BLOCK_SIZE;
+        let end_block = (end - 1) / BLOCK_SIZE;
+        for b in start_block..=end_block {
+            let bstart = b * BLOCK_SIZE;
+            let bend = core::cmp::min(bstart + BLOCK_SIZE, self.data.len());
+            let live = provenance_hash(&self.data[bstart..bend]);
+            match self.block_hashes.get(b) {
+                Some(stored) if crate::provenance::constant_time_eq(&live, stored) => {}
+                _ => return false,
+            }
+        }
+        true
+    }
+
+    /// Lazily return the Merkle root, recomputing from leaves only if dirty.
+    pub fn merkle_root(&mut self) -> [u8; 32] {
+        if self.root_dirty {
+            self.merkle_root = compute_merkle_root(&self.block_hashes);
+            self.root_dirty = false;
+        }
+        self.merkle_root
+    }
+
+    /// Overwrite one block: updates that leaf and marks the root dirty, so a
+    /// single-block write costs one block hash instead of a full-file rehash.
+    /// The whole-file `provenance_hash` (baseline only) is left stale.
+    pub fn write_block(&mut self, idx: usize, new_data: &[u8]) -> bool {
+        let bstart = idx * BLOCK_SIZE;
+        if bstart >= self.data.len() || idx >= self.block_hashes.len() {
+            return false;
+        }
+        let bend = core::cmp::min(bstart + BLOCK_SIZE, self.data.len());
+        let n = core::cmp::min(new_data.len(), bend - bstart);
+        self.data[bstart..bstart + n].copy_from_slice(&new_data[..n]);
+        self.block_hashes[idx] = provenance_hash(&self.data[bstart..bend]);
+        self.root_dirty = true;
+        true
+    }
 }
 
 pub struct VirtualFS {
@@ -85,6 +184,35 @@ impl VirtualFS {
         Some(file.data.as_slice())
     }
 
+    /// Block-level verified ranged read: verifies only the blocks overlapping
+    /// the range. Cost scales with bytes read, not total file size.
+    pub fn read_range(&self, name: &str, offset: usize, len: usize) -> Option<&[u8]> {
+        let file = self.files.iter().find(|f| f.name == name)?;
+        let end = core::cmp::min(offset + len, file.data.len());
+        if offset >= end {
+            return None;
+        }
+        if !file.verify_range(offset, len) {
+            println!("[AXIOM KERNEL] READ BLOCKED: \"{}\" block {} provenance violation",
+                name, offset / BLOCK_SIZE);
+            return None;
+        }
+        Some(&file.data[offset..end])
+    }
+
+    /// Overwrite one block of a file (exercises the lazy Merkle path).
+    pub fn write_block(&mut self, name: &str, idx: usize, data: &[u8]) -> bool {
+        match self.files.iter_mut().find(|f| f.name == name) {
+            Some(f) => f.write_block(idx, data),
+            None => false,
+        }
+    }
+
+    /// Current Merkle root for a file (recomputed lazily if dirty).
+    pub fn merkle_root(&mut self, name: &str) -> Option<[u8; 32]> {
+        self.files.iter_mut().find(|f| f.name == name).map(|f| f.merkle_root())
+    }
+
     pub fn verify(&self, name: &str) -> Option<bool> {
         self.files.iter()
             .find(|f| f.name == name)
@@ -106,31 +234,4 @@ impl VirtualFS {
             }
         }
     }
-}
-
-// Atomic State Machine Definitions for Asynchronous Verification
-pub const STATE_PENDING: u8 = 0;
-pub const STATE_VERIFIED: u8 = 1;
-pub const STATE_CORRUPTED: u8 = 2;
-
-pub struct CachedVfsBlock {
-    pub block_id: u64,
-    pub data: [u8; 4096],
-    pub lineage_token: u64,
-    pub status: core::sync::atomic::AtomicU8, 
-}
-
-pub fn read_block_async(block: &mut CachedVfsBlock) {
-    block.status.store(STATE_PENDING, core::sync::atomic::Ordering::Relaxed);
-
-    let job = CryptoVerificationJob {
-        block_ptr: block as *mut CachedVfsBlock,
-        expected_hash: [0u8; 32],
-    };
-
-    if let Some(queue) = crate::task::VERIFICATION_QUEUE.get() {
-        let _ = queue.push(job);
-    }
-    
-    crate::task::yield_current_thread(); 
 }