lcpfs 2026.1.102

//! LunaVault Block Device
//!
//! Transparent encryption block device for mounted volumes.

#![cfg_attr(not(feature = "std"), no_std)]

extern crate alloc;

use alloc::string::String;
use alloc::vec;
use alloc::vec::Vec;
use core::sync::atomic::{AtomicBool, AtomicU64, Ordering};

use super::crypto::*;
use super::types::*;
use super::volume::VolumeStorage;

// ============================================================================
// Block Device Trait
// ============================================================================

/// Block device trait for encrypted storage.
pub trait VaultBlockDeviceTrait {
    /// Read data at offset.
    fn read(&self, offset: u64, buf: &mut [u8]) -> Result<usize, VaultError>;

    /// Write data at offset.
    fn write(&mut self, offset: u64, buf: &[u8]) -> Result<usize, VaultError>;

    /// Get total size.
    fn size(&self) -> u64;

    /// Sync to underlying storage.
    fn sync(&mut self) -> Result<(), VaultError>;

    /// Check if read-only.
    fn is_read_only(&self) -> bool;
}

// ============================================================================
// Vault Block Device
// ============================================================================

/// Block device backed by an encrypted container.
/// Provides transparent encryption/decryption.
pub struct VaultBlockDevice {
    /// Underlying volume storage.
    storage: VolumeStorage,
    /// Master encryption key.
    master_key: [u8; 64],
    /// Secondary key (for XTS mode).
    secondary_key: [u8; 64],
    /// Offset to encrypted data area.
    data_offset: u64,
    /// Size of encrypted data area.
    data_size: u64,
    /// Encryption algorithm.
    algorithm: EncryptionAlgorithm,
    /// Sector size.
    sector_size: u32,
    /// Read-only mode.
    read_only: bool,
    /// Protected range start (for hidden volume protection).
    protected_start: Option<u64>,
    /// Protected range end.
    protected_end: Option<u64>,
    /// Statistics: bytes read.
    bytes_read: AtomicU64,
    /// Statistics: bytes written.
    bytes_written: AtomicU64,
    /// Statistics: sectors encrypted.
    sectors_encrypted: AtomicU64,
    /// Statistics: sectors decrypted.
    sectors_decrypted: AtomicU64,
    /// Is device open.
    is_open: AtomicBool,
}

impl VaultBlockDevice {
    /// Create a new vault block device from header and storage.
    pub fn new(
        storage: VolumeStorage,
        header: &VaultHeader,
        algorithm: EncryptionAlgorithm,
        read_only: bool,
    ) -> Self {
        Self {
            storage,
            master_key: header.master_key,
            secondary_key: header.secondary_key,
            data_offset: header.data_offset,
            data_size: header.data_size,
            algorithm,
            sector_size: header.sector_size,
            read_only,
            protected_start: None,
            protected_end: None,
            bytes_read: AtomicU64::new(0),
            bytes_written: AtomicU64::new(0),
            sectors_encrypted: AtomicU64::new(0),
            sectors_decrypted: AtomicU64::new(0),
            is_open: AtomicBool::new(true),
        }
    }

    /// Set protected range for hidden volume protection.
    pub fn set_protected_range(&mut self, start: u64, end: u64) {
        self.protected_start = Some(start);
        self.protected_end = Some(end);
    }

    /// Clear protected range.
    pub fn clear_protected_range(&mut self) {
        self.protected_start = None;
        self.protected_end = None;
    }

    /// Check if offset is in protected range.
    fn is_protected(&self, offset: u64, len: u64) -> bool {
        if let (Some(start), Some(end)) = (self.protected_start, self.protected_end) {
            let range_end = offset + len;
            // Check for overlap
            offset < end && range_end > start
        } else {
            false
        }
    }

    /// Get statistics.
    pub fn stats(&self) -> VaultBlockDeviceStats {
        VaultBlockDeviceStats {
            bytes_read: self.bytes_read.load(Ordering::Relaxed),
            bytes_written: self.bytes_written.load(Ordering::Relaxed),
            sectors_encrypted: self.sectors_encrypted.load(Ordering::Relaxed),
            sectors_decrypted: self.sectors_decrypted.load(Ordering::Relaxed),
        }
    }

    /// Close the device.
    pub fn close(&mut self) {
        self.is_open.store(false, Ordering::SeqCst);
        // Zeroize keys
        self.master_key = [0u8; 64];
        self.secondary_key = [0u8; 64];
    }

    /// Check if device is open.
    pub fn is_open(&self) -> bool {
        self.is_open.load(Ordering::SeqCst)
    }

    /// Get underlying storage (consumes self).
    pub fn into_storage(mut self) -> VolumeStorage {
        self.close();
        self.storage
    }
}

impl VaultBlockDeviceTrait for VaultBlockDevice {
    fn read(&self, offset: u64, buf: &mut [u8]) -> Result<usize, VaultError> {
        if !self.is_open() {
            return Err(VaultError::NotMounted);
        }

        if offset + buf.len() as u64 > self.data_size {
            return Err(VaultError::IoError("Read past end of volume".into()));
        }

        let sector_size = self.sector_size as usize;
        let file_offset = self.data_offset + offset;

        // Read encrypted data
        let encrypted = self.storage.read(file_offset, buf.len())?;

        // Decrypt sector by sector
        let start_sector = offset / sector_size as u64;
        let mut decrypted = encrypted;

        for (i, chunk) in decrypted.chunks_mut(sector_size).enumerate() {
            let sector_num = start_sector + i as u64;
            decrypt_sector(
                chunk,
                sector_num,
                &self.master_key,
                &self.secondary_key,
                self.algorithm,
            );
            self.sectors_decrypted.fetch_add(1, Ordering::Relaxed);
        }

        buf.copy_from_slice(&decrypted);
        self.bytes_read
            .fetch_add(buf.len() as u64, Ordering::Relaxed);

        Ok(buf.len())
    }

    fn write(&mut self, offset: u64, buf: &[u8]) -> Result<usize, VaultError> {
        if !self.is_open() {
            return Err(VaultError::NotMounted);
        }

        if self.read_only {
            return Err(VaultError::IoError("Volume is read-only".into()));
        }

        if offset + buf.len() as u64 > self.data_size {
            return Err(VaultError::IoError("Write past end of volume".into()));
        }

        // Check protected range
        if self.is_protected(offset, buf.len() as u64) {
            return Err(VaultError::ProtectedAreaViolation);
        }

        let sector_size = self.sector_size as usize;
        let file_offset = self.data_offset + offset;

        // Encrypt sector by sector
        let start_sector = offset / sector_size as u64;
        let mut encrypted = buf.to_vec();

        for (i, chunk) in encrypted.chunks_mut(sector_size).enumerate() {
            let sector_num = start_sector + i as u64;
            encrypt_sector(
                chunk,
                sector_num,
                &self.master_key,
                &self.secondary_key,
                self.algorithm,
            );
            self.sectors_encrypted.fetch_add(1, Ordering::Relaxed);
        }

        // Write to storage
        self.storage.write(file_offset, &encrypted)?;
        self.bytes_written
            .fetch_add(buf.len() as u64, Ordering::Relaxed);

        Ok(buf.len())
    }

    fn size(&self) -> u64 {
        self.data_size
    }

    fn sync(&mut self) -> Result<(), VaultError> {
        // In-memory storage doesn't need sync
        Ok(())
    }

    fn is_read_only(&self) -> bool {
        self.read_only
    }
}

/// Block device statistics.
#[derive(Debug, Clone, Copy)]
pub struct VaultBlockDeviceStats {
    /// Total bytes read.
    pub bytes_read: u64,
    /// Total bytes written.
    pub bytes_written: u64,
    /// Total sectors decrypted.
    pub sectors_decrypted: u64,
    /// Total sectors encrypted.
    pub sectors_encrypted: u64,
}

// ============================================================================
// Protected Block Device Wrapper
// ============================================================================

/// Block device wrapper that protects hidden volume area.
pub struct ProtectedVaultDevice {
    /// Inner device.
    inner: VaultBlockDevice,
    /// Hidden volume header (for calculating protected range).
    hidden_header: Option<VaultHeader>,
}

impl ProtectedVaultDevice {
    /// Create with hidden volume protection.
    pub fn new_with_protection(
        storage: VolumeStorage,
        outer_header: &VaultHeader,
        hidden_header: VaultHeader,
        algorithm: EncryptionAlgorithm,
    ) -> Self {
        let mut device = VaultBlockDevice::new(storage, outer_header, algorithm, false);

        // Set protected range based on hidden volume
        let protected_start = hidden_header.data_offset - outer_header.data_offset;
        let protected_end = protected_start + hidden_header.data_size;
        device.set_protected_range(protected_start, protected_end);

        Self {
            inner: device,
            hidden_header: Some(hidden_header),
        }
    }

    /// Create without protection.
    pub fn new_unprotected(
        storage: VolumeStorage,
        header: &VaultHeader,
        algorithm: EncryptionAlgorithm,
        read_only: bool,
    ) -> Self {
        Self {
            inner: VaultBlockDevice::new(storage, header, algorithm, read_only),
            hidden_header: None,
        }
    }

    /// Check if hidden volume protection is active.
    pub fn has_protection(&self) -> bool {
        self.hidden_header.is_some()
    }

    /// Get inner device reference.
    pub fn inner(&self) -> &VaultBlockDevice {
        &self.inner
    }

    /// Get mutable inner device reference.
    pub fn inner_mut(&mut self) -> &mut VaultBlockDevice {
        &mut self.inner
    }
}

impl VaultBlockDeviceTrait for ProtectedVaultDevice {
    fn read(&self, offset: u64, buf: &mut [u8]) -> Result<usize, VaultError> {
        self.inner.read(offset, buf)
    }

    fn write(&mut self, offset: u64, buf: &[u8]) -> Result<usize, VaultError> {
        self.inner.write(offset, buf)
    }

    fn size(&self) -> u64 {
        self.inner.size()
    }

    fn sync(&mut self) -> Result<(), VaultError> {
        self.inner.sync()
    }

    fn is_read_only(&self) -> bool {
        self.inner.is_read_only()
    }
}

// ============================================================================
// LCPFS BlockDevice Adapter
// ============================================================================

/// Adapter to use VaultBlockDevice with LCPFS.
/// This is a simple wrapper that delegates to VaultBlockDeviceTrait.
pub struct LcpfsVaultAdapter {
    /// Inner vault device.
    device: VaultBlockDevice,
}

impl LcpfsVaultAdapter {
    /// Create new adapter.
    pub fn new(device: VaultBlockDevice) -> Self {
        Self { device }
    }

    /// Get underlying device.
    pub fn into_inner(self) -> VaultBlockDevice {
        self.device
    }

    /// Read data at offset.
    pub fn read(&self, offset: u64, buf: &mut [u8]) -> Result<usize, VaultError> {
        VaultBlockDeviceTrait::read(&self.device, offset, buf)
    }

    /// Write data at offset.
    pub fn write(&mut self, offset: u64, buf: &[u8]) -> Result<usize, VaultError> {
        VaultBlockDeviceTrait::write(&mut self.device, offset, buf)
    }

    /// Get total size.
    pub fn size(&self) -> u64 {
        VaultBlockDeviceTrait::size(&self.device)
    }

    /// Get block size.
    pub fn block_size(&self) -> u32 {
        self.device.sector_size
    }

    /// Check if read-only.
    pub fn is_read_only(&self) -> bool {
        VaultBlockDeviceTrait::is_read_only(&self.device)
    }

    /// Get device path.
    pub fn device_path(&self) -> &str {
        self.device.storage.path()
    }
}

// ============================================================================
// Tests
// ============================================================================

#[cfg(test)]
mod tests {
    use super::*;
    use crate::vault::volume::create_volume;

    fn create_test_device() -> VaultBlockDevice {
        let options = VaultCreateOptions {
            size: 2 * 1024 * 1024,
            encryption: EncryptionAlgorithm::Aes256,
            hash: HashAlgorithm::Sha256,
            wipe_mode: WipeMode::Zero,
            ..Default::default()
        };

        let storage = create_volume("test_password", &options).unwrap();

        let mount_options = VaultMountOptions {
            hash_hint: Some(HashAlgorithm::Sha256),
            encryption_hint: Some(EncryptionAlgorithm::Aes256),
            ..Default::default()
        };

        let (header, enc) =
            crate::vault::volume::open_volume(&storage, "test_password", &mount_options).unwrap();

        VaultBlockDevice::new(storage, &header, enc, false)
    }

    #[test]
    fn test_read_write() {
        let mut device = create_test_device();

        // Write data
        let write_data = vec![0xABu8; 512];
        device.write(0, &write_data).unwrap();

        // Read it back
        let mut read_data = vec![0u8; 512];
        device.read(0, &mut read_data).unwrap();

        assert_eq!(write_data, read_data);
    }

    #[test]
    fn test_multi_sector_io() {
        let mut device = create_test_device();

        // Write multiple sectors
        let write_data: Vec<u8> = (0..2048).map(|i| (i % 256) as u8).collect();
        device.write(0, &write_data).unwrap();

        // Read it back
        let mut read_data = vec![0u8; 2048];
        device.read(0, &mut read_data).unwrap();

        assert_eq!(write_data, read_data);
    }

    #[test]
    fn test_statistics() {
        let mut device = create_test_device();

        let data = vec![0u8; 1024];
        device.write(0, &data).unwrap();

        let mut buf = vec![0u8; 1024];
        device.read(0, &mut buf).unwrap();

        let stats = device.stats();
        assert_eq!(stats.bytes_written, 1024);
        assert_eq!(stats.bytes_read, 1024);
        assert!(stats.sectors_encrypted > 0);
        assert!(stats.sectors_decrypted > 0);
    }

    #[test]
    fn test_protected_range() {
        let mut device = create_test_device();

        // Set protected range
        device.set_protected_range(1024, 2048);

        // Write before protected range should succeed
        let data = vec![0u8; 512];
        assert!(device.write(0, &data).is_ok());

        // Write in protected range should fail
        assert!(matches!(
            device.write(1024, &data),
            Err(VaultError::ProtectedAreaViolation)
        ));

        // Write overlapping protected range should fail
        assert!(matches!(
            device.write(768, &data),
            Err(VaultError::ProtectedAreaViolation)
        ));

        // Write after protected range should succeed
        assert!(device.write(2048, &data).is_ok());

        // Read from protected range should still work
        let mut buf = vec![0u8; 512];
        assert!(device.read(1024, &mut buf).is_ok());
    }

    #[test]
    fn test_read_only() {
        let options = VaultCreateOptions {
            size: 2 * 1024 * 1024,
            encryption: EncryptionAlgorithm::Aes256,
            hash: HashAlgorithm::Sha256,
            wipe_mode: WipeMode::Zero,
            ..Default::default()
        };

        let storage = create_volume("test_password", &options).unwrap();

        let mount_options = VaultMountOptions {
            hash_hint: Some(HashAlgorithm::Sha256),
            encryption_hint: Some(EncryptionAlgorithm::Aes256),
            ..Default::default()
        };

        let (header, enc) =
            crate::vault::volume::open_volume(&storage, "test_password", &mount_options).unwrap();

        // Create read-only device
        let mut device = VaultBlockDevice::new(storage, &header, enc, true);

        assert!(device.is_read_only());

        let data = vec![0u8; 512];
        assert!(device.write(0, &data).is_err());
    }

    #[test]
    fn test_close() {
        let mut device = create_test_device();

        assert!(device.is_open());
        device.close();
        assert!(!device.is_open());

        // Operations should fail after close
        let mut buf = vec![0u8; 512];
        assert!(matches!(
            device.read(0, &mut buf),
            Err(VaultError::NotMounted)
        ));
    }
}