`585cb7b`

Add Phase 2 crypto foundation: AES-256-GCM encryption, scrypt key derivation, hierarchical keys, secure memory, content addressing with Blake3/SHA-256

Authored by mfwolffe <wolffemf@dukes.jmu.edu> 8 months ago

SHA: 585cb7bd0208db3cd0f0f8aa07d7a42057bb1eaf
Parents: 4588949
Tree: fa6e0d5

8 changed files

Status	File	+	-
M	`Cargo.toml`	11	0
A	`src/crypto/content_addressing.rs`	489	0
A	`src/crypto/encryption.rs`	360	0
A	`src/crypto/key_derivation.rs`	457	0
A	`src/crypto/mod.rs`	213	0
A	`src/crypto/secure_memory.rs`	461	0
A	`src/lib.rs`	20	0
M	`src/main.rs`	7	2

Cargo.tomlmodified

  rand = "0.8"
  hex = "0.4"
 +# Phase 2: Advanced cryptography
 +ring = "0.17"              # AES-256-GCM, SHA-256, secure crypto primitives
 +scrypt = "0.11"            # Key derivation from passwords
 +zeroize = "1.7"            # Secure memory clearing
 +constant_time_eq = "0.3"   # Timing-safe comparisons
 +rand_core = "0.6"          # Cryptographic randomness
++
 +# TLS and networking security
 +rustls = "0.23"            # TLS 1.3 implementation
 +rustls-pemfile = "2.0"     # Certificate management
++
  # Protocol buffers
  prost = "0.13"
  prost-types = "0.13"

src/crypto/content_addressing.rsadded

 +//! Content addressing system for ZephyrFS
 +//!
 +//! Provides cryptographic content identifiers and verification using Blake3 and SHA-256.
 +//! Content IDs are used for integrity verification and deduplication.
++
 +use crate::crypto::{ContentHasher, VerificationHasher};
 +use blake3::Hasher as Blake3Hasher;
 +use serde::{Deserialize, Serialize};
 +use sha2::{Digest, Sha256};
 +use std::fmt;
++
 +/// Content identifier - cryptographic hash of data
 +#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
 +pub struct ContentId {
 +    /// Hash algorithm used
 +    pub algorithm: HashAlgorithm,
 +    /// Hash bytes
 +    pub hash: Vec<u8>,
 +}
++
 +/// Supported hash algorithms
 +#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
 +pub enum HashAlgorithm {
 +    Blake3,
 +    Sha256,
 +}
++
 +impl ContentId {
 +    /// Generate content ID from data
 +    pub fn generate(data: &[u8], hasher: &ContentHasher) -> Self {
 +        match hasher {
 +            ContentHasher::Blake3 => {
 +                let mut hasher = Blake3Hasher::new();
 +                hasher.update(data);
 +                let hash = hasher.finalize();
++
 +                Self {
 +                    algorithm: HashAlgorithm::Blake3,
 +                    hash: hash.as_bytes().to_vec(),
 +                }
 +            }
 +            ContentHasher::Sha256 => {
 +                let mut hasher = Sha256::new();
 +                hasher.update(data);
 +                let hash = hasher.finalize();
++
 +                Self {
 +                    algorithm: HashAlgorithm::Sha256,
 +                    hash: hash.to_vec(),
 +                }
 +            }
 +        }
 +    }
++
 +    /// Create from existing hash bytes and algorithm
 +    pub fn from_hash(algorithm: HashAlgorithm, hash: Vec<u8>) -> Self {
 +        Self { algorithm, hash }
 +    }
++
 +    /// Get hash bytes
 +    pub fn hash_bytes(&self) -> &[u8] {
 +        &self.hash
 +    }
++
 +    /// Get algorithm used
 +    pub fn algorithm(&self) -> &HashAlgorithm {
 +        &self.algorithm
 +    }
++
 +    /// Convert to hex string representation
 +    pub fn to_hex(&self) -> String {
 +        hex::encode(&self.hash)
 +    }
++
 +    /// Create from hex string
 +    pub fn from_hex(algorithm: HashAlgorithm, hex_str: &str) -> Result<Self, hex::FromHexError> {
 +        let hash = hex::decode(hex_str)?;
 +        Ok(Self { algorithm, hash })
 +    }
++
 +    /// Get expected hash length for algorithm
 +    pub fn expected_length(&self) -> usize {
 +        match self.algorithm {
 +            HashAlgorithm::Blake3 => 32,  // Blake3 output is 32 bytes
 +            HashAlgorithm::Sha256 => 32,  // SHA-256 output is 32 bytes
 +        }
 +    }
++
 +    /// Validate hash length matches algorithm
 +    pub fn is_valid(&self) -> bool {
 +        self.hash.len() == self.expected_length()
 +    }
++
 +    /// Create a multihash-style prefix for the content ID
 +    pub fn multihash_prefix(&self) -> Vec<u8> {
 +        let mut prefix = Vec::new();
++
 +        // Add algorithm identifier
 +        match self.algorithm {
 +            HashAlgorithm::Blake3 => {
 +                prefix.push(0x1e); // Blake3 multicodec
 +                prefix.push(32);   // Hash length
 +            }
 +            HashAlgorithm::Sha256 => {
 +                prefix.push(0x12); // SHA-256 multicodec
 +                prefix.push(32);   // Hash length
 +            }
 +        }
++
 +        prefix.extend_from_slice(&self.hash);
 +        prefix
 +    }
++
 +    /// Parse from multihash format
 +    pub fn from_multihash(data: &[u8]) -> Result<Self, String> {
 +        if data.len() < 2 {
 +            return Err("Multihash too short".to_string());
 +        }
++
 +        let algorithm = match data[0] {
 +            0x1e => HashAlgorithm::Blake3,
 +            0x12 => HashAlgorithm::Sha256,
 +            _ => return Err(format!("Unsupported hash algorithm: {}", data[0])),
 +        };
++
 +        let expected_len = data[1] as usize;
 +        if data.len() != expected_len + 2 {
 +            return Err(format!(
 +                "Invalid multihash length: expected {}, got {}",
 +                expected_len + 2,
 +                data.len()
 +            ));
 +        }
++
 +        let hash = data[2..].to_vec();
 +        let content_id = Self { algorithm, hash };
++
 +        if !content_id.is_valid() {
 +            return Err("Invalid hash length for algorithm".to_string());
 +        }
++
 +        Ok(content_id)
 +    }
 +}
++
 +impl fmt::Display for ContentId {
 +    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 +        write!(f, "{}:{}",
 +            match self.algorithm {
 +                HashAlgorithm::Blake3 => "blake3",
 +                HashAlgorithm::Sha256 => "sha256",
 +            },
 +            self.to_hex()
 +        )
 +    }
 +}
++
 +/// Content verification utilities
 +pub struct ContentVerifier;
++
 +impl ContentVerifier {
 +    /// Verify data matches expected content ID
 +    pub fn verify(data: &[u8], expected_id: &ContentId, hasher: &VerificationHasher) -> bool {
 +        let computed_id = match hasher {
 +            VerificationHasher::Blake3 => ContentId::generate(data, &ContentHasher::Blake3),
 +            VerificationHasher::Sha256 => ContentId::generate(data, &ContentHasher::Sha256),
 +        };
++
 +        // Must use same algorithm and hash must match
 +        computed_id.algorithm == expected_id.algorithm &&
 +        computed_id.hash == expected_id.hash
 +    }
++
 +    /// Verify data with multiple hash algorithms (for maximum security)
 +    pub fn verify_multi(data: &[u8], expected_ids: &[ContentId]) -> bool {
 +        for expected_id in expected_ids {
 +            let hasher = match expected_id.algorithm {
 +                HashAlgorithm::Blake3 => VerificationHasher::Blake3,
 +                HashAlgorithm::Sha256 => VerificationHasher::Sha256,
 +            };
++
 +            if !Self::verify(data, expected_id, &hasher) {
 +                return false;
 +            }
 +        }
 +        true
 +    }
++
 +    /// Compute multiple hashes for data (Blake3 + SHA-256 for maximum security)
 +    pub fn compute_multi_hash(data: &[u8]) -> Vec<ContentId> {
 +        vec![
 +            ContentId::generate(data, &ContentHasher::Blake3),
 +            ContentId::generate(data, &ContentHasher::Sha256),
 +        ]
 +    }
++
 +    /// Create integrity proof for data chunk
 +    pub fn create_integrity_proof(data: &[u8]) -> IntegrityProof {
 +        IntegrityProof {
 +            blake3_hash: ContentId::generate(data, &ContentHasher::Blake3),
 +            sha256_hash: ContentId::generate(data, &ContentHasher::Sha256),
 +            data_length: data.len() as u64,
 +        }
 +    }
++
 +    /// Verify data against integrity proof
 +    pub fn verify_integrity_proof(data: &[u8], proof: &IntegrityProof) -> bool {
 +        if data.len() as u64 != proof.data_length {
 +            return false;
 +        }
++
 +        let blake3_ok = Self::verify(data, &proof.blake3_hash, &VerificationHasher::Blake3);
 +        let sha256_ok = Self::verify(data, &proof.sha256_hash, &VerificationHasher::Sha256);
++
 +        blake3_ok && sha256_ok
 +    }
 +}
++
 +/// Integrity proof containing multiple hashes for maximum security
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct IntegrityProof {
 +    pub blake3_hash: ContentId,
 +    pub sha256_hash: ContentId,
 +    pub data_length: u64,
 +}
++
 +impl IntegrityProof {
 +    /// Get the primary content ID (Blake3 for performance)
 +    pub fn primary_id(&self) -> &ContentId {
 +        &self.blake3_hash
 +    }
++
 +    /// Get the secondary content ID (SHA-256 for compatibility)
 +    pub fn secondary_id(&self) -> &ContentId {
 +        &self.sha256_hash
 +    }
++
 +    /// Convert to multihash format (primary hash only)
 +    pub fn to_multihash(&self) -> Vec<u8> {
 +        self.blake3_hash.multihash_prefix()
 +    }
 +}
++
 +/// Content addressing utilities for file chunks
 +pub struct ChunkAddressing;
++
 +impl ChunkAddressing {
 +    /// Generate content ID for a file chunk with metadata
 +    pub fn chunk_id(chunk_data: &[u8], chunk_index: u64, file_id: &[u8]) -> ContentId {
 +        let mut hasher = Blake3Hasher::new();
++
 +        // Include chunk metadata in hash for uniqueness
 +        hasher.update(b"ZephyrFS-chunk-v1:");
 +        hasher.update(&chunk_index.to_be_bytes());
 +        hasher.update(b":");
 +        hasher.update(file_id);
 +        hasher.update(b":");
 +        hasher.update(chunk_data);
++
 +        let hash = hasher.finalize();
 +        ContentId {
 +            algorithm: HashAlgorithm::Blake3,
 +            hash: hash.as_bytes().to_vec(),
 +        }
 +    }
++
 +    /// Generate file-level content ID from chunk IDs
 +    pub fn file_id_from_chunks(chunk_ids: &[ContentId]) -> ContentId {
 +        let mut hasher = Blake3Hasher::new();
 +        hasher.update(b"ZephyrFS-file-v1:");
++
 +        for chunk_id in chunk_ids {
 +            hasher.update(&chunk_id.hash);
 +        }
++
 +        let hash = hasher.finalize();
 +        ContentId {
 +            algorithm: HashAlgorithm::Blake3,
 +            hash: hash.as_bytes().to_vec(),
 +        }
 +    }
++
 +    /// Create Merkle tree root from chunk hashes
 +    pub fn merkle_root(chunk_ids: &[ContentId]) -> ContentId {
 +        if chunk_ids.is_empty() {
 +            // Empty file hash
 +            return ContentId::generate(b"", &ContentHasher::Blake3);
 +        }
++
 +        if chunk_ids.len() == 1 {
 +            return chunk_ids[0].clone();
 +        }
++
 +        // Build Merkle tree bottom-up
 +        let mut level: Vec<ContentId> = chunk_ids.to_vec();
++
 +        while level.len() > 1 {
 +            let mut next_level = Vec::new();
++
 +            for pair in level.chunks(2) {
 +                let mut hasher = Blake3Hasher::new();
 +                hasher.update(b"ZephyrFS-merkle-v1:");
 +                hasher.update(&pair[0].hash);
++
 +                if pair.len() == 2 {
 +                    hasher.update(&pair[1].hash);
 +                } else {
 +                    // Odd number of nodes - hash with itself
 +                    hasher.update(&pair[0].hash);
 +                }
++
 +                let hash = hasher.finalize();
 +                next_level.push(ContentId {
 +                    algorithm: HashAlgorithm::Blake3,
 +                    hash: hash.as_bytes().to_vec(),
 +                });
 +            }
++
 +            level = next_level;
 +        }
++
 +        level.into_iter().next().unwrap()
 +    }
 +}
++
 +#[cfg(test)]
 +mod tests {
 +    use super::*;
++
 +    #[test]
 +    fn test_content_id_generation() {
 +        let data = b"Hello, ZephyrFS!";
++
 +        let blake3_id = ContentId::generate(data, &ContentHasher::Blake3);
 +        let sha256_id = ContentId::generate(data, &ContentHasher::Sha256);
++
 +        assert_eq!(blake3_id.algorithm, HashAlgorithm::Blake3);
 +        assert_eq!(sha256_id.algorithm, HashAlgorithm::Sha256);
 +        assert_eq!(blake3_id.hash.len(), 32);
 +        assert_eq!(sha256_id.hash.len(), 32);
 +        assert_ne!(blake3_id.hash, sha256_id.hash);
 +    }
++
 +    #[test]
 +    fn test_content_verification() {
 +        let data = b"Test data for verification";
 +        let content_id = ContentId::generate(data, &ContentHasher::Blake3);
++
 +        // Correct data should verify
 +        assert!(ContentVerifier::verify(data, &content_id, &VerificationHasher::Blake3));
++
 +        // Wrong data should not verify
 +        let wrong_data = b"Wrong data";
 +        assert!(!ContentVerifier::verify(wrong_data, &content_id, &VerificationHasher::Blake3));
 +    }
++
 +    #[test]
 +    fn test_content_id_hex_serialization() {
 +        let data = b"Serialization test";
 +        let original_id = ContentId::generate(data, &ContentHasher::Blake3);
++
 +        let hex_str = original_id.to_hex();
 +        let restored_id = ContentId::from_hex(HashAlgorithm::Blake3, &hex_str).unwrap();
++
 +        assert_eq!(original_id, restored_id);
 +    }
++
 +    #[test]
 +    fn test_multihash_format() {
 +        let data = b"Multihash test data";
 +        let content_id = ContentId::generate(data, &ContentHasher::Blake3);
++
 +        let multihash = content_id.multihash_prefix();
 +        let restored_id = ContentId::from_multihash(&multihash).unwrap();
++
 +        assert_eq!(content_id, restored_id);
++
 +        // Test SHA-256 as well
 +        let sha256_id = ContentId::generate(data, &ContentHasher::Sha256);
 +        let sha256_multihash = sha256_id.multihash_prefix();
 +        let restored_sha256 = ContentId::from_multihash(&sha256_multihash).unwrap();
++
 +        assert_eq!(sha256_id, restored_sha256);
 +    }
++
 +    #[test]
 +    fn test_integrity_proof() {
 +        let data = b"Integrity proof test data";
 +        let proof = ContentVerifier::create_integrity_proof(data);
++
 +        assert_eq!(proof.data_length, data.len() as u64);
 +        assert_eq!(proof.blake3_hash.algorithm, HashAlgorithm::Blake3);
 +        assert_eq!(proof.sha256_hash.algorithm, HashAlgorithm::Sha256);
++
 +        // Correct data should verify
 +        assert!(ContentVerifier::verify_integrity_proof(data, &proof));
++
 +        // Wrong data should not verify
 +        let wrong_data = b"Wrong data";
 +        assert!(!ContentVerifier::verify_integrity_proof(wrong_data, &proof));
 +    }
++
 +    #[test]
 +    fn test_chunk_addressing() {
 +        let chunk_data = b"Chunk data for addressing test";
 +        let file_id = b"test_file_12345";
++
 +        let chunk_id = ChunkAddressing::chunk_id(chunk_data, 0, file_id);
 +        assert_eq!(chunk_id.algorithm, HashAlgorithm::Blake3);
 +        assert_eq!(chunk_id.hash.len(), 32);
++
 +        // Different chunk index should produce different ID
 +        let chunk_id2 = ChunkAddressing::chunk_id(chunk_data, 1, file_id);
 +        assert_ne!(chunk_id, chunk_id2);
++
 +        // Different file ID should produce different ID
 +        let chunk_id3 = ChunkAddressing::chunk_id(chunk_data, 0, b"different_file");
 +        assert_ne!(chunk_id, chunk_id3);
 +    }
++
 +    #[test]
 +    fn test_file_id_from_chunks() {
 +        let chunk1 = ContentId::generate(b"chunk 1", &ContentHasher::Blake3);
 +        let chunk2 = ContentId::generate(b"chunk 2", &ContentHasher::Blake3);
 +        let chunk3 = ContentId::generate(b"chunk 3", &ContentHasher::Blake3);
++
 +        let file_id = ChunkAddressing::file_id_from_chunks(&[chunk1.clone(), chunk2.clone(), chunk3.clone()]);
 +        assert_eq!(file_id.algorithm, HashAlgorithm::Blake3);
++
 +        // Different order should produce different file ID
 +        let file_id2 = ChunkAddressing::file_id_from_chunks(&[chunk3, chunk1, chunk2]);
 +        assert_ne!(file_id, file_id2);
 +    }
++
 +    #[test]
 +    fn test_merkle_root() {
 +        let chunk1 = ContentId::generate(b"chunk 1", &ContentHasher::Blake3);
 +        let chunk2 = ContentId::generate(b"chunk 2", &ContentHasher::Blake3);
 +        let chunk3 = ContentId::generate(b"chunk 3", &ContentHasher::Blake3);
 +        let chunk4 = ContentId::generate(b"chunk 4", &ContentHasher::Blake3);
++
 +        // Single chunk
 +        let root1 = ChunkAddressing::merkle_root(&[chunk1.clone()]);
 +        assert_eq!(root1, chunk1);
++
 +        // Multiple chunks
 +        let root2 = ChunkAddressing::merkle_root(&[chunk1.clone(), chunk2.clone()]);
 +        let root4 = ChunkAddressing::merkle_root(&[chunk1, chunk2, chunk3, chunk4]);
++
 +        assert_ne!(root2, root4);
 +        assert_eq!(root2.algorithm, HashAlgorithm::Blake3);
 +        assert_eq!(root4.algorithm, HashAlgorithm::Blake3);
++
 +        // Empty chunks
 +        let empty_root = ChunkAddressing::merkle_root(&[]);
 +        assert_eq!(empty_root.algorithm, HashAlgorithm::Blake3);
 +    }
++
 +    #[test]
 +    fn test_content_id_display() {
 +        let content_id = ContentId::generate(b"display test", &ContentHasher::Blake3);
 +        let display_str = format!("{}", content_id);
++
 +        assert!(display_str.starts_with("blake3:"));
 +        assert_eq!(display_str.len(), 71); // "blake3:" (7) + hex hash (64)
++
 +        let sha256_id = ContentId::generate(b"display test", &ContentHasher::Sha256);
 +        let sha256_str = format!("{}", sha256_id);
++
 +        assert!(sha256_str.starts_with("sha256:"));
 +        assert_eq!(sha256_str.len(), 71); // "sha256:" (7) + hex hash (64)
 +    }
++
 +    #[test]
 +    fn test_multi_hash_verification() {
 +        let data = b"Multi hash verification test";
 +        let blake3_id = ContentId::generate(data, &ContentHasher::Blake3);
 +        let sha256_id = ContentId::generate(data, &ContentHasher::Sha256);
++
 +        let ids = vec![blake3_id, sha256_id];
++
 +        // Correct data should verify against all hashes
 +        assert!(ContentVerifier::verify_multi(data, &ids));
++
 +        // Wrong data should fail verification
 +        let wrong_data = b"Wrong data";
 +        assert!(!ContentVerifier::verify_multi(wrong_data, &ids));
 +    }
 +}

src/crypto/encryption.rsadded

 +//! AES-256-GCM encryption implementation for ZephyrFS
 +//!
 +//! Provides segment-level encryption using AES-256 in GCM mode for authenticated encryption.
 +//! Each file segment is encrypted with its own derived key for maximum security isolation.
++
 +use crate::crypto::{AesParams, KeyHierarchy, SecureBytes};
 +use anyhow::{Context, Result};
 +use ring::aead::{Aad, BoundKey, Nonce, NonceSequence, OpeningKey, SealingKey, UnboundKey, AES_256_GCM};
 +use ring::error::Unspecified;
 +use ring::rand::{SecureRandom, SystemRandom};
 +use serde::{Deserialize, Serialize};
 +use zeroize::{Zeroize, ZeroizeOnDrop};
++
 +/// Default segment size for file encryption (1MB)
 +pub const DEFAULT_SEGMENT_SIZE: usize = 1024 * 1024; // 1MB
++
 +/// Encrypted data container with all necessary metadata for decryption
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct EncryptedData {
 +    /// Segment index in the original file
 +    pub segment_index: u64,
 +    /// Encrypted data payload
 +    pub ciphertext: Vec<u8>,
 +    /// Nonce used for this encryption
 +    pub nonce: [u8; 12],
 +    /// Additional authenticated data (AAD) - segment metadata
 +    pub aad: Vec<u8>,
 +    /// Key derivation path for this segment
 +    pub key_path: Vec<u32>,
 +}
++
 +/// File-level encryption operations
 +pub struct FileEncryption {
 +    params: AesParams,
 +    segment_size: usize,
 +    rng: SystemRandom,
 +}
++
 +impl FileEncryption {
 +    pub fn new(params: &AesParams) -> Self {
 +        Self {
 +            params: params.clone(),
 +            segment_size: DEFAULT_SEGMENT_SIZE,
 +            rng: SystemRandom::new(),
 +        }
 +    }
++
 +    pub fn with_segment_size(params: &AesParams, segment_size: usize) -> Self {
 +        Self {
 +            params: params.clone(),
 +            segment_size,
 +            rng: SystemRandom::new(),
 +        }
 +    }
++
 +    /// Encrypt file data into multiple encrypted segments
 +    pub fn encrypt_to_segments(
 +        &self,
 +        file_data: &[u8],
 +        key_hierarchy: &KeyHierarchy,
 +    ) -> Result<Vec<EncryptedData>> {
 +        let mut encrypted_segments = Vec::new();
 +        let total_segments = (file_data.len() + self.segment_size - 1) / self.segment_size;
++
 +        for (segment_index, chunk) in file_data.chunks(self.segment_size).enumerate() {
 +            let segment_encryption = SegmentEncryption::new(&self.params, &self.rng);
 +            let key_path = vec![segment_index as u32]; // Simple path for now
++
 +            let encrypted_data = segment_encryption.encrypt_segment(
 +                chunk,
 +                segment_index as u64,
 +                key_hierarchy,
 +                &key_path,
 +            )?;
++
 +            encrypted_segments.push(encrypted_data);
 +        }
++
 +        Ok(encrypted_segments)
 +    }
++
 +    /// Decrypt segments back to original file data
 +    pub fn decrypt_from_segments(
 +        &self,
 +        encrypted_segments: &[EncryptedData],
 +        key_hierarchy: &KeyHierarchy,
 +    ) -> Result<Vec<u8>> {
 +        // Sort segments by index to ensure correct order
 +        let mut sorted_segments = encrypted_segments.to_vec();
 +        sorted_segments.sort_by_key(|s| s.segment_index);
++
 +        let mut decrypted_data = Vec::new();
++
 +        for encrypted_segment in sorted_segments {
 +            let segment_encryption = SegmentEncryption::new(&self.params, &self.rng);
 +            let decrypted_chunk = segment_encryption.decrypt_segment(
 +                &encrypted_segment,
 +                key_hierarchy,
 +            )?;
++
 +            decrypted_data.extend_from_slice(&decrypted_chunk);
 +        }
++
 +        Ok(decrypted_data)
 +    }
 +}
++
 +/// Segment-level encryption operations
 +pub struct SegmentEncryption {
 +    params: AesParams,
 +    rng: SystemRandom,
 +}
++
 +impl SegmentEncryption {
 +    pub fn new(params: &AesParams, rng: &SystemRandom) -> Self {
 +        Self {
 +            params: params.clone(),
 +            rng: SystemRandom::new(), // Create new instance for thread safety
 +        }
 +    }
++
 +    /// Encrypt a single file segment
 +    pub fn encrypt_segment(
 +        &self,
 +        segment_data: &[u8],
 +        segment_index: u64,
 +        key_hierarchy: &KeyHierarchy,
 +        key_path: &[u32],
 +    ) -> Result<EncryptedData> {
 +        // Derive segment-specific key
 +        let segment_key = key_hierarchy.derive_segment_key(key_path)
 +            .context("Failed to derive segment key")?;
++
 +        // Generate random nonce
 +        let mut nonce_bytes = [0u8; 12];
 +        self.rng.fill(&mut nonce_bytes)
 +            .map_err(|_| anyhow::anyhow!("Failed to generate random nonce"))?;
++
 +        let nonce = Nonce::assume_unique_for_key(nonce_bytes);
++
 +        // Prepare AAD (Additional Authenticated Data) with segment metadata
 +        let aad_data = self.prepare_aad(segment_index, key_path)?;
 +        let aad = Aad::from(&aad_data);
++
 +        // Create sealing key
 +        let unbound_key = UnboundKey::new(&AES_256_GCM, segment_key.as_bytes())
 +            .map_err(|_| anyhow::anyhow!("Failed to create encryption key"))?;
++
 +        let mut sealing_key = SealingKey::new(unbound_key, NonceCounter::new());
++
 +        // Encrypt the data
 +        let mut ciphertext = segment_data.to_vec();
 +        sealing_key.seal_in_place_append_tag(aad, &mut ciphertext)
 +            .map_err(|_| anyhow::anyhow!("Failed to encrypt segment"))?;
++
 +        Ok(EncryptedData {
 +            segment_index,
 +            ciphertext,
 +            nonce: nonce_bytes,
 +            aad: aad_data,
 +            key_path: key_path.to_vec(),
 +        })
 +    }
++
 +    /// Decrypt a single encrypted segment
 +    pub fn decrypt_segment(
 +        &self,
 +        encrypted_data: &EncryptedData,
 +        key_hierarchy: &KeyHierarchy,
 +    ) -> Result<Vec<u8>> {
 +        // Derive the same segment key used for encryption
 +        let segment_key = key_hierarchy.derive_segment_key(&encrypted_data.key_path)
 +            .context("Failed to derive segment key for decryption")?;
++
 +        // Recreate nonce
 +        let nonce = Nonce::assume_unique_for_key(encrypted_data.nonce);
 +        let aad = Aad::from(&encrypted_data.aad);
++
 +        // Create opening key
 +        let unbound_key = UnboundKey::new(&AES_256_GCM, segment_key.as_bytes())
 +            .map_err(|_| anyhow::anyhow!("Failed to create decryption key"))?;
++
 +        let mut opening_key = OpeningKey::new(unbound_key, NonceCounter::new());
++
 +        // Decrypt the data
 +        let mut ciphertext = encrypted_data.ciphertext.clone();
 +        let plaintext = opening_key.open_in_place(aad, &mut ciphertext)
 +            .map_err(|_| anyhow::anyhow!("Failed to decrypt segment - authentication failed"))?;
++
 +        Ok(plaintext.to_vec())
 +    }
++
 +    /// Prepare Additional Authenticated Data (AAD) for GCM
 +    fn prepare_aad(&self, segment_index: u64, key_path: &[u32]) -> Result<Vec<u8>> {
 +        let mut aad = Vec::new();
++
 +        // Add segment index to AAD
 +        aad.extend_from_slice(&segment_index.to_le_bytes());
++
 +        // Add key path to AAD for additional security
 +        for path_element in key_path {
 +            aad.extend_from_slice(&path_element.to_le_bytes());
 +        }
++
 +        // Add version identifier for future compatibility
 +        aad.extend_from_slice(b"ZephyrFS-v1");
++
 +        Ok(aad)
 +    }
 +}
++
 +/// Nonce counter for GCM operations - ensures nonces are never reused
 +#[derive(ZeroizeOnDrop)]
 +struct NonceCounter {
 +    counter: u64,
 +}
++
 +impl NonceCounter {
 +    fn new() -> Self {
 +        Self { counter: 0 }
 +    }
 +}
++
 +impl NonceSequence for NonceCounter {
 +    fn advance(&mut self) -> Result<Nonce, Unspecified> {
 +        self.counter += 1;
++
 +        if self.counter == u64::MAX {
 +            return Err(Unspecified);
 +        }
++
 +        let mut nonce_bytes = [0u8; 12];
 +        nonce_bytes[4..].copy_from_slice(&self.counter.to_be_bytes());
++
 +        Ok(Nonce::assume_unique_for_key(nonce_bytes))
 +    }
 +}
++
 +impl Zeroize for NonceCounter {
 +    fn zeroize(&mut self) {
 +        self.counter = 0;
 +    }
 +}
++
 +#[cfg(test)]
 +mod tests {
 +    use super::*;
 +    use crate::crypto::key_derivation::{KeyDerivation, DerivedKey};
 +    use crate::crypto::CryptoParams;
++
 +    fn create_test_hierarchy() -> Result<KeyHierarchy> {
 +        let params = CryptoParams::default();
 +        let key_derivation = KeyDerivation::new(&params.scrypt_params);
 +        let derived_key = key_derivation.derive_from_password("test_password_123")?;
 +        KeyHierarchy::new(derived_key)
 +    }
++
 +    #[test]
 +    fn test_segment_encryption_roundtrip() -> Result<()> {
 +        let params = CryptoParams::default().aes_params;
 +        let hierarchy = create_test_hierarchy()?;
 +        let rng = SystemRandom::new();
++
 +        let segment_encryption = SegmentEncryption::new(&params, &rng);
 +        let test_data = b"Hello, ZephyrFS! This is test segment data for encryption.";
 +        let key_path = vec![42];
++
 +        // Encrypt
 +        let encrypted = segment_encryption.encrypt_segment(
 +            test_data,
 +            1,
 +            &hierarchy,
 +            &key_path,
 +        )?;
++
 +        // Decrypt
 +        let decrypted = segment_encryption.decrypt_segment(&encrypted, &hierarchy)?;
++
 +        assert_eq!(test_data, decrypted.as_slice());
 +        assert_eq!(encrypted.segment_index, 1);
 +        assert_eq!(encrypted.key_path, vec![42]);
++
 +        Ok(())
 +    }
++
 +    #[test]
 +    fn test_file_encryption_multiple_segments() -> Result<()> {
 +        let params = CryptoParams::default().aes_params;
 +        let hierarchy = create_test_hierarchy()?;
++
 +        let file_encryption = FileEncryption::with_segment_size(&params, 100); // Small segments for testing
 +        let test_data = b"This is a longer test file that should be split into multiple segments for encryption testing. Each segment will be encrypted independently with its own derived key.";
++
 +        // Encrypt file
 +        let encrypted_segments = file_encryption.encrypt_to_segments(test_data, &hierarchy)?;
++
 +        // Should have multiple segments
 +        assert!(encrypted_segments.len() > 1);
++
 +        // Decrypt file
 +        let decrypted_data = file_encryption.decrypt_from_segments(&encrypted_segments, &hierarchy)?;
++
 +        assert_eq!(test_data, decrypted_data.as_slice());
++
 +        Ok(())
 +    }
++
 +    #[test]
 +    fn test_encryption_authentication_failure() -> Result<()> {
 +        let params = CryptoParams::default().aes_params;
 +        let hierarchy = create_test_hierarchy()?;
 +        let rng = SystemRandom::new();
++
 +        let segment_encryption = SegmentEncryption::new(&params, &rng);
 +        let test_data = b"Test data for authentication failure";
 +        let key_path = vec![1];
++
 +        // Encrypt
 +        let mut encrypted = segment_encryption.encrypt_segment(
 +            test_data,
 +            0,
 +            &hierarchy,
 +            &key_path,
 +        )?;
++
 +        // Tamper with ciphertext
 +        encrypted.ciphertext[0] ^= 1;
++
 +        // Decrypt should fail due to authentication failure
 +        let result = segment_encryption.decrypt_segment(&encrypted, &hierarchy);
 +        assert!(result.is_err());
++
 +        Ok(())
 +    }
++
 +    #[test]
 +    fn test_different_segments_different_keys() -> Result<()> {
 +        let params = CryptoParams::default().aes_params;
 +        let hierarchy = create_test_hierarchy()?;
 +        let rng = SystemRandom::new();
++
 +        let segment_encryption = SegmentEncryption::new(&params, &rng);
 +        let test_data = b"Same data, different keys";
++
 +        // Encrypt with different key paths
 +        let encrypted1 = segment_encryption.encrypt_segment(
 +            test_data, 0, &hierarchy, &[1]
 +        )?;
++
 +        let encrypted2 = segment_encryption.encrypt_segment(
 +            test_data, 0, &hierarchy, &[2]
 +        )?;
++
 +        // Ciphertexts should be different even with same plaintext
 +        assert_ne!(encrypted1.ciphertext, encrypted2.ciphertext);
 +        assert_ne!(encrypted1.key_path, encrypted2.key_path);
++
 +        Ok(())
 +    }
 +}

src/crypto/key_derivation.rsadded

 +//! Key derivation system for ZephyrFS
 +//!
 +//! Implements hierarchical deterministic key derivation following Tahoe-LAFS security model.
 +//! Uses scrypt for password-based key derivation and HKDF for key hierarchy expansion.
++
 +use crate::crypto::{ScryptParams, SecureBytes};
 +use anyhow::{Context, Result};
 +use ring::hkdf::{Salt, Prk, HKDF_SHA256};
 +use ring::rand::{SecureRandom, SystemRandom};
 +use scrypt::{scrypt, Params};
 +use zeroize::{Zeroize, ZeroizeOnDrop};
 +use std::collections::HashMap;
++
 +/// Master key derived from user password using scrypt
 +#[derive(ZeroizeOnDrop)]
 +pub struct DerivedKey {
 +    /// Master key material (32 bytes)
 +    master_key: SecureBytes,
 +    /// Salt used for derivation (32 bytes)
 +    salt: [u8; 32],
 +    /// Verification hash for password checking (32 bytes)
 +    verification_hash: [u8; 32],
 +}
++
 +impl DerivedKey {
 +    /// Create DerivedKey from raw bytes (64 bytes total)
 +    pub fn from_bytes(bytes: SecureBytes) -> Result<Self> {
 +        if bytes.len() != 64 {
 +            anyhow::bail!("DerivedKey requires exactly 64 bytes (32 master + 32 salt, verification derived)");
 +        }
++
 +        let mut master_key = SecureBytes::new(32);
 +        let mut salt = [0u8; 32];
++
 +        master_key.copy_from_slice(&bytes[0..32]);
 +        salt.copy_from_slice(&bytes[32..64]);
++
 +        // Derive verification hash using HKDF from master key and salt
 +        let salt_obj = Salt::new(HKDF_SHA256, &salt);
 +        let prk = salt_obj.extract(master_key.as_bytes());
 +        let mut verification_hash = [0u8; 32];
 +        prk.expand(&[b"ZephyrFS-verification-hash-v1"], HKDF_SHA256)
 +            .map_err(|_| anyhow::anyhow!("HKDF expansion failed"))?
 +            .fill(&mut verification_hash)
 +            .map_err(|_| anyhow::anyhow!("HKDF fill failed"))?;
++
 +        Ok(Self {
 +            master_key,
 +            salt,
 +            verification_hash,
 +        })
 +    }
++
 +    /// Export key material as bytes (for secure storage/transmission)
 +    pub fn to_bytes(&self) -> SecureBytes {
 +        let mut bytes = SecureBytes::new(64);
 +        bytes[0..32].copy_from_slice(self.master_key.as_bytes());
 +        bytes[32..64].copy_from_slice(&self.salt);
 +        // Note: verification_hash is derived, not stored
 +        bytes
 +    }
++
 +    /// Get master key bytes for HKDF
 +    pub fn master_key(&self) -> &SecureBytes {
 +        &self.master_key
 +    }
++
 +    /// Get salt used for derivation
 +    pub fn salt(&self) -> &[u8; 32] {
 +        &self.salt
 +    }
++
 +    /// Verify password against stored verification hash
 +    pub fn verify_password(&self, password: &str, params: &ScryptParams) -> Result<bool> {
 +        let mut derived = vec![0u8; params.output_len];
 +        let scrypt_params = Params::new(
 +            params.log_n,
 +            params.r,
 +            params.p,
 +            params.output_len
 +        ).context("Invalid scrypt parameters")?;
++
 +        scrypt(password.as_bytes(), &self.salt, &scrypt_params, &mut derived)
 +            .context("Scrypt key derivation failed")?;
++
 +        // Extract master key from derived output
 +        let derived_master_key = &derived[0..32];
++
 +        // Derive verification hash using HKDF (same as during creation)
 +        let salt_obj = Salt::new(HKDF_SHA256, &self.salt);
 +        let prk = salt_obj.extract(derived_master_key);
 +        let mut computed_verification = [0u8; 32];
 +        prk.expand(&[b"ZephyrFS-verification-hash-v1"], HKDF_SHA256)
 +            .map_err(|_| anyhow::anyhow!("HKDF expansion failed"))?
 +            .fill(&mut computed_verification)
 +            .map_err(|_| anyhow::anyhow!("HKDF fill failed"))?;
++
 +        // Check verification hash matches
 +        let verification_ok = constant_time_eq::constant_time_eq(
 +            &computed_verification,
 +            &self.verification_hash
 +        );
++
 +        // Clear derived key material
 +        derived.zeroize();
 +        computed_verification.zeroize();
++
 +        Ok(verification_ok)
 +    }
 +}
++
 +/// Password-based key derivation using scrypt
 +pub struct KeyDerivation {
 +    params: ScryptParams,
 +    rng: SystemRandom,
 +}
++
 +impl KeyDerivation {
 +    pub fn new(params: &ScryptParams) -> Self {
 +        Self {
 +            params: params.clone(),
 +            rng: SystemRandom::new(),
 +        }
 +    }
++
 +    /// Derive key from password with random salt
 +    pub fn derive_from_password(&self, password: &str) -> Result<DerivedKey> {
 +        // Generate random salt
 +        let mut salt = [0u8; 32];
 +        self.rng.fill(&mut salt)
 +            .map_err(|_| anyhow::anyhow!("Failed to generate random salt"))?;
++
 +        self.derive_from_password_with_salt(password, &salt)
 +    }
++
 +    /// Derive key from password with specific salt (for key recovery)
 +    pub fn derive_from_password_with_salt(&self, password: &str, salt: &[u8; 32]) -> Result<DerivedKey> {
 +        let scrypt_params = Params::new(
 +            self.params.log_n,
 +            self.params.r,
 +            self.params.p,
 +            self.params.output_len
 +        ).context("Invalid scrypt parameters")?;
++
 +        let mut derived = vec![0u8; self.params.output_len];
 +        scrypt(password.as_bytes(), salt, &scrypt_params, &mut derived)
 +            .context("Scrypt key derivation failed")?;
++
 +        // Split derived output: 32 bytes master key (64 bytes total now)
 +        let mut master_key = SecureBytes::new(32);
 +        master_key.copy_from_slice(&derived[0..32]);
++
 +        // Derive verification hash using HKDF from master key and salt
 +        let salt_obj = Salt::new(HKDF_SHA256, salt);
 +        let prk = salt_obj.extract(master_key.as_bytes());
 +        let mut verification_hash = [0u8; 32];
 +        prk.expand(&[b"ZephyrFS-verification-hash-v1"], HKDF_SHA256)
 +            .map_err(|_| anyhow::anyhow!("HKDF expansion failed"))?
 +            .fill(&mut verification_hash)
 +            .map_err(|_| anyhow::anyhow!("HKDF fill failed"))?;
++
 +        // Clear the derived buffer
 +        derived.zeroize();
++
 +        Ok(DerivedKey {
 +            master_key,
 +            salt: *salt,
 +            verification_hash,
 +        })
 +    }
 +}
++
 +/// Hierarchical key system for deriving segment-specific keys
 +pub struct KeyHierarchy {
 +    master_prk: Prk,
 +    key_cache: HashMap<Vec<u32>, SecureBytes>,
 +}
++
 +impl KeyHierarchy {
 +    /// Create new key hierarchy from derived master key
 +    pub fn new(derived_key: DerivedKey) -> Result<Self> {
 +        // Use HKDF to create pseudorandom key from master key
 +        let salt = Salt::new(HKDF_SHA256, &derived_key.salt);
 +        let prk = salt.extract(derived_key.master_key.as_bytes());
++
 +        Ok(Self {
 +            master_prk: prk,
 +            key_cache: HashMap::new(),
 +        })
 +    }
++
 +    /// Derive segment-specific encryption key
 +    pub fn derive_segment_key(&self, key_path: &[u32]) -> Result<SecureBytes> {
 +        // Check cache first
 +        if let Some(cached_key) = self.key_cache.get(key_path) {
 +            return Ok(cached_key.clone());
 +        }
++
 +        // Create info string from key path
 +        let mut info = Vec::new();
 +        info.extend_from_slice(b"ZephyrFS-segment-key-v1:");
 +        for &path_element in key_path {
 +            info.extend_from_slice(&path_element.to_be_bytes());
 +        }
++
 +        // Derive key using HKDF-Expand
 +        let mut segment_key = SecureBytes::new(32); // AES-256 key size
 +        self.master_prk.expand(&[&info], ring::hkdf::HKDF_SHA256)
 +            .map_err(|_| anyhow::anyhow!("HKDF expansion failed"))?
 +            .fill(segment_key.as_mut())?;
++
 +        Ok(segment_key)
 +    }
++
 +    /// Derive file-level key (for file metadata encryption)
 +    pub fn derive_file_key(&self, file_id: &[u8]) -> Result<SecureBytes> {
 +        let mut info = Vec::new();
 +        info.extend_from_slice(b"ZephyrFS-file-key-v1:");
 +        info.extend_from_slice(file_id);
++
 +        let mut file_key = SecureBytes::new(32);
 +        self.master_prk.expand(&[&info], ring::hkdf::HKDF_SHA256)
 +            .map_err(|_| anyhow::anyhow!("HKDF expansion failed"))?
 +            .fill(file_key.as_mut())?;
++
 +        Ok(file_key)
 +    }
++
 +    /// Derive capability key for zero-knowledge proofs
 +    pub fn derive_capability_key(&self, capability_id: &[u8]) -> Result<SecureBytes> {
 +        let mut info = Vec::new();
 +        info.extend_from_slice(b"ZephyrFS-capability-key-v1:");
 +        info.extend_from_slice(capability_id);
++
 +        let mut capability_key = SecureBytes::new(32);
 +        self.master_prk.expand(&[&info], ring::hkdf::HKDF_SHA256)
 +            .map_err(|_| anyhow::anyhow!("HKDF expansion failed"))?
 +            .fill(capability_key.as_mut())?;
++
 +        Ok(capability_key)
 +    }
++
 +    /// Get public capability for sharing (non-sensitive key material)
 +    pub fn get_public_capability(&self) -> Result<Vec<u8>> {
 +        // Derive a public capability that can be shared without compromising security
 +        let mut info = Vec::new();
 +        info.extend_from_slice(b"ZephyrFS-public-capability-v1");
++
 +        let mut public_cap = vec![0u8; 32];
 +        self.master_prk.expand(&[&info], ring::hkdf::HKDF_SHA256)
 +            .map_err(|_| anyhow::anyhow!("HKDF expansion failed"))?
 +            .fill(&mut public_cap)?;
++
 +        Ok(public_cap)
 +    }
++
 +    /// Clear key cache (for security)
 +    pub fn clear_cache(&mut self) {
 +        for (_, mut key) in self.key_cache.drain() {
 +            key.zeroize();
 +        }
 +    }
 +}
++
 +impl Drop for KeyHierarchy {
 +    fn drop(&mut self) {
 +        self.clear_cache();
 +    }
 +}
++
 +impl Zeroize for KeyHierarchy {
 +    fn zeroize(&mut self) {
 +        self.clear_cache();
 +        // Note: Cannot zeroize master_prk as it's not under our control
 +    }
 +}
++
 +#[cfg(test)]
 +mod tests {
 +    use super::*;
++
 +    #[test]
 +    fn test_scrypt_params_validation() -> Result<()> {
 +        // Test different scrypt parameters to find valid range
 +        println!("Testing various scrypt parameters...");
++
 +        // Test with lower log_n
 +        let result15 = scrypt::Params::new(15, 8, 1, 96);
 +        println!("Scrypt params (15, 8, 1, 96) result: {:?}", result15);
++
 +        let result16 = scrypt::Params::new(16, 8, 1, 96);
 +        println!("Scrypt params (16, 8, 1, 96) result: {:?}", result16);
++
 +        let result17 = scrypt::Params::new(17, 8, 1, 96);
 +        println!("Scrypt params (17, 8, 1, 96) result: {:?}", result17);
++
 +        // Test with smaller output length
 +        let result17_32 = scrypt::Params::new(17, 8, 1, 32);
 +        println!("Scrypt params (17, 8, 1, 32) result: {:?}", result17_32);
++
 +        let result17_64 = scrypt::Params::new(17, 8, 1, 64);
 +        println!("Scrypt params (17, 8, 1, 64) result: {:?}", result17_64);
++
 +        // 64-byte versions should work, 96-byte should not
 +        assert!(result17_32.is_ok(), "17,8,1,32 should be valid");
 +        assert!(result17_64.is_ok(), "17,8,1,64 should be valid");
 +        assert!(!result17.is_ok(), "17,8,1,96 should be invalid");
 +        Ok(())
 +    }
++
 +    #[test]
 +    fn test_key_derivation_from_password() -> Result<()> {
 +        let params = ScryptParams {
 +            log_n: 15,  // Lower for testing (faster)
 +            r: 8,
 +            p: 1,
 +            output_len: 64,
 +        };
++
 +        let key_derivation = KeyDerivation::new(&params);
 +        let derived_key = key_derivation.derive_from_password("test_password_123")?;
++
 +        assert_eq!(derived_key.master_key.len(), 32);
 +        assert_eq!(derived_key.salt.len(), 32);
 +        assert_eq!(derived_key.verification_hash.len(), 32);
++
 +        Ok(())
 +    }
++
 +    #[test]
 +    fn test_password_verification() -> Result<()> {
 +        let params = ScryptParams {
 +            log_n: 15,
 +            r: 8,
 +            p: 1,
 +            output_len: 64,
 +        };
++
 +        let key_derivation = KeyDerivation::new(&params);
 +        let derived_key = key_derivation.derive_from_password("correct_password")?;
++
 +        // Correct password should verify
 +        assert!(derived_key.verify_password("correct_password", &params)?);
++
 +        // Wrong password should not verify
 +        assert!(!derived_key.verify_password("wrong_password", &params)?);
++
 +        Ok(())
 +    }
++
 +    #[test]
 +    fn test_key_hierarchy_segment_keys() -> Result<()> {
 +        let params = ScryptParams {
 +            log_n: 15,
 +            r: 8,
 +            p: 1,
 +            output_len: 96,
 +        };
++
 +        let key_derivation = KeyDerivation::new(&params);
 +        let derived_key = key_derivation.derive_from_password("test_password")?;
 +        let hierarchy = KeyHierarchy::new(derived_key)?;
++
 +        // Derive keys for different segments
 +        let key1 = hierarchy.derive_segment_key(&[0])?;
 +        let key2 = hierarchy.derive_segment_key(&[1])?;
 +        let key3 = hierarchy.derive_segment_key(&[0, 1])?;
++
 +        // Keys should be different
 +        assert_ne!(key1.as_bytes(), key2.as_bytes());
 +        assert_ne!(key1.as_bytes(), key3.as_bytes());
 +        assert_ne!(key2.as_bytes(), key3.as_bytes());
++
 +        // Same path should produce same key
 +        let key1_again = hierarchy.derive_segment_key(&[0])?;
 +        assert_eq!(key1.as_bytes(), key1_again.as_bytes());
++
 +        Ok(())
 +    }
++
 +    #[test]
 +    fn test_derived_key_serialization() -> Result<()> {
 +        let params = ScryptParams {
 +            log_n: 15,
 +            r: 8,
 +            p: 1,
 +            output_len: 96,
 +        };
++
 +        let key_derivation = KeyDerivation::new(&params);
 +        let original_key = key_derivation.derive_from_password("serialization_test")?;
++
 +        // Serialize and deserialize
 +        let serialized = original_key.to_bytes();
 +        let restored_key = DerivedKey::from_bytes(serialized)?;
++
 +        // Should be able to verify with restored key
 +        assert!(restored_key.verify_password("serialization_test", &params)?);
 +        assert!(!restored_key.verify_password("wrong_password", &params)?);
++
 +        Ok(())
 +    }
++
 +    #[test]
 +    fn test_deterministic_key_derivation() -> Result<()> {
 +        let params = ScryptParams {
 +            log_n: 15,
 +            r: 8,
 +            p: 1,
 +            output_len: 96,
 +        };
++
 +        let key_derivation = KeyDerivation::new(&params);
 +        let password = "deterministic_test";
 +        let salt = [42u8; 32]; // Fixed salt
++
 +        // Derive key twice with same password and salt
 +        let key1 = key_derivation.derive_from_password_with_salt(password, &salt)?;
 +        let key2 = key_derivation.derive_from_password_with_salt(password, &salt)?;
++
 +        // Should produce identical keys
 +        assert_eq!(key1.master_key.as_bytes(), key2.master_key.as_bytes());
 +        assert_eq!(key1.salt, key2.salt);
 +        assert_eq!(key1.verification_hash, key2.verification_hash);
++
 +        Ok(())
 +    }
++
 +    #[test]
 +    fn test_capability_derivation() -> Result<()> {
 +        let params = ScryptParams {
 +            log_n: 15,
 +            r: 8,
 +            p: 1,
 +            output_len: 96,
 +        };
++
 +        let key_derivation = KeyDerivation::new(&params);
 +        let derived_key = key_derivation.derive_from_password("capability_test")?;
 +        let hierarchy = KeyHierarchy::new(derived_key)?;
++
 +        let file_key = hierarchy.derive_file_key(b"test_file_id")?;
 +        let cap_key = hierarchy.derive_capability_key(b"test_capability_id")?;
 +        let public_cap = hierarchy.get_public_capability()?;
++
 +        // All should be different
 +        assert_ne!(file_key.as_bytes(), cap_key.as_bytes());
 +        assert_ne!(file_key.as_bytes(), &public_cap);
 +        assert_ne!(cap_key.as_bytes(), &public_cap);
++
 +        // Should be deterministic
 +        let file_key2 = hierarchy.derive_file_key(b"test_file_id")?;
 +        assert_eq!(file_key.as_bytes(), file_key2.as_bytes());
++
 +        Ok(())
 +    }
 +}

src/crypto/mod.rsadded

 +//! # ZephyrFS Cryptography Module
 +//!
 +//! Provides zero-knowledge client-side encryption for ZephyrFS distributed storage.
 +//! Implements Tahoe-LAFS inspired capability-based security with mandatory encryption.
 +//!
 +//! ## Architecture
 +//! - AES-256-GCM encryption for file segments
 +//! - Scrypt key derivation from user passwords
 +//! - Hierarchical deterministic keys for per-segment encryption
 +//! - Secure memory handling with automatic cleanup
 +//! - Content addressing with cryptographic verification
++
 +pub mod encryption;
 +pub mod key_derivation;
 +pub mod secure_memory;
 +pub mod content_addressing;
++
 +pub use encryption::{FileEncryption, SegmentEncryption, EncryptedData};
 +pub use key_derivation::{KeyDerivation, DerivedKey, KeyHierarchy};
 +pub use secure_memory::{SecureBytes, SecureString};
 +pub use content_addressing::{ContentId, ContentVerifier, HashAlgorithm};
++
 +use anyhow::Result;
 +use zeroize::Zeroize;
++
 +/// Core cryptographic parameters following Tahoe-LAFS security model
 +pub struct CryptoParams {
 +    /// Scrypt parameters: N=2^17, r=8, p=1, output=96 bytes
 +    pub scrypt_params: ScryptParams,
 +    /// AES-256-GCM parameters
 +    pub aes_params: AesParams,
 +    /// Content addressing parameters
 +    pub hash_params: HashParams,
 +}
++
 +#[derive(Debug, Clone)]
 +pub struct ScryptParams {
 +    pub log_n: u8,      // 17 (N = 2^17 = 131072)
 +    pub r: u32,         // 8
 +    pub p: u32,         // 1
 +    pub output_len: usize, // 96 bytes (master key + salt + verification)
 +}
++
 +#[derive(Debug, Clone)]
 +pub struct AesParams {
 +    pub key_len: usize,    // 32 bytes (AES-256)
 +    pub nonce_len: usize,  // 12 bytes (GCM standard)
 +    pub tag_len: usize,    // 16 bytes (GCM authentication tag)
 +}
++
 +#[derive(Debug, Clone)]
 +pub struct HashParams {
 +    pub content_hasher: ContentHasher,
 +    pub verification_hasher: VerificationHasher,
 +}
++
 +#[derive(Debug, Clone)]
 +pub enum ContentHasher {
 +    Blake3,     // Fast hashing for content IDs
 +    Sha256,     // SHA-256 for compatibility
 +}
++
 +#[derive(Debug, Clone)]
 +pub enum VerificationHasher {
 +    Blake3,     // Fast verification
 +    Sha256,     // Standard verification
 +}
++
 +impl Default for CryptoParams {
 +    fn default() -> Self {
 +        Self {
 +            scrypt_params: ScryptParams {
 +                log_n: 17,          // 2^17 iterations (strong security)
 +                r: 8,               // Memory cost parameter
 +                p: 1,               // Parallelization parameter
 +                output_len: 64,     // 64 bytes (max supported by scrypt crate)
 +            },
 +            aes_params: AesParams {
 +                key_len: 32,        // AES-256
 +                nonce_len: 12,      // GCM standard nonce size
 +                tag_len: 16,        // GCM authentication tag size
 +            },
 +            hash_params: HashParams {
 +                content_hasher: ContentHasher::Blake3,
 +                verification_hasher: VerificationHasher::Blake3,
 +            },
 +        }
 +    }
 +}
++
 +/// High-level cryptographic operations for ZephyrFS
 +pub struct ZephyrCrypto {
 +    params: CryptoParams,
 +    key_hierarchy: Option<KeyHierarchy>,
 +}
++
 +impl ZephyrCrypto {
 +    /// Create new crypto instance with default parameters
 +    pub fn new() -> Self {
 +        Self {
 +            params: CryptoParams::default(),
 +            key_hierarchy: None,
 +        }
 +    }
++
 +    /// Create crypto instance with custom parameters
 +    pub fn with_params(params: CryptoParams) -> Self {
 +        Self {
 +            params,
 +            key_hierarchy: None,
 +        }
 +    }
++
 +    /// Initialize key hierarchy from password
 +    pub fn init_from_password(&mut self, password: &str) -> Result<()> {
 +        let key_derivation = KeyDerivation::new(&self.params.scrypt_params);
 +        let derived_key = key_derivation.derive_from_password(password)?;
 +        self.key_hierarchy = Some(KeyHierarchy::new(derived_key)?);
 +        Ok(())
 +    }
++
 +    /// Initialize key hierarchy from existing key material
 +    pub fn init_from_key(&mut self, key_material: SecureBytes) -> Result<()> {
 +        let derived_key = DerivedKey::from_bytes(key_material)?;
 +        self.key_hierarchy = Some(KeyHierarchy::new(derived_key)?);
 +        Ok(())
 +    }
++
 +    /// Encrypt file data into segments
 +    pub fn encrypt_file(&self, file_data: &[u8]) -> Result<Vec<EncryptedData>> {
 +        let hierarchy = self.key_hierarchy.as_ref()
 +            .ok_or_else(|| anyhow::anyhow!("Key hierarchy not initialized"))?;
++
 +        let file_encryption = FileEncryption::new(&self.params.aes_params);
 +        file_encryption.encrypt_to_segments(file_data, hierarchy)
 +    }
++
 +    /// Decrypt file segments back to original data
 +    pub fn decrypt_file(&self, encrypted_segments: &[EncryptedData]) -> Result<Vec<u8>> {
 +        let hierarchy = self.key_hierarchy.as_ref()
 +            .ok_or_else(|| anyhow::anyhow!("Key hierarchy not initialized"))?;
++
 +        let file_encryption = FileEncryption::new(&self.params.aes_params);
 +        file_encryption.decrypt_from_segments(encrypted_segments, hierarchy)
 +    }
++
 +    /// Generate content ID for data
 +    pub fn content_id(&self, data: &[u8]) -> ContentId {
 +        ContentId::generate(data, &self.params.hash_params.content_hasher)
 +    }
++
 +    /// Verify content integrity
 +    pub fn verify_content(&self, data: &[u8], expected_id: &ContentId) -> bool {
 +        ContentVerifier::verify(data, expected_id, &self.params.hash_params.verification_hasher)
 +    }
++
 +    /// Get public key material for capability sharing (zero-knowledge proof)
 +    pub fn get_capability(&self) -> Result<Vec<u8>> {
 +        let hierarchy = self.key_hierarchy.as_ref()
 +            .ok_or_else(|| anyhow::anyhow!("Key hierarchy not initialized"))?;
++
 +        // Return only public/shareable key material, never private keys
 +        Ok(hierarchy.get_public_capability()?)
 +    }
 +}
++
 +impl Drop for ZephyrCrypto {
 +    fn drop(&mut self) {
 +        // Ensure all sensitive data is cleared when dropping
 +        if let Some(ref mut hierarchy) = self.key_hierarchy {
 +            hierarchy.zeroize();
 +        }
 +    }
 +}
++
 +impl Zeroize for ZephyrCrypto {
 +    fn zeroize(&mut self) {
 +        if let Some(ref mut hierarchy) = self.key_hierarchy {
 +            hierarchy.zeroize();
 +        }
 +        self.key_hierarchy = None;
 +    }
 +}
++
 +#[cfg(test)]
 +mod tests {
 +    use super::*;
++
 +    #[test]
 +    fn test_crypto_params_default() {
 +        let params = CryptoParams::default();
 +        assert_eq!(params.scrypt_params.log_n, 17);
 +        assert_eq!(params.scrypt_params.r, 8);
 +        assert_eq!(params.scrypt_params.p, 1);
 +        assert_eq!(params.aes_params.key_len, 32);
 +        assert_eq!(params.aes_params.nonce_len, 12);
 +        assert_eq!(params.aes_params.tag_len, 16);
 +    }
++
 +    #[test]
 +    fn test_zephyr_crypto_creation() {
 +        let crypto = ZephyrCrypto::new();
 +        assert!(crypto.key_hierarchy.is_none());
 +    }
++
 +    #[test]
 +    fn test_crypto_init_from_password() {
 +        let mut crypto = ZephyrCrypto::new();
 +        let result = crypto.init_from_password("test_password_123");
 +        assert!(result.is_ok());
 +        assert!(crypto.key_hierarchy.is_some());
 +    }
 +}

src/crypto/secure_memory.rsadded

 +//! Secure memory handling for ZephyrFS cryptographic operations
 +//!
 +//! Provides zeroizing containers for sensitive data like keys, passwords, and plaintext.
 +//! Ensures memory is securely cleared when data is no longer needed.
++
 +use zeroize::{Zeroize, ZeroizeOnDrop};
 +use std::ops::{Deref, DerefMut};
 +use std::fmt;
++
 +/// Secure byte buffer that automatically zeros memory on drop
 +#[derive(Clone, ZeroizeOnDrop)]
 +pub struct SecureBytes {
 +    data: Vec<u8>,
 +}
++
 +impl SecureBytes {
 +    /// Create new secure buffer with specified size
 +    pub fn new(size: usize) -> Self {
 +        Self {
 +            data: vec![0u8; size],
 +        }
 +    }
++
 +    /// Create from existing data (data will be zeroized in source)
 +    pub fn from_vec(mut data: Vec<u8>) -> Self {
 +        let secure = Self { data: data.clone() };
 +        data.zeroize(); // Clear original
 +        secure
 +    }
++
 +    /// Create from slice (slice data will be copied)
 +    pub fn from_slice(data: &[u8]) -> Self {
 +        Self {
 +            data: data.to_vec(),
 +        }
 +    }
++
 +    /// Get length of secure buffer
 +    pub fn len(&self) -> usize {
 +        self.data.len()
 +    }
++
 +    /// Check if buffer is empty
 +    pub fn is_empty(&self) -> bool {
 +        self.data.is_empty()
 +    }
++
 +    /// Get immutable reference to bytes
 +    pub fn as_bytes(&self) -> &[u8] {
 +        &self.data
 +    }
++
 +    /// Get mutable reference to bytes
 +    pub fn as_mut(&mut self) -> &mut [u8] {
 +        &mut self.data
 +    }
++
 +    /// Copy data from slice into this buffer
 +    pub fn copy_from_slice(&mut self, src: &[u8]) {
 +        if src.len() != self.data.len() {
 +            panic!("Source length {} doesn't match buffer length {}", src.len(), self.data.len());
 +        }
 +        self.data.copy_from_slice(src);
 +    }
++
 +    /// Resize buffer (new space will be zero-filled)
 +    pub fn resize(&mut self, new_size: usize) {
 +        self.data.resize(new_size, 0);
 +    }
++
 +    /// Clear buffer contents (set all bytes to zero)
 +    pub fn clear(&mut self) {
 +        self.data.zeroize();
 +    }
++
 +    /// Split buffer at index, returning (left, right)
 +    pub fn split_at(mut self, mid: usize) -> (SecureBytes, SecureBytes) {
 +        let right = self.data.split_off(mid);
 +        let left_data = std::mem::take(&mut self.data);
 +        let left = SecureBytes { data: left_data };
 +        let right = SecureBytes { data: right };
 +        self.data.zeroize(); // Clear original (now empty)
 +        (left, right)
 +    }
++
 +    /// Extend buffer with data from slice
 +    pub fn extend_from_slice(&mut self, data: &[u8]) {
 +        self.data.extend_from_slice(data);
 +    }
++
 +    /// Convert to Vec<u8> (consumes self and zeros original)
 +    pub fn into_vec(mut self) -> Vec<u8> {
 +        let data = std::mem::take(&mut self.data);
 +        self.data.zeroize();
 +        data
 +    }
 +}
++
 +impl Deref for SecureBytes {
 +    type Target = [u8];
++
 +    fn deref(&self) -> &Self::Target {
 +        &self.data
 +    }
 +}
++
 +impl DerefMut for SecureBytes {
 +    fn deref_mut(&mut self) -> &mut Self::Target {
 +        &mut self.data
 +    }
 +}
++
 +impl AsRef<[u8]> for SecureBytes {
 +    fn as_ref(&self) -> &[u8] {
 +        &self.data
 +    }
 +}
++
 +impl AsMut<[u8]> for SecureBytes {
 +    fn as_mut(&mut self) -> &mut [u8] {
 +        &mut self.data
 +    }
 +}
++
 +// Implement Debug but don't show actual data
 +impl fmt::Debug for SecureBytes {
 +    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 +        f.debug_struct("SecureBytes")
 +            .field("len", &self.data.len())
 +            .field("data", &"[REDACTED]")
 +            .finish()
 +    }
 +}
++
 +// Implement PartialEq for testing, but use constant-time comparison
 +impl PartialEq for SecureBytes {
 +    fn eq(&self, other: &Self) -> bool {
 +        if self.data.len() != other.data.len() {
 +            return false;
 +        }
 +        constant_time_eq::constant_time_eq(&self.data, &other.data)
 +    }
 +}
++
 +impl Eq for SecureBytes {}
++
 +impl Zeroize for SecureBytes {
 +    fn zeroize(&mut self) {
 +        self.data.zeroize();
 +    }
 +}
++
 +/// Secure string that automatically zeros memory on drop
 +#[derive(Clone, ZeroizeOnDrop)]
 +pub struct SecureString {
 +    data: String,
 +}
++
 +impl SecureString {
 +    /// Create new empty secure string
 +    pub fn new() -> Self {
 +        Self {
 +            data: String::new(),
 +        }
 +    }
++
 +    /// Create from existing string (string will be zeroized in source)
 +    pub fn from_string(mut data: String) -> Self {
 +        let secure = Self { data: data.clone() };
 +        data.zeroize();
 +        secure
 +    }
++
 +    /// Create from str (data will be copied)
 +    pub fn from_str(data: &str) -> Self {
 +        Self {
 +            data: data.to_string(),
 +        }
 +    }
++
 +    /// Get length of string
 +    pub fn len(&self) -> usize {
 +        self.data.len()
 +    }
++
 +    /// Check if string is empty
 +    pub fn is_empty(&self) -> bool {
 +        self.data.is_empty()
 +    }
++
 +    /// Get str reference
 +    pub fn as_str(&self) -> &str {
 +        &self.data
 +    }
++
 +    /// Push character to string
 +    pub fn push(&mut self, ch: char) {
 +        self.data.push(ch);
 +    }
++
 +    /// Push str to string
 +    pub fn push_str(&mut self, string: &str) {
 +        self.data.push_str(string);
 +    }
++
 +    /// Clear string contents
 +    pub fn clear(&mut self) {
 +        self.data.zeroize();
 +        self.data.clear();
 +    }
++
 +    /// Convert to String (consumes self and zeros original)
 +    pub fn into_string(mut self) -> String {
 +        let data = std::mem::take(&mut self.data);
 +        self.data.zeroize();
 +        data
 +    }
++
 +    /// Get bytes of the UTF-8 string
 +    pub fn as_bytes(&self) -> &[u8] {
 +        self.data.as_bytes()
 +    }
 +}
++
 +impl Default for SecureString {
 +    fn default() -> Self {
 +        Self::new()
 +    }
 +}
++
 +impl Deref for SecureString {
 +    type Target = str;
++
 +    fn deref(&self) -> &Self::Target {
 +        &self.data
 +    }
 +}
++
 +impl AsRef<str> for SecureString {
 +    fn as_ref(&self) -> &str {
 +        &self.data
 +    }
 +}
++
 +impl fmt::Debug for SecureString {
 +    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 +        f.debug_struct("SecureString")
 +            .field("len", &self.data.len())
 +            .field("data", &"[REDACTED]")
 +            .finish()
 +    }
 +}
++
 +impl PartialEq for SecureString {
 +    fn eq(&self, other: &Self) -> bool {
 +        constant_time_eq::constant_time_eq(self.data.as_bytes(), other.data.as_bytes())
 +    }
 +}
++
 +impl Eq for SecureString {}
++
 +impl Zeroize for SecureString {
 +    fn zeroize(&mut self) {
 +        self.data.zeroize();
 +    }
 +}
++
 +/// Utility for securely reading passwords from console
 +pub struct SecureInput;
++
 +impl SecureInput {
 +    /// Read password from stdin without echoing (requires rpassword crate)
 +    #[cfg(feature = "password-input")]
 +    pub fn read_password(prompt: &str) -> std::io::Result<SecureString> {
 +        use rpassword::read_password_from_tty;
 +        print!("{}", prompt);
 +        std::io::flush(std::io::stdout())?;
 +        let password = read_password_from_tty(None)?;
 +        Ok(SecureString::from_string(password))
 +    }
++
 +    /// Read password from stdin (fallback - echoes input, for testing only)
 +    #[cfg(not(feature = "password-input"))]
 +    pub fn read_password(prompt: &str) -> std::io::Result<SecureString> {
 +        use std::io::{self, Write};
 +        print!("{}", prompt);
 +        io::stdout().flush()?;
++
 +        let mut input = String::new();
 +        io::stdin().read_line(&mut input)?;
++
 +        // Remove trailing newline
 +        if input.ends_with('\n') {
 +            input.pop();
 +        }
++
 +        Ok(SecureString::from_string(input))
 +    }
 +}
++
 +/// Helper trait for creating secure versions of sensitive data
 +pub trait IntoSecure {
 +    type Output;
 +    fn into_secure(self) -> Self::Output;
 +}
++
 +impl IntoSecure for Vec<u8> {
 +    type Output = SecureBytes;
++
 +    fn into_secure(self) -> Self::Output {
 +        SecureBytes::from_vec(self)
 +    }
 +}
++
 +impl IntoSecure for String {
 +    type Output = SecureString;
++
 +    fn into_secure(self) -> Self::Output {
 +        SecureString::from_string(self)
 +    }
 +}
++
 +impl IntoSecure for &[u8] {
 +    type Output = SecureBytes;
++
 +    fn into_secure(self) -> Self::Output {
 +        SecureBytes::from_slice(self)
 +    }
 +}
++
 +impl IntoSecure for &str {
 +    type Output = SecureString;
++
 +    fn into_secure(self) -> Self::Output {
 +        SecureString::from_str(self)
 +    }
 +}
++
 +#[cfg(test)]
 +mod tests {
 +    use super::*;
++
 +    #[test]
 +    fn test_secure_bytes_basic_operations() {
 +        let mut secure = SecureBytes::new(32);
 +        assert_eq!(secure.len(), 32);
 +        assert!(!secure.is_empty());
++
 +        // Fill with test data
 +        for (i, byte) in secure.as_mut().iter_mut().enumerate() {
 +            *byte = (i % 256) as u8;
 +        }
++
 +        // Check data
 +        for (i, &byte) in secure.as_bytes().iter().enumerate() {
 +            assert_eq!(byte, (i % 256) as u8);
 +        }
++
 +        // Clear should zero all data
 +        secure.clear();
 +        for &byte in secure.as_bytes() {
 +            assert_eq!(byte, 0);
 +        }
 +    }
++
 +    #[test]
 +    fn test_secure_bytes_from_slice() {
 +        let data = b"Hello, ZephyrFS!";
 +        let secure = SecureBytes::from_slice(data);
++
 +        assert_eq!(secure.len(), data.len());
 +        assert_eq!(secure.as_bytes(), data);
 +    }
++
 +    #[test]
 +    fn test_secure_bytes_split() {
 +        let mut secure = SecureBytes::new(10);
 +        for (i, byte) in secure.as_mut().iter_mut().enumerate() {
 +            *byte = i as u8;
 +        }
++
 +        let (left, right) = secure.split_at(4);
 +        assert_eq!(left.len(), 4);
 +        assert_eq!(right.len(), 6);
 +        assert_eq!(left.as_bytes(), &[0, 1, 2, 3]);
 +        assert_eq!(right.as_bytes(), &[4, 5, 6, 7, 8, 9]);
 +    }
++
 +    #[test]
 +    fn test_secure_string_operations() {
 +        let mut secure = SecureString::from_str("Hello");
 +        assert_eq!(secure.len(), 5);
 +        assert_eq!(secure.as_str(), "Hello");
++
 +        secure.push_str(", World!");
 +        assert_eq!(secure.as_str(), "Hello, World!");
++
 +        secure.clear();
 +        assert!(secure.is_empty());
 +    }
++
 +    #[test]
 +    fn test_secure_memory_equality() {
 +        let secure1 = SecureBytes::from_slice(b"test data");
 +        let secure2 = SecureBytes::from_slice(b"test data");
 +        let secure3 = SecureBytes::from_slice(b"different");
++
 +        assert_eq!(secure1, secure2);
 +        assert_ne!(secure1, secure3);
++
 +        let str1 = SecureString::from_str("password");
 +        let str2 = SecureString::from_str("password");
 +        let str3 = SecureString::from_str("different");
++
 +        assert_eq!(str1, str2);
 +        assert_ne!(str1, str3);
 +    }
++
 +    #[test]
 +    fn test_into_secure_trait() {
 +        let vec = vec![1, 2, 3, 4, 5];
 +        let secure_bytes = vec.into_secure();
 +        assert_eq!(secure_bytes.as_bytes(), &[1, 2, 3, 4, 5]);
++
 +        let string = "test string".to_string();
 +        let secure_string = string.into_secure();
 +        assert_eq!(secure_string.as_str(), "test string");
++
 +        let slice: &[u8] = &[10, 20, 30];
 +        let secure_bytes = slice.into_secure();
 +        assert_eq!(secure_bytes.as_bytes(), &[10, 20, 30]);
++
 +        let str_ref: &str = "reference string";
 +        let secure_string = str_ref.into_secure();
 +        assert_eq!(secure_string.as_str(), "reference string");
 +    }
++
 +    #[test]
 +    fn test_debug_redaction() {
 +        let secure_bytes = SecureBytes::from_slice(b"secret data");
 +        let debug_str = format!("{:?}", secure_bytes);
 +        assert!(debug_str.contains("[REDACTED]"));
 +        assert!(!debug_str.contains("secret"));
++
 +        let secure_string = SecureString::from_str("secret password");
 +        let debug_str = format!("{:?}", secure_string);
 +        assert!(debug_str.contains("[REDACTED]"));
 +        assert!(!debug_str.contains("password"));
 +    }
++
 +    #[test]
 +    fn test_zeroize_on_drop() {
 +        let mut data = vec![1, 2, 3, 4, 5];
 +        {
 +            let _secure = SecureBytes::from_vec(data.clone());
 +            // secure goes out of scope here and should zero its memory
 +        }
 +        // Original data should be zeroed
 +        assert_eq!(data, vec![0, 0, 0, 0, 0]);
 +    }
 +}

src/lib.rsadded

 +//! ZephyrFS Node Library
 +//!
 +//! Core library for ZephyrFS distributed P2P storage system.
 +//! Provides cryptographic primitives, storage management, and network protocols.
++
 +pub mod config;
 +pub mod network;
 +pub mod storage;
 +pub mod protocol;
 +pub mod node_manager;
 +pub mod crypto;
++
 +pub use crypto::{
 +    ZephyrCrypto, CryptoParams, ScryptParams, AesParams, HashParams,
 +    ContentHasher, VerificationHasher, EncryptedData, ContentId, HashAlgorithm
 +};
++
 +pub use config::Config;
 +pub use node_manager::{NodeManager, DistributionStrategy};
 +pub use storage::{StorageManager, StorageConfig};

src/main.rsmodified

  mod storage;
  mod protocol;
  mod node_manager;
 +mod crypto;
  #[cfg(test)]
  mod integration_tests;
          .init();
      match args.command {
 -        Some(Commands::HealthCheck) | None if std::env::args().any(|arg| arg == "--health-check") => {
 +        Some(Commands::HealthCheck) => {
              // Simple health check for Docker/monitoring
              info!("Health check passed");
              Ok(())
              init_node(storage_path, max_storage_gb, args.config.as_deref()).await
+         }
 -        Some(Commands::Start { daemon }) | None => {
 +        Some(Commands::Start { daemon }) => {
              start_node(daemon, args.config.as_deref()).await
+         }
 +        None => {
 +            start_node(false, args.config.as_deref()).await
 +        }
++
          Some(Commands::Join { bootstrap_peer }) => {
              join_network(bootstrap_peer, args.config.as_deref()).await
+         }