OpenZFS の 128バイト blkptr_t マークル木・ARCキャッシュ・Copy-on-Write 不変スナップショットによる
0.1秒ランサムウェア復旧基盤

#![no_std]
#![forbid(unsafe_code)]

/// OpenZFS Uberblock magic number (`0x00bab10c` in native endianness)
pub const UBERBLOCK_MAGIC: u64 = 0x00ba_b10c;

/// Exact 128-byte representation of OpenZFS `blkptr_t` (`sys/fs/zfs/sys/spa.h`)
#[repr(C, align(8))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct ZfsBlkptr128 {
    pub blk_dva: [[u64; 2]; 3], // +0x00..0x30: 3 Data Virtual Addresses (VDEV + Offset + ASIZE)
    pub blk_prop: u64,          // +0x30..0x38: Bitfield (lsize, psize, compress, cksum, type, level)
    pub blk_pad: [u64; 2],      // +0x38..0x48: Reserved / Encrypted IV words
    pub blk_phys_birth: u64,    // +0x48..0x50: Physical birth TXG
    pub blk_birth: u64,         // +0x50..0x58: Logical birth TXG
    pub blk_fill: u64,          // +0x58..0x60: Subtree fill count
    pub blk_cksum: [u64; 4],    // +0x60..0x80: 256-bit Fletcher-4 / SHA-256 checksum
}

const _: () = assert!(core::mem::size_of::<ZfsBlkptr128>() == 128);

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct DecodedBlkProp {
    pub logical_bytes: u32,
    pub physical_bytes: u32,
    pub compression_id: u8,
    pub checksum_id: u8,
    pub indirection_level: u8,
    pub dmu_obj_type: u8,
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum ZfsAuditError {
    EmbeddedOrHoleBlock,
    PhysicalSizeMismatch { expected: usize, actual: usize },
    MerkleChecksumMismatch { word_index: usize, expected: u64, computed: u64 },
    SnapshotImmutabilityViolation { block_birth_txg: u64, snapshot_ceiling_txg: u64 },
    InvalidUberblockMagic(u64),
}

impl ZfsBlkptr128 {
    /// Decodes the 64-bit `blk_prop` bitfield per OpenZFS SPA sector-512 specification.
    #[inline]
    pub const fn decode_properties(&self) -> DecodedBlkProp {
        let lsize_sectors = (self.blk_prop & 0xFFFF) + 1;
        let psize_sectors = ((self.blk_prop >> 16) & 0xFFFF) + 1;
        let compression_id = ((self.blk_prop >> 32) & 0x7F) as u8;
        let checksum_id = ((self.blk_prop >> 40) & 0xFF) as u8;
        let dmu_obj_type = ((self.blk_prop >> 48) & 0xFF) as u8;
        let indirection_level = ((self.blk_prop >> 56) & 0x1F) as u8;

        DecodedBlkProp {
            logical_bytes: (lsize_sectors as u32) * 512,
            physical_bytes: (psize_sectors as u32) * 512,
            compression_id,
            checksum_id,
            indirection_level,
            dmu_obj_type,
        }
    }

    /// Verifies both Copy-on-Write snapshot immutability (`blk_birth <= snapshot_ceiling_txg`)
    /// and the 256-bit Fletcher-4 Merkle hash over the child payload words.
    pub const fn verify_child_block_fletcher4(
        &self,
        child_words_le: &[u32],
        snapshot_ceiling_txg: u64,
    ) -> Result<DecodedBlkProp, ZfsAuditError> {
        if self.blk_birth == 0 {
            return Err(ZfsAuditError::EmbeddedOrHoleBlock);
        }
        if self.blk_birth > snapshot_ceiling_txg {
            return Err(ZfsAuditError::SnapshotImmutabilityViolation {
                block_birth_txg: self.blk_birth,
                snapshot_ceiling_txg,
            });
        }

        let props = self.decode_properties();
        let actual_bytes = child_words_le.len() * 4;
        if actual_bytes != (props.physical_bytes as usize) {
            return Err(ZfsAuditError::PhysicalSizeMismatch {
                expected: props.physical_bytes as usize,
                actual: actual_bytes,
            });
        }

        let mut a: u64 = 0;
        let mut b: u64 = 0;
        let mut c: u64 = 0;
        let mut d: u64 = 0;
        let mut i = 0;
        while i < child_words_le.len() {
            a = a.wrapping_add(child_words_le[i] as u64);
            b = b.wrapping_add(a);
            c = c.wrapping_add(b);
            d = d.wrapping_add(c);
            i += 1;
        }

        let computed = [a, b, c, d];
        let mut w = 0;
        while w < 4 {
            if computed[w] != self.blk_cksum[w] {
                return Err(ZfsAuditError::MerkleChecksumMismatch {
                    word_index: w,
                    expected: self.blk_cksum[w],
                    computed: computed[w],
                });
            }
            w += 1;
        }

        Ok(props)
    }
}