use lib_crypto::*;

// RECOMMENDED: Post-quantum secure algorithms
fn secure_algorithm_selection() -> Result<()> {
    // Post-quantum signatures (quantum-resistant)
    let pq_keypair = post_quantum::DilithiumKeyPair::generate()?;
    
    // Classical signatures for current security (faster)
    let classical_keypair = KeyPair::generate(); // Ed25519
    
    // Hybrid encryption (quantum-resistant KEM + classical symmetric)
    let message = b"Highly sensitive data requiring post-quantum protection";
    let encrypted = pq_keypair.encrypt(message, b"metadata")?;
    
    // Use strongest available hashing
    let hash = hashing::blake3_hash(b"data to hash")?; // BLAKE3 > SHA-3 > SHA-2
    
    println!("Selected quantum-resistant algorithms");
    Ok(())
}

// AVOID: Deprecated or weak algorithms
fn avoid_weak_algorithms() {
    // DON'T USE: RSA (vulnerable to quantum attacks)
    // DON'T USE: ECDSA with weak curves (secp256k1 without post-quantum)
    // DON'T USE: SHA-1 (cryptographically broken)
    // DON'T USE: MD5 (completely broken)
    // DON'T USE: DES, 3DES (too short key lengths)
}

use lib_crypto::{KeyPair, random::SecureRng};
use zeroize::{Zeroize, ZeroizeOnDrop};

#[derive(ZeroizeOnDrop)]
struct SecureKeyMaterial {
    private_key: [u8; 32],
    derived_keys: Vec<[u8; 32]>,
}

fn secure_key_management() -> Result<()> {
    // Generate keys with secure randomness
    let keypair = KeyPair::generate()?; // Uses system entropy
    
    // Derive keys properly with salt
    let master_key = random::secure_random_bytes::<32>()?;
    let salt = random::secure_random_bytes::<32>()?;
    let derived_key = hashing::blake3_derive_key(&master_key, &salt);
    
    // Store sensitive material in secure containers
    let mut secure_material = SecureKeyMaterial {
        private_key: master_key,
        derived_keys: vec![derived_key],
    };
    
    // ... use keys for cryptographic operations ...
    
    // Explicitly zero sensitive data
    secure_material.zeroize();
    
    println!("Secure key management implemented");
    Ok(())
}

// Key rotation strategy
fn key_rotation_strategy() -> Result<()> {
    struct KeyManager {
        current_key: KeyPair,
        previous_key: Option<KeyPair>,
        rotation_interval: std::time::Duration,
        last_rotation: std::time::SystemTime,
    }
    
    impl KeyManager {
        fn should_rotate(&self) -> bool {
            self.last_rotation.elapsed().unwrap_or_default() > self.rotation_interval
        }
        
        fn rotate_keys(&mut self) -> Result<()> {
            // Archive old key for decryption
            self.previous_key = Some(self.current_key.clone());
            
            // Generate new key for encryption
            self.current_key = KeyPair::generate()?;
            self.last_rotation = std::time::SystemTime::now();
            
            println!("Keys rotated successfully");
            Ok(())
        }
    }
    
    let mut key_manager = KeyManager {
        current_key: KeyPair::generate()?,
        previous_key: None,
        rotation_interval: std::time::Duration::from_secs(86400 * 30), // 30 days
        last_rotation: std::time::SystemTime::now(),
    };
    
    if key_manager.should_rotate() {
        key_manager.rotate_keys()?;
    }
    
    Ok(())
}

use lib_crypto::{KeyPair, symmetric::*};

fn secure_communication() -> Result<()> {
    // Perfect Forward Secrecy
    fn establish_ephemeral_channel() -> Result<([u8; 32], Vec<u8>)> {
        // Generate ephemeral keypair for each session
        let ephemeral_keypair = KeyPair::generate()?;
        
        // Perform key exchange (simplified)
        let encapsulation = ephemeral_keypair.encapsulate()?;
        let shared_secret = encapsulation.shared_secret;
        
        // Delete ephemeral private key immediately after use
        drop(ephemeral_keypair);
        
        Ok((shared_secret, encapsulation.ciphertext))
    }
    
    let (session_key, kem_ciphertext) = establish_ephemeral_channel()?;
    
    // Authenticated encryption with associated data
    let plaintext = b"Confidential message requiring integrity";
    let associated_data = b"session_id=12345,timestamp=1640995200";
    let nonce = random::secure_random_bytes::<12>()?;
    
    let ciphertext = encrypt_chacha20poly1305(
        plaintext,
        associated_data,
        &session_key,
        &nonce
    )?;
    
    // Secure transmission format: [KEM_CT][NONCE][AEAD_CT]
    let mut secure_message = Vec::new();
    secure_message.extend_from_slice(&kem_ciphertext);
    secure_message.extend_from_slice(&nonce);
    secure_message.extend_from_slice(&ciphertext);
    
    println!("Secure communication established with forward secrecy");
    Ok(())
}

use lib_crypto::{KeyPair, random::SecureRng};

fn side_channel_protection() -> Result<()> {
    let keypair = KeyPair::generate()?;
    let message = b"Message requiring side-channel protection";
    
    // Constant-time operations (built into Ed25519)
    let signature = keypair.sign(message)?; // Constant-time signing
    
    // Timing attack mitigation with random delays
    let mut rng = SecureRng::new()?;
    let jitter_us = rng.gen_range(100..1000); // 0.1-1ms random delay
    std::thread::sleep(std::time::Duration::from_micros(jitter_us));
    
    // Memory access pattern obfuscation
    let dummy_operations = rng.gen_range(5..15);
    for _ in 0..dummy_operations {
        let _ = random::secure_random_bytes::<32>()?; // Dummy computation
    }
    
    // Power analysis resistance (algorithmic)
    let verification = keypair.verify(&signature, message)?;
    
    // Cache timing attack mitigation
    let cache_noise_iterations = rng.gen_range(10..50);
    let mut cache_noise = vec![0u8; 4096 * cache_noise_iterations];
    rng.fill_bytes(&mut cache_noise);
    
    println!("Side-channel protections applied");
    Ok(())
}

use lib_crypto::{KeyPair, hashing::blake3_hash};

fn network_attack_protection() -> Result<()> {
    // Replay attack prevention
    struct ReplayProtection {
        nonce_cache: std::collections::HashSet<[u8; 32]>,
        window_start: u64,
        window_size: u64,
    }
    
    impl ReplayProtection {
        fn verify_nonce(&mut self, nonce: &[u8; 32], timestamp: u64) -> bool {
            // Check if nonce is within time window
            if timestamp < self.window_start || 
               timestamp > self.window_start + self.window_size {
                return false;
            }
            
            // Check if nonce has been used before
            if self.nonce_cache.contains(nonce) {
                return false; // Replay attack detected
            }
            
            self.nonce_cache.insert(*nonce);
            true
        }
        
        fn cleanup_old_nonces(&mut self, current_time: u64) {
            if current_time > self.window_start + self.window_size {
                self.nonce_cache.clear();
                self.window_start = current_time;
            }
        }
    }
    
    // Message authentication with sequence numbers
    struct MessageAuth {
        keypair: KeyPair,
        sequence_number: u64,
    }
    
    impl MessageAuth {
        fn sign_message(&mut self, message: &[u8]) -> Result<Vec<u8>> {
            // Include sequence number in signed data
            let mut signed_data = Vec::new();
            signed_data.extend_from_slice(message);
            signed_data.extend_from_slice(&self.sequence_number.to_le_bytes());
            
            let signature = self.keypair.sign(&signed_data)?;
            self.sequence_number += 1;
            
            // Format: [SEQ][MESSAGE][SIGNATURE]
            let mut authenticated_message = Vec::new();
            authenticated_message.extend_from_slice(&self.sequence_number.to_le_bytes());
            authenticated_message.extend_from_slice(message);
            authenticated_message.extend_from_slice(&signature.as_bytes());
            
            Ok(authenticated_message)
        }
    }
    
    println!("Network attack protections implemented");
    Ok(())
}

use lib_crypto::{post_quantum::*, classical::*};

fn quantum_attack_preparation() -> Result<()> {
    // Hybrid cryptosystem (classical + post-quantum)
    struct HybridCrypto {
        classical_keypair: KeyPair,      // Fast, current security
        pq_keypair: DilithiumKeyPair,    // Quantum-resistant
    }
    
    impl HybridCrypto {
        fn new() -> Result<Self> {
            Ok(Self {
                classical_keypair: KeyPair::generate()?,
                pq_keypair: DilithiumKeyPair::generate()?,
            })
        }
        
        fn hybrid_sign(&self, message: &[u8]) -> Result<Vec<u8>> {
            // Sign with both algorithms
            let classical_sig = self.classical_keypair.sign(message)?;
            let pq_sig = self.pq_keypair.sign(message)?;
            
            // Combine signatures
            let mut hybrid_signature = Vec::new();
            hybrid_signature.extend_from_slice(&classical_sig.as_bytes());
            hybrid_signature.extend_from_slice(&pq_sig.as_bytes());
            
            Ok(hybrid_signature)
        }
        
        fn hybrid_verify(&self, signature: &[u8], message: &[u8]) -> Result<bool> {
            // Split combined signature
            let classical_sig = &signature[..64]; // Ed25519 is 64 bytes
            let pq_sig = &signature[64..];
            
            // Verify both signatures
            let classical_valid = self.classical_keypair.verify_bytes(classical_sig, message)?;
            let pq_valid = self.pq_keypair.verify_bytes(pq_sig, message)?;
            
            // Both must be valid
            Ok(classical_valid && pq_valid)
        }
    }
    
    let hybrid_crypto = HybridCrypto::new()?;
    let message = b"Message protected against quantum attacks";
    
    let hybrid_signature = hybrid_crypto.hybrid_sign(message)?;
    let is_valid = hybrid_crypto.hybrid_verify(&hybrid_signature, message)?;
    
    println!("Hybrid quantum-resistant signature: {}", is_valid);
    Ok(())
}

use lib_crypto::*;

fn secure_input_validation() -> Result<()> {
    // Validate all cryptographic inputs
    fn validate_signature_input(signature: &[u8], message: &[u8], pubkey: &[u8]) -> Result<()> {
        // Check signature length
        if signature.len() != 64 {
            return Err(anyhow::anyhow!("Invalid signature length: {}", signature.len()));
        }
        
        // Check public key length
        if pubkey.len() != 32 {
            return Err(anyhow::anyhow!("Invalid public key length: {}", pubkey.len()));
        }
        
        // Check message isn't empty (application-specific)
        if message.is_empty() {
            return Err(anyhow::anyhow!("Empty message not allowed"));
        }
        
        // Check message size limits (prevent DoS)
        if message.len() > 1_000_000 { // 1MB limit
            return Err(anyhow::anyhow!("Message too large: {} bytes", message.len()));
        }
        
        Ok(())
    }
    
    // Sanitize and validate all inputs
    let raw_signature = [0u8; 64]; // Simulated input
    let raw_message = b"Test message";
    let raw_pubkey = [1u8; 32];
    
    validate_signature_input(&raw_signature, raw_message, &raw_pubkey)?;
    
    // Use type-safe interfaces when possible
    let keypair = KeyPair::generate()?;
    let message = b"Type-safe message signing";
    let signature = keypair.sign(message)?; // Type-safe, validated internally
    
    println!("Input validation implemented");
    Ok(())
}

use lib_crypto::*;

fn secure_error_handling() -> Result<()> {
    let keypair = KeyPair::generate()?;
    let message = b"Test message for error handling";
    let signature = keypair.sign(message)?;
    
    // Don't leak information through error messages
    fn safe_verification(sig: &[u8], msg: &[u8], pubkey: &[u8]) -> Result<bool> {
        match verify_signature_bytes(sig, msg, pubkey) {
            Ok(result) => Ok(result),
            Err(_) => {
                // Generic error message (don't reveal why verification failed)
                println!("Verification failed"); // Same message for all failures
                Ok(false)
            }
        }
    }
    
    // Constant-time error responses
    fn constant_time_verification(sig: &[u8], msg: &[u8], pubkey: &[u8]) -> Result<bool> {
        let start_time = std::time::Instant::now();
        
        let result = verify_signature_bytes(sig, msg, pubkey).unwrap_or(false);
        
        // Ensure minimum processing time to prevent timing attacks
        let min_duration = std::time::Duration::from_millis(10);
        let elapsed = start_time.elapsed();
        if elapsed < min_duration {
            std::thread::sleep(min_duration - elapsed);
        }
        
        Ok(result)
    }
    
    // Audit security-relevant errors
    fn audit_security_events(event: &str, details: &str) {
        let timestamp = std::time::SystemTime::now()
            .duration_since(std::time::UNIX_EPOCH)
            .unwrap()
            .as_secs();
        
        // Log to secure audit trail (not shown here)
        println!("SECURITY_EVENT: {} - {} at {}", event, details, timestamp);
    }
    
    // Test error handling
    let wrong_signature = [0u8; 64];
    match safe_verification(&wrong_signature, message, &keypair.public_key().as_bytes()) {
        Ok(false) => audit_security_events("VERIFICATION_FAILED", "Invalid signature"),
        _ => audit_security_events("UNEXPECTED_ERROR", "Verification error handling"),
    }
    
    println!("Secure error handling implemented");
    Ok(())
}

use lib_crypto::*;
use zeroize::{Zeroize, ZeroizeOnDrop};

// Secure memory containers
#[derive(ZeroizeOnDrop)]
struct SecureBuffer {
    data: Vec<u8>,
    size: usize,
}

impl SecureBuffer {
    fn new(size: usize) -> Self {
        Self {
            data: vec![0u8; size],
            size,
        }
    }
    
    fn write(&mut self, offset: usize, data: &[u8]) -> Result<()> {
        if offset + data.len() > self.size {
            return Err(anyhow::anyhow!("Buffer overflow prevented"));
        }
        self.data[offset..offset + data.len()].copy_from_slice(data);
        Ok(())
    }
    
    fn read(&self, offset: usize, len: usize) -> Result<&[u8]> {
        if offset + len > self.size {
            return Err(anyhow::anyhow!("Buffer overread prevented"));
        }
        Ok(&self.data[offset..offset + len])
    }
}

fn memory_security() -> Result<()> {
    // Use secure buffers for sensitive data
    let mut secure_key_buffer = SecureBuffer::new(32);
    let key_material = random::secure_random_bytes::<32>()?;
    secure_key_buffer.write(0, &key_material)?;
    
    // Prevent memory dumps of sensitive data
    use mlock::*; // Hypothetical memory locking crate
    let sensitive_data = random::secure_random_bytes::<64>()?;
    // mlock(&sensitive_data)?; // Lock memory page to prevent swapping
    
    // Overwrite sensitive data multiple times
    fn secure_overwrite(buffer: &mut [u8]) {
        // Multiple pass overwrite (DoD 5220.22-M standard)
        buffer.fill(0x00);
        buffer.fill(0xFF);
        buffer.fill(0x00);
        
        // Random overwrite pass
        use rand::RngCore;
        rand::rngs::OsRng.fill_bytes(buffer);
        
        // Final zero pass
        buffer.zeroize();
    }
    
    // Stack allocation for temporary sensitive data
    {
        let temp_key = random::secure_random_bytes::<32>()?;
        // Use temp_key...
        // Automatically cleared when leaving scope
    }
    
    println!("Memory security measures implemented");
    Ok(())
}

use lib_crypto::*;

fn cryptographic_testing() -> Result<()> {
    // Test vector validation
    fn test_known_vectors() -> Result<()> {
        // Test with known good inputs/outputs
        let test_vectors = [
            (b"test message 1", "expected_signature_hex"),
            (b"test message 2", "expected_signature_hex"),
        ];
        
        let keypair = KeyPair::from_seed(&[1u8; 32])?; // Deterministic for testing
        
        for (message, expected_sig_hex) in &test_vectors {
            let signature = keypair.sign(message)?;
            let sig_hex = hex::encode(signature.as_bytes());
            
            if &sig_hex != expected_sig_hex {
                return Err(anyhow::anyhow!("Test vector failed for message: {:?}", message));
            }
        }
        
        println!("All test vectors passed");
        Ok(())
    }
    
    // Fuzzing inputs
    fn fuzz_testing() -> Result<()> {
        let keypair = KeyPair::generate()?;
        let valid_message = b"Valid message";
        let valid_signature = keypair.sign(valid_message)?;
        
        // Fuzz signature bytes
        for i in 0..64 {
            let mut fuzzed_sig = valid_signature.clone();
            fuzzed_sig.as_mut()[i] ^= 0xFF; // Flip bits
            
            // Should always return false, never panic
            let result = keypair.verify(&fuzzed_sig, valid_message);
            assert!(result.is_ok()); // Should not panic
            assert!(!result.unwrap()); // Should be false
        }
        
        println!("Fuzz testing completed");
        Ok(())
    }
    
    // Timing analysis testing
    fn timing_analysis_testing() -> Result<()> {
        let keypair = KeyPair::generate()?;
        let message = b"Timing test message";
        let valid_signature = keypair.sign(message)?;
        let invalid_signature = [0u8; 64];
        
        // Measure timing for valid vs invalid signatures
        let mut valid_times = Vec::new();
        let mut invalid_times = Vec::new();
        
        for _ in 0..1000 {
            let start = std::time::Instant::now();
            let _ = keypair.verify_bytes(&valid_signature.as_bytes(), message)?;
            valid_times.push(start.elapsed());
            
            let start = std::time::Instant::now();
            let _ = keypair.verify_bytes(&invalid_signature, message);
            invalid_times.push(start.elapsed());
        }
        
        let avg_valid = valid_times.iter().sum::<std::time::Duration>() / valid_times.len() as u32;
        let avg_invalid = invalid_times.iter().sum::<std::time::Duration>() / invalid_times.len() as u32;
        
        println!("Timing analysis: valid={:?}, invalid={:?}", avg_valid, avg_invalid);
        
        // Check for timing differences (should be minimal)
        let timing_ratio = avg_valid.as_nanos() as f64 / avg_invalid.as_nanos() as f64;
        if (timing_ratio - 1.0).abs() > 0.1 {
            println!("Warning: Significant timing difference detected: {:.2}", timing_ratio);
        }
        
        Ok(())
    }
    
    test_known_vectors()?;
    fuzz_testing()?;
    timing_analysis_testing()?;
    
    Ok(())
}

use lib_crypto::*;

fn penetration_testing() -> Result<()> {
    // Test malformed inputs
    fn test_malformed_inputs() -> Result<()> {
        let keypair = KeyPair::generate()?;
        
        // Test various malformed signatures
        let malformed_sigs = vec![
            vec![], // Empty
            vec![0u8; 32], // Too short
            vec![0u8; 128], // Too long
            vec![0xFF; 64], // All ones
        ];
        
        for malformed_sig in malformed_sigs {
            let result = keypair.verify_bytes(&malformed_sig, b"test");
            // Should handle gracefully, not panic
            match result {
                Ok(false) => println!("Malformed signature correctly rejected"),
                Err(_) => println!("Malformed signature caused error (expected)"),
                Ok(true) => return Err(anyhow::anyhow!("Malformed signature incorrectly accepted!")),
            }
        }
        
        println!("Malformed input testing passed");
        Ok(())
    }
    
    // Test resource exhaustion attacks
    fn test_resource_exhaustion() -> Result<()> {
        // Test with very large messages (DoS prevention)
        let large_message = vec![0u8; 10_000_000]; // 10MB
        let keypair = KeyPair::generate()?;
        
        let start_time = std::time::Instant::now();
        let result = keypair.sign(&large_message);
        let elapsed = start_time.elapsed();
        
        match result {
            Ok(_) => {
                println!("Large message signed in {:?}", elapsed);
                if elapsed > std::time::Duration::from_secs(10) {
                    println!("Warning: Signing took too long, potential DoS vector");
                }
            },
            Err(_) => println!("Large message signing rejected (good)"),
        }
        
        println!("Resource exhaustion testing completed");
        Ok(())
    }
    
    test_malformed_inputs()?;
    test_resource_exhaustion()?;
    
    Ok(())
}

use lib_crypto::*;

fn standards_compliance() -> Result<()> {
    // FIPS 140-2 Level 2 equivalent practices
    fn fips_compliance_check() -> Result<()> {
        // Use FIPS-approved algorithms
        let keypair = KeyPair::generate()?; // Ed25519 (FIPS approved)
        
        // Use approved random number generators
        let random_bytes = random::secure_random_bytes::<32>()?; // Uses OS entropy
        
        // Use approved hash functions
        let hash = hashing::blake3_hash(b"FIPS compliance test")?;
        
        // Key zeroization (FIPS requirement)
        let mut sensitive_key = random_bytes;
        sensitive_key.zeroize();
        
        println!("FIPS 140-2 compliance practices implemented");
        Ok(())
    }
    
    // Common Criteria EAL4+ practices
    fn common_criteria_compliance() -> Result<()> {
        // Security target: Protect cryptographic keys
        // TOE (Target of Evaluation): lib-crypto library
        
        // CC requirement: Cryptographic key generation
        let keypair = KeyPair::generate()?; // Uses certified RNG
        
        // CC requirement: Cryptographic operation
        let message = b"Common Criteria evaluation message";
        let signature = keypair.sign(message)?; // Certified algorithm
        
        // CC requirement: Key destruction
        drop(keypair); // Secure key destruction
        
        println!("Common Criteria compliance practices implemented");
        Ok(())
    }
    
    fips_compliance_check()?;
    common_criteria_compliance()?;
    
    Ok(())
}

use lib_crypto::*;

struct SecurityMonitor {
    failed_verifications: u64,
    timing_anomalies: u64,
    resource_exhaustion_attempts: u64,
    last_audit: std::time::SystemTime,
}

impl SecurityMonitor {
    fn new() -> Self {
        Self {
            failed_verifications: 0,
            timing_anomalies: 0,
            resource_exhaustion_attempts: 0,
            last_audit: std::time::SystemTime::now(),
        }
    }
    
    fn record_verification_failure(&mut self) {
        self.failed_verifications += 1;
        
        // Alert on suspicious patterns
        if self.failed_verifications > 100 {
            self.security_alert("High verification failure rate detected");
        }
    }
    
    fn record_timing_anomaly(&mut self, expected: std::time::Duration, actual: std::time::Duration) {
        if actual > expected * 2 {
            self.timing_anomalies += 1;
            
            if self.timing_anomalies > 10 {
                self.security_alert("Timing attack pattern detected");
            }
        }
    }
    
    fn security_alert(&self, message: &str) {
        println!(" SECURITY ALERT: {}", message);
        // In production: send to SIEM, log to secure audit trail, notify security team
    }
    
    fn generate_security_report(&self) -> String {
        format!(
            "Security Report:\n\
             - Failed verifications: {}\n\
             - Timing anomalies: {}\n\
             - Resource exhaustion attempts: {}\n\
             - Report generated: {:?}",
            self.failed_verifications,
            self.timing_anomalies, 
            self.resource_exhaustion_attempts,
            std::time::SystemTime::now()
        )
    }
}

fn security_monitoring() -> Result<()> {
    let mut monitor = SecurityMonitor::new();
    
    // Simulate security events
    monitor.record_verification_failure();
    monitor.record_timing_anomaly(
        std::time::Duration::from_millis(1),
        std::time::Duration::from_millis(5)
    );
    
    println!("{}", monitor.generate_security_report());
    
    Ok(())
}

use lib_crypto::*;

// RECOMMENDED: Post-quantum secure algorithms
fn secure_algorithm_selection() -> Result<()> {
    // Post-quantum signatures (quantum-resistant)
    let pq_keypair = post_quantum::DilithiumKeyPair::generate()?;
    
    // Classical signatures for current security (faster)
    let classical_keypair = KeyPair::generate(); // Ed25519
    
    // Hybrid encryption (quantum-resistant KEM + classical symmetric)
    let message = b"Highly sensitive data requiring post-quantum protection";
    let encrypted = pq_keypair.encrypt(message, b"metadata")?;
    
    // Use strongest available hashing
    let hash = hashing::blake3_hash(b"data to hash")?; // BLAKE3 > SHA-3 > SHA-2
    
    println!("Selected quantum-resistant algorithms");
    Ok(())
}

// AVOID: Deprecated or weak algorithms
fn avoid_weak_algorithms() {
    // DON'T USE: RSA (vulnerable to quantum attacks)
    // DON'T USE: ECDSA with weak curves (secp256k1 without post-quantum)
    // DON'T USE: SHA-1 (cryptographically broken)
    // DON'T USE: MD5 (completely broken)
    // DON'T USE: DES, 3DES (too short key lengths)
}

use lib_crypto::{KeyPair, random::SecureRng};
use zeroize::{Zeroize, ZeroizeOnDrop};

#[derive(ZeroizeOnDrop)]
struct SecureKeyMaterial {
    private_key: [u8; 32],
    derived_keys: Vec<[u8; 32]>,
}

fn secure_key_management() -> Result<()> {
    // Generate keys with secure randomness
    let keypair = KeyPair::generate()?; // Uses system entropy
    
    // Derive keys properly with salt
    let master_key = random::secure_random_bytes::<32>()?;
    let salt = random::secure_random_bytes::<32>()?;
    let derived_key = hashing::blake3_derive_key(&master_key, &salt);
    
    // Store sensitive material in secure containers
    let mut secure_material = SecureKeyMaterial {
        private_key: master_key,
        derived_keys: vec![derived_key],
    };
    
    // ... use keys for cryptographic operations ...
    
    // Explicitly zero sensitive data
    secure_material.zeroize();
    
    println!("Secure key management implemented");
    Ok(())
}

// Key rotation strategy
fn key_rotation_strategy() -> Result<()> {
    struct KeyManager {
        current_key: KeyPair,
        previous_key: Option<KeyPair>,
        rotation_interval: std::time::Duration,
        last_rotation: std::time::SystemTime,
    }
    
    impl KeyManager {
        fn should_rotate(&self) -> bool {
            self.last_rotation.elapsed().unwrap_or_default() > self.rotation_interval
        }
        
        fn rotate_keys(&mut self) -> Result<()> {
            // Archive old key for decryption
            self.previous_key = Some(self.current_key.clone());
            
            // Generate new key for encryption
            self.current_key = KeyPair::generate()?;
            self.last_rotation = std::time::SystemTime::now();
            
            println!("Keys rotated successfully");
            Ok(())
        }
    }
    
    let mut key_manager = KeyManager {
        current_key: KeyPair::generate()?,
        previous_key: None,
        rotation_interval: std::time::Duration::from_secs(86400 * 30), // 30 days
        last_rotation: std::time::SystemTime::now(),
    };
    
    if key_manager.should_rotate() {
        key_manager.rotate_keys()?;
    }
    
    Ok(())
}

use lib_crypto::{KeyPair, symmetric::*};

fn secure_communication() -> Result<()> {
    // Perfect Forward Secrecy
    fn establish_ephemeral_channel() -> Result<([u8; 32], Vec<u8>)> {
        // Generate ephemeral keypair for each session
        let ephemeral_keypair = KeyPair::generate()?;
        
        // Perform key exchange (simplified)
        let encapsulation = ephemeral_keypair.encapsulate()?;
        let shared_secret = encapsulation.shared_secret;
        
        // Delete ephemeral private key immediately after use
        drop(ephemeral_keypair);
        
        Ok((shared_secret, encapsulation.ciphertext))
    }
    
    let (session_key, kem_ciphertext) = establish_ephemeral_channel()?;
    
    // Authenticated encryption with associated data
    let plaintext = b"Confidential message requiring integrity";
    let associated_data = b"session_id=12345,timestamp=1640995200";
    let nonce = random::secure_random_bytes::<12>()?;
    
    let ciphertext = encrypt_chacha20poly1305(
        plaintext,
        associated_data,
        &session_key,
        &nonce
    )?;
    
    // Secure transmission format: [KEM_CT][NONCE][AEAD_CT]
    let mut secure_message = Vec::new();
    secure_message.extend_from_slice(&kem_ciphertext);
    secure_message.extend_from_slice(&nonce);
    secure_message.extend_from_slice(&ciphertext);
    
    println!("Secure communication established with forward secrecy");
    Ok(())
}

use lib_crypto::{KeyPair, random::SecureRng};

fn side_channel_protection() -> Result<()> {
    let keypair = KeyPair::generate()?;
    let message = b"Message requiring side-channel protection";
    
    // Constant-time operations (built into Ed25519)
    let signature = keypair.sign(message)?; // Constant-time signing
    
    // Timing attack mitigation with random delays
    let mut rng = SecureRng::new()?;
    let jitter_us = rng.gen_range(100..1000); // 0.1-1ms random delay
    std::thread::sleep(std::time::Duration::from_micros(jitter_us));
    
    // Memory access pattern obfuscation
    let dummy_operations = rng.gen_range(5..15);
    for _ in 0..dummy_operations {
        let _ = random::secure_random_bytes::<32>()?; // Dummy computation
    }
    
    // Power analysis resistance (algorithmic)
    let verification = keypair.verify(&signature, message)?;
    
    // Cache timing attack mitigation
    let cache_noise_iterations = rng.gen_range(10..50);
    let mut cache_noise = vec![0u8; 4096 * cache_noise_iterations];
    rng.fill_bytes(&mut cache_noise);
    
    println!("Side-channel protections applied");
    Ok(())
}

use lib_crypto::{KeyPair, hashing::blake3_hash};

fn network_attack_protection() -> Result<()> {
    // Replay attack prevention
    struct ReplayProtection {
        nonce_cache: std::collections::HashSet<[u8; 32]>,
        window_start: u64,
        window_size: u64,
    }
    
    impl ReplayProtection {
        fn verify_nonce(&mut self, nonce: &[u8; 32], timestamp: u64) -> bool {
            // Check if nonce is within time window
            if timestamp < self.window_start || 
               timestamp > self.window_start + self.window_size {
                return false;
            }
            
            // Check if nonce has been used before
            if self.nonce_cache.contains(nonce) {
                return false; // Replay attack detected
            }
            
            self.nonce_cache.insert(*nonce);
            true
        }
        
        fn cleanup_old_nonces(&mut self, current_time: u64) {
            if current_time > self.window_start + self.window_size {
                self.nonce_cache.clear();
                self.window_start = current_time;
            }
        }
    }
    
    // Message authentication with sequence numbers
    struct MessageAuth {
        keypair: KeyPair,
        sequence_number: u64,
    }
    
    impl MessageAuth {
        fn sign_message(&mut self, message: &[u8]) -> Result<Vec<u8>> {
            // Include sequence number in signed data
            let mut signed_data = Vec::new();
            signed_data.extend_from_slice(message);
            signed_data.extend_from_slice(&self.sequence_number.to_le_bytes());
            
            let signature = self.keypair.sign(&signed_data)?;
            self.sequence_number += 1;
            
            // Format: [SEQ][MESSAGE][SIGNATURE]
            let mut authenticated_message = Vec::new();
            authenticated_message.extend_from_slice(&self.sequence_number.to_le_bytes());
            authenticated_message.extend_from_slice(message);
            authenticated_message.extend_from_slice(&signature.as_bytes());
            
            Ok(authenticated_message)
        }
    }
    
    println!("Network attack protections implemented");
    Ok(())
}

use lib_crypto::{post_quantum::*, classical::*};

fn quantum_attack_preparation() -> Result<()> {
    // Hybrid cryptosystem (classical + post-quantum)
    struct HybridCrypto {
        classical_keypair: KeyPair,      // Fast, current security
        pq_keypair: DilithiumKeyPair,    // Quantum-resistant
    }
    
    impl HybridCrypto {
        fn new() -> Result<Self> {
            Ok(Self {
                classical_keypair: KeyPair::generate()?,
                pq_keypair: DilithiumKeyPair::generate()?,
            })
        }
        
        fn hybrid_sign(&self, message: &[u8]) -> Result<Vec<u8>> {
            // Sign with both algorithms
            let classical_sig = self.classical_keypair.sign(message)?;
            let pq_sig = self.pq_keypair.sign(message)?;
            
            // Combine signatures
            let mut hybrid_signature = Vec::new();
            hybrid_signature.extend_from_slice(&classical_sig.as_bytes());
            hybrid_signature.extend_from_slice(&pq_sig.as_bytes());
            
            Ok(hybrid_signature)
        }
        
        fn hybrid_verify(&self, signature: &[u8], message: &[u8]) -> Result<bool> {
            // Split combined signature
            let classical_sig = &signature[..64]; // Ed25519 is 64 bytes
            let pq_sig = &signature[64..];
            
            // Verify both signatures
            let classical_valid = self.classical_keypair.verify_bytes(classical_sig, message)?;
            let pq_valid = self.pq_keypair.verify_bytes(pq_sig, message)?;
            
            // Both must be valid
            Ok(classical_valid && pq_valid)
        }
    }
    
    let hybrid_crypto = HybridCrypto::new()?;
    let message = b"Message protected against quantum attacks";
    
    let hybrid_signature = hybrid_crypto.hybrid_sign(message)?;
    let is_valid = hybrid_crypto.hybrid_verify(&hybrid_signature, message)?;
    
    println!("Hybrid quantum-resistant signature: {}", is_valid);
    Ok(())
}

use lib_crypto::*;

fn secure_input_validation() -> Result<()> {
    // Validate all cryptographic inputs
    fn validate_signature_input(signature: &[u8], message: &[u8], pubkey: &[u8]) -> Result<()> {
        // Check signature length
        if signature.len() != 64 {
            return Err(anyhow::anyhow!("Invalid signature length: {}", signature.len()));
        }
        
        // Check public key length
        if pubkey.len() != 32 {
            return Err(anyhow::anyhow!("Invalid public key length: {}", pubkey.len()));
        }
        
        // Check message isn't empty (application-specific)
        if message.is_empty() {
            return Err(anyhow::anyhow!("Empty message not allowed"));
        }
        
        // Check message size limits (prevent DoS)
        if message.len() > 1_000_000 { // 1MB limit
            return Err(anyhow::anyhow!("Message too large: {} bytes", message.len()));
        }
        
        Ok(())
    }
    
    // Sanitize and validate all inputs
    let raw_signature = [0u8; 64]; // Simulated input
    let raw_message = b"Test message";
    let raw_pubkey = [1u8; 32];
    
    validate_signature_input(&raw_signature, raw_message, &raw_pubkey)?;
    
    // Use type-safe interfaces when possible
    let keypair = KeyPair::generate()?;
    let message = b"Type-safe message signing";
    let signature = keypair.sign(message)?; // Type-safe, validated internally
    
    println!("Input validation implemented");
    Ok(())
}

use lib_crypto::*;

fn secure_error_handling() -> Result<()> {
    let keypair = KeyPair::generate()?;
    let message = b"Test message for error handling";
    let signature = keypair.sign(message)?;
    
    // Don't leak information through error messages
    fn safe_verification(sig: &[u8], msg: &[u8], pubkey: &[u8]) -> Result<bool> {
        match verify_signature_bytes(sig, msg, pubkey) {
            Ok(result) => Ok(result),
            Err(_) => {
                // Generic error message (don't reveal why verification failed)
                println!("Verification failed"); // Same message for all failures
                Ok(false)
            }
        }
    }
    
    // Constant-time error responses
    fn constant_time_verification(sig: &[u8], msg: &[u8], pubkey: &[u8]) -> Result<bool> {
        let start_time = std::time::Instant::now();
        
        let result = verify_signature_bytes(sig, msg, pubkey).unwrap_or(false);
        
        // Ensure minimum processing time to prevent timing attacks
        let min_duration = std::time::Duration::from_millis(10);
        let elapsed = start_time.elapsed();
        if elapsed < min_duration {
            std::thread::sleep(min_duration - elapsed);
        }
        
        Ok(result)
    }
    
    // Audit security-relevant errors
    fn audit_security_events(event: &str, details: &str) {
        let timestamp = std::time::SystemTime::now()
            .duration_since(std::time::UNIX_EPOCH)
            .unwrap()
            .as_secs();
        
        // Log to secure audit trail (not shown here)
        println!("SECURITY_EVENT: {} - {} at {}", event, details, timestamp);
    }
    
    // Test error handling
    let wrong_signature = [0u8; 64];
    match safe_verification(&wrong_signature, message, &keypair.public_key().as_bytes()) {
        Ok(false) => audit_security_events("VERIFICATION_FAILED", "Invalid signature"),
        _ => audit_security_events("UNEXPECTED_ERROR", "Verification error handling"),
    }
    
    println!("Secure error handling implemented");
    Ok(())
}

use lib_crypto::*;
use zeroize::{Zeroize, ZeroizeOnDrop};

// Secure memory containers
#[derive(ZeroizeOnDrop)]
struct SecureBuffer {
    data: Vec<u8>,
    size: usize,
}

impl SecureBuffer {
    fn new(size: usize) -> Self {
        Self {
            data: vec![0u8; size],
            size,
        }
    }
    
    fn write(&mut self, offset: usize, data: &[u8]) -> Result<()> {
        if offset + data.len() > self.size {
            return Err(anyhow::anyhow!("Buffer overflow prevented"));
        }
        self.data[offset..offset + data.len()].copy_from_slice(data);
        Ok(())
    }
    
    fn read(&self, offset: usize, len: usize) -> Result<&[u8]> {
        if offset + len > self.size {
            return Err(anyhow::anyhow!("Buffer overread prevented"));
        }
        Ok(&self.data[offset..offset + len])
    }
}

fn memory_security() -> Result<()> {
    // Use secure buffers for sensitive data
    let mut secure_key_buffer = SecureBuffer::new(32);
    let key_material = random::secure_random_bytes::<32>()?;
    secure_key_buffer.write(0, &key_material)?;
    
    // Prevent memory dumps of sensitive data
    use mlock::*; // Hypothetical memory locking crate
    let sensitive_data = random::secure_random_bytes::<64>()?;
    // mlock(&sensitive_data)?; // Lock memory page to prevent swapping
    
    // Overwrite sensitive data multiple times
    fn secure_overwrite(buffer: &mut [u8]) {
        // Multiple pass overwrite (DoD 5220.22-M standard)
        buffer.fill(0x00);
        buffer.fill(0xFF);
        buffer.fill(0x00);
        
        // Random overwrite pass
        use rand::RngCore;
        rand::rngs::OsRng.fill_bytes(buffer);
        
        // Final zero pass
        buffer.zeroize();
    }
    
    // Stack allocation for temporary sensitive data
    {
        let temp_key = random::secure_random_bytes::<32>()?;
        // Use temp_key...
        // Automatically cleared when leaving scope
    }
    
    println!("Memory security measures implemented");
    Ok(())
}

use lib_crypto::*;

fn cryptographic_testing() -> Result<()> {
    // Test vector validation
    fn test_known_vectors() -> Result<()> {
        // Test with known good inputs/outputs
        let test_vectors = [
            (b"test message 1", "expected_signature_hex"),
            (b"test message 2", "expected_signature_hex"),
        ];
        
        let keypair = KeyPair::from_seed(&[1u8; 32])?; // Deterministic for testing
        
        for (message, expected_sig_hex) in &test_vectors {
            let signature = keypair.sign(message)?;
            let sig_hex = hex::encode(signature.as_bytes());
            
            if &sig_hex != expected_sig_hex {
                return Err(anyhow::anyhow!("Test vector failed for message: {:?}", message));
            }
        }
        
        println!("All test vectors passed");
        Ok(())
    }
    
    // Fuzzing inputs
    fn fuzz_testing() -> Result<()> {
        let keypair = KeyPair::generate()?;
        let valid_message = b"Valid message";
        let valid_signature = keypair.sign(valid_message)?;
        
        // Fuzz signature bytes
        for i in 0..64 {
            let mut fuzzed_sig = valid_signature.clone();
            fuzzed_sig.as_mut()[i] ^= 0xFF; // Flip bits
            
            // Should always return false, never panic
            let result = keypair.verify(&fuzzed_sig, valid_message);
            assert!(result.is_ok()); // Should not panic
            assert!(!result.unwrap()); // Should be false
        }
        
        println!("Fuzz testing completed");
        Ok(())
    }
    
    // Timing analysis testing
    fn timing_analysis_testing() -> Result<()> {
        let keypair = KeyPair::generate()?;
        let message = b"Timing test message";
        let valid_signature = keypair.sign(message)?;
        let invalid_signature = [0u8; 64];
        
        // Measure timing for valid vs invalid signatures
        let mut valid_times = Vec::new();
        let mut invalid_times = Vec::new();
        
        for _ in 0..1000 {
            let start = std::time::Instant::now();
            let _ = keypair.verify_bytes(&valid_signature.as_bytes(), message)?;
            valid_times.push(start.elapsed());
            
            let start = std::time::Instant::now();
            let _ = keypair.verify_bytes(&invalid_signature, message);
            invalid_times.push(start.elapsed());
        }
        
        let avg_valid = valid_times.iter().sum::<std::time::Duration>() / valid_times.len() as u32;
        let avg_invalid = invalid_times.iter().sum::<std::time::Duration>() / invalid_times.len() as u32;
        
        println!("Timing analysis: valid={:?}, invalid={:?}", avg_valid, avg_invalid);
        
        // Check for timing differences (should be minimal)
        let timing_ratio = avg_valid.as_nanos() as f64 / avg_invalid.as_nanos() as f64;
        if (timing_ratio - 1.0).abs() > 0.1 {
            println!("Warning: Significant timing difference detected: {:.2}", timing_ratio);
        }
        
        Ok(())
    }
    
    test_known_vectors()?;
    fuzz_testing()?;
    timing_analysis_testing()?;
    
    Ok(())
}

use lib_crypto::*;

fn penetration_testing() -> Result<()> {
    // Test malformed inputs
    fn test_malformed_inputs() -> Result<()> {
        let keypair = KeyPair::generate()?;
        
        // Test various malformed signatures
        let malformed_sigs = vec![
            vec![], // Empty
            vec![0u8; 32], // Too short
            vec![0u8; 128], // Too long
            vec![0xFF; 64], // All ones
        ];
        
        for malformed_sig in malformed_sigs {
            let result = keypair.verify_bytes(&malformed_sig, b"test");
            // Should handle gracefully, not panic
            match result {
                Ok(false) => println!("Malformed signature correctly rejected"),
                Err(_) => println!("Malformed signature caused error (expected)"),
                Ok(true) => return Err(anyhow::anyhow!("Malformed signature incorrectly accepted!")),
            }
        }
        
        println!("Malformed input testing passed");
        Ok(())
    }
    
    // Test resource exhaustion attacks
    fn test_resource_exhaustion() -> Result<()> {
        // Test with very large messages (DoS prevention)
        let large_message = vec![0u8; 10_000_000]; // 10MB
        let keypair = KeyPair::generate()?;
        
        let start_time = std::time::Instant::now();
        let result = keypair.sign(&large_message);
        let elapsed = start_time.elapsed();
        
        match result {
            Ok(_) => {
                println!("Large message signed in {:?}", elapsed);
                if elapsed > std::time::Duration::from_secs(10) {
                    println!("Warning: Signing took too long, potential DoS vector");
                }
            },
            Err(_) => println!("Large message signing rejected (good)"),
        }
        
        println!("Resource exhaustion testing completed");
        Ok(())
    }
    
    test_malformed_inputs()?;
    test_resource_exhaustion()?;
    
    Ok(())
}

use lib_crypto::*;

fn standards_compliance() -> Result<()> {
    // FIPS 140-2 Level 2 equivalent practices
    fn fips_compliance_check() -> Result<()> {
        // Use FIPS-approved algorithms
        let keypair = KeyPair::generate()?; // Ed25519 (FIPS approved)
        
        // Use approved random number generators
        let random_bytes = random::secure_random_bytes::<32>()?; // Uses OS entropy
        
        // Use approved hash functions
        let hash = hashing::blake3_hash(b"FIPS compliance test")?;
        
        // Key zeroization (FIPS requirement)
        let mut sensitive_key = random_bytes;
        sensitive_key.zeroize();
        
        println!("FIPS 140-2 compliance practices implemented");
        Ok(())
    }
    
    // Common Criteria EAL4+ practices
    fn common_criteria_compliance() -> Result<()> {
        // Security target: Protect cryptographic keys
        // TOE (Target of Evaluation): lib-crypto library
        
        // CC requirement: Cryptographic key generation
        let keypair = KeyPair::generate()?; // Uses certified RNG
        
        // CC requirement: Cryptographic operation
        let message = b"Common Criteria evaluation message";
        let signature = keypair.sign(message)?; // Certified algorithm
        
        // CC requirement: Key destruction
        drop(keypair); // Secure key destruction
        
        println!("Common Criteria compliance practices implemented");
        Ok(())
    }
    
    fips_compliance_check()?;
    common_criteria_compliance()?;
    
    Ok(())
}

use lib_crypto::*;

struct SecurityMonitor {
    failed_verifications: u64,
    timing_anomalies: u64,
    resource_exhaustion_attempts: u64,
    last_audit: std::time::SystemTime,
}

impl SecurityMonitor {
    fn new() -> Self {
        Self {
            failed_verifications: 0,
            timing_anomalies: 0,
            resource_exhaustion_attempts: 0,
            last_audit: std::time::SystemTime::now(),
        }
    }
    
    fn record_verification_failure(&mut self) {
        self.failed_verifications += 1;
        
        // Alert on suspicious patterns
        if self.failed_verifications > 100 {
            self.security_alert("High verification failure rate detected");
        }
    }
    
    fn record_timing_anomaly(&mut self, expected: std::time::Duration, actual: std::time::Duration) {
        if actual > expected * 2 {
            self.timing_anomalies += 1;
            
            if self.timing_anomalies > 10 {
                self.security_alert("Timing attack pattern detected");
            }
        }
    }
    
    fn security_alert(&self, message: &str) {
        println!(" SECURITY ALERT: {}", message);
        // In production: send to SIEM, log to secure audit trail, notify security team
    }
    
    fn generate_security_report(&self) -> String {
        format!(
            "Security Report:\n\
             - Failed verifications: {}\n\
             - Timing anomalies: {}\n\
             - Resource exhaustion attempts: {}\n\
             - Report generated: {:?}",
            self.failed_verifications,
            self.timing_anomalies, 
            self.resource_exhaustion_attempts,
            std::time::SystemTime::now()
        )
    }
}

fn security_monitoring() -> Result<()> {
    let mut monitor = SecurityMonitor::new();
    
    // Simulate security events
    monitor.record_verification_failure();
    monitor.record_timing_anomaly(
        std::time::Duration::from_millis(1),
        std::time::Duration::from_millis(5)
    );
    
    println!("{}", monitor.generate_security_report());
    
    Ok(())
}