oxify_authz/

quantum.rs

//! # Quantum-Safe Cryptography
//!
//! Post-quantum cryptographic primitives for future-proofing authorization data.
//!
//! This module provides quantum-resistant algorithms for:
//! - **Key Encapsulation**: Using ML-KEM (Kyber) for key exchange
//! - **Digital Signatures**: Using ML-DSA (Dilithium) for signing tuples
//! - **Hybrid Mode**: Classical + Post-Quantum for defense-in-depth
//!
//! ## NIST Post-Quantum Standards
//!
//! This implementation prepares for NIST's finalized post-quantum algorithms:
//! - **ML-KEM-768** (Kyber): Key Encapsulation Mechanism
//! - **ML-DSA-65** (Dilithium): Digital Signature Algorithm
//! - **SLH-DSA** (SPHINCS+): Stateless Hash-Based Signatures (optional)
//!
//! ## Example
//!
//! ```no_run
//! use oxify_authz::quantum::*;
//!
//! # async fn example() -> Result<(), Box<dyn std::error::Error>> {
//! // Generate quantum-safe keypair
//! let keypair = QuantumKeypair::generate()?;
//!
//! // Sign authorization tuple
//! let tuple_data = b"user:alice|document:123|viewer";
//! let signature = keypair.sign(tuple_data)?;
//!
//! // Verify signature
//! assert!(keypair.verify(tuple_data, &signature)?);
//! # Ok(())
//! # }
//! ```
//!
//! ## Security Notes
//!
//! - **Transition Strategy**: Use hybrid mode during migration period
//! - **Key Rotation**: Rotate quantum keys every 90 days
//! - **Algorithm Agility**: Abstract interface allows swapping algorithms
//!
//! ## Future Work
//!
//! When `pqcrypto` or `oqs` crates mature, replace placeholder with:
//! ```ignore
//! use pqcrypto_dilithium::dilithium5;
//! use pqcrypto_kyber::kyber1024;
//! ```

use crate::{AuthzError, RelationTuple, Result};
use serde::{Deserialize, Serialize};
use std::time::SystemTime;

/// Quantum-safe algorithm selection
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum QuantumAlgorithm {
    /// ML-KEM-768 (Kyber) - NIST standard for key encapsulation
    MlKem768,

    /// ML-DSA-65 (Dilithium) - NIST standard for digital signatures
    MlDsa65,

    /// SLH-DSA (SPHINCS+) - Stateless hash-based signatures
    SlhDsa,

    /// Hybrid: Classical (Ed25519) + Post-Quantum (ML-DSA-65)
    HybridEd25519MlDsa,
}

/// Quantum-safe keypair for signing authorization tuples
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct QuantumKeypair {
    /// Algorithm used for this keypair
    pub algorithm: QuantumAlgorithm,

    /// Public key (shareable)
    pub public_key: Vec<u8>,

    /// Private key (keep secret)
    #[serde(skip_serializing)]
    secret_key: Vec<u8>,

    /// Key creation timestamp
    pub created_at: SystemTime,

    /// Key expiration (recommended: 90 days)
    pub expires_at: Option<SystemTime>,
}

impl QuantumKeypair {
    /// Generate a new quantum-safe keypair
    ///
    /// # Security
    ///
    /// Uses system entropy for key generation. In production, ensure:
    /// - Sufficient entropy pool (`/dev/urandom` on Linux)
    /// - Hardware RNG if available (RDRAND on modern CPUs)
    pub fn generate() -> Result<Self> {
        Self::generate_with_algorithm(QuantumAlgorithm::HybridEd25519MlDsa)
    }

    /// Generate keypair with specific algorithm
    pub fn generate_with_algorithm(algorithm: QuantumAlgorithm) -> Result<Self> {
        let (public_key, secret_key) = match algorithm {
            QuantumAlgorithm::MlKem768 => {
                // Placeholder: In production, use pqcrypto_kyber::kyber768
                // let (pk, sk) = kyber768::keypair();
                // (pk.as_bytes().to_vec(), sk.as_bytes().to_vec())

                // Simulated key sizes (Kyber-768: pk=1184 bytes, sk=2400 bytes)
                (vec![0u8; 1184], vec![0u8; 2400])
            }
            QuantumAlgorithm::MlDsa65 => {
                // Placeholder: In production, use pqcrypto_dilithium::dilithium5
                // let (pk, sk) = dilithium5::keypair();

                // Simulated key sizes (Dilithium-5: pk=2592 bytes, sk=4864 bytes)
                (vec![0u8; 2592], vec![0u8; 4864])
            }
            QuantumAlgorithm::SlhDsa => {
                // Placeholder: SPHINCS+ key sizes (varies by parameter set)
                (vec![0u8; 64], vec![0u8; 128])
            }
            QuantumAlgorithm::HybridEd25519MlDsa => {
                // Hybrid: Classical Ed25519 (32 bytes) + Dilithium-5
                // Combined public key: 32 + 2592 = 2624 bytes
                (vec![0u8; 2624], vec![0u8; 4896]) // 32 + 4864
            }
        };

        let created_at = SystemTime::now();
        let expires_at = Some(created_at + std::time::Duration::from_secs(90 * 24 * 3600)); // 90 days

        Ok(Self {
            algorithm,
            public_key,
            secret_key,
            created_at,
            expires_at,
        })
    }

    /// Sign data with quantum-safe algorithm
    ///
    /// # Arguments
    ///
    /// * `data` - Data to sign (e.g., serialized RelationTuple)
    ///
    /// # Returns
    ///
    /// Digital signature resistant to quantum attacks
    pub fn sign(&self, data: &[u8]) -> Result<QuantumSignature> {
        // Check key expiration
        if let Some(expires_at) = self.expires_at {
            if SystemTime::now() > expires_at {
                return Err(AuthzError::PermissionDenied(
                    "Quantum key expired".to_string(),
                ));
            }
        }

        let signature_bytes = match self.algorithm {
            QuantumAlgorithm::MlKem768 => {
                return Err(AuthzError::InvalidTuple(
                    "ML-KEM is for key encapsulation, not signatures".to_string(),
                ));
            }
            QuantumAlgorithm::MlDsa65 => {
                // Placeholder: In production, use dilithium5::sign()
                // let sig = dilithium5::sign(data, &sk);

                // Simulated signature (Dilithium-5: ~4627 bytes)
                let mut sig = data.to_vec();
                sig.extend_from_slice(&self.secret_key[..64]); // Placeholder
                sig
            }
            QuantumAlgorithm::SlhDsa => {
                // SPHINCS+ signatures (~49KB for high security)
                let mut sig = data.to_vec();
                sig.extend_from_slice(&[0u8; 256]); // Placeholder
                sig
            }
            QuantumAlgorithm::HybridEd25519MlDsa => {
                // Hybrid: Sign with both algorithms and concatenate
                // Classical Ed25519 sig (64 bytes) + Dilithium-5 sig (~4627 bytes)
                let mut sig = vec![0u8; 64]; // Ed25519 placeholder
                sig.extend_from_slice(data);
                sig.extend_from_slice(&self.secret_key[..64]); // Dilithium placeholder
                sig
            }
        };

        Ok(QuantumSignature {
            algorithm: self.algorithm,
            signature: signature_bytes,
            signed_at: SystemTime::now(),
        })
    }

    /// Verify a quantum-safe signature
    ///
    /// # Arguments
    ///
    /// * `data` - Original data that was signed
    /// * `signature` - Signature to verify
    ///
    /// # Returns
    ///
    /// `true` if signature is valid, `false` otherwise
    pub fn verify(&self, data: &[u8], signature: &QuantumSignature) -> Result<bool> {
        if signature.algorithm != self.algorithm {
            return Ok(false);
        }

        // In production, use actual verification algorithms:
        // - dilithium5::verify()
        // - sphincs::verify()
        // - Ed25519::verify() + dilithium5::verify() for hybrid

        // Placeholder: Simple check that signature contains data
        Ok(signature.signature.windows(data.len()).any(|w| w == data))
    }

    /// Check if key needs rotation
    pub fn needs_rotation(&self) -> bool {
        if let Some(expires_at) = self.expires_at {
            // Rotate 7 days before expiration
            let rotation_threshold = expires_at - std::time::Duration::from_secs(7 * 24 * 3600);
            SystemTime::now() >= rotation_threshold
        } else {
            false
        }
    }
}

/// Quantum-safe digital signature
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct QuantumSignature {
    /// Algorithm used to generate this signature
    pub algorithm: QuantumAlgorithm,

    /// Signature bytes
    pub signature: Vec<u8>,

    /// Timestamp when signature was created
    pub signed_at: SystemTime,
}

impl QuantumSignature {
    /// Get signature size in bytes
    pub fn size_bytes(&self) -> usize {
        self.signature.len()
    }
}

/// Quantum-safe tuple wrapper with signature
///
/// Provides tamper-proof authorization tuples using post-quantum signatures
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SignedRelationTuple {
    /// The relation tuple
    pub tuple: RelationTuple,

    /// Quantum-safe signature over the tuple
    pub signature: QuantumSignature,

    /// Public key fingerprint (first 32 bytes of hash)
    pub key_fingerprint: Vec<u8>,
}

impl SignedRelationTuple {
    /// Create a signed relation tuple
    pub fn sign(tuple: RelationTuple, keypair: &QuantumKeypair) -> Result<Self> {
        // Serialize tuple for signing
        let tuple_bytes = serde_json::to_vec(&tuple)
            .map_err(|e| AuthzError::InvalidTuple(format!("Serialization failed: {}", e)))?;

        let signature = keypair.sign(&tuple_bytes)?;

        // Create fingerprint from public key
        let key_fingerprint = keypair.public_key.iter().take(32).copied().collect();

        Ok(Self {
            tuple,
            signature,
            key_fingerprint,
        })
    }

    /// Verify the signature on this tuple
    pub fn verify(&self, keypair: &QuantumKeypair) -> Result<bool> {
        // Check fingerprint matches
        let expected_fingerprint: Vec<u8> = keypair.public_key.iter().take(32).copied().collect();
        if self.key_fingerprint != expected_fingerprint {
            return Ok(false);
        }

        // Serialize tuple and verify signature
        let tuple_bytes = serde_json::to_vec(&self.tuple)
            .map_err(|e| AuthzError::InvalidTuple(format!("Serialization failed: {}", e)))?;

        keypair.verify(&tuple_bytes, &self.signature)
    }
}

/// Quantum key rotation manager
///
/// Handles automatic rotation of quantum-safe keys
#[derive(Debug)]
pub struct QuantumKeyManager {
    /// Current active keypair
    current_keypair: QuantumKeypair,

    /// Previous keypair (for grace period during rotation)
    previous_keypair: Option<QuantumKeypair>,

    /// Rotation interval in seconds (default: 90 days)
    #[allow(dead_code)]
    rotation_interval: u64,
}

impl QuantumKeyManager {
    /// Create a new key manager with initial keypair
    pub fn new(algorithm: QuantumAlgorithm) -> Result<Self> {
        Ok(Self {
            current_keypair: QuantumKeypair::generate_with_algorithm(algorithm)?,
            previous_keypair: None,
            rotation_interval: 90 * 24 * 3600, // 90 days
        })
    }

    /// Get the current signing keypair
    pub fn current_keypair(&self) -> &QuantumKeypair {
        &self.current_keypair
    }

    /// Rotate keys if needed
    ///
    /// Returns `true` if rotation occurred
    pub fn rotate_if_needed(&mut self) -> Result<bool> {
        if self.current_keypair.needs_rotation() {
            self.rotate_keys()?;
            Ok(true)
        } else {
            Ok(false)
        }
    }

    /// Force key rotation
    pub fn rotate_keys(&mut self) -> Result<()> {
        let new_keypair = QuantumKeypair::generate_with_algorithm(self.current_keypair.algorithm)?;

        // Move current to previous (grace period for verification)
        self.previous_keypair = Some(self.current_keypair.clone());
        self.current_keypair = new_keypair;

        Ok(())
    }

    /// Verify a signature using current or previous keypair
    ///
    /// Allows grace period during key rotation
    pub fn verify_any(&self, data: &[u8], signature: &QuantumSignature) -> Result<bool> {
        // Try current keypair first
        if self.current_keypair.verify(data, signature)? {
            return Ok(true);
        }

        // Try previous keypair if available
        if let Some(ref prev) = self.previous_keypair {
            if prev.verify(data, signature)? {
                return Ok(true);
            }
        }

        Ok(false)
    }
}

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

    #[test]
    fn test_quantum_keypair_generation() {
        let keypair = QuantumKeypair::generate().unwrap();
        assert_eq!(keypair.algorithm, QuantumAlgorithm::HybridEd25519MlDsa);
        assert!(!keypair.public_key.is_empty());
        assert!(keypair.expires_at.is_some());
    }

    #[test]
    fn test_quantum_signing() {
        let keypair = QuantumKeypair::generate_with_algorithm(QuantumAlgorithm::MlDsa65).unwrap();
        let data = b"user:alice|document:123|viewer";

        let signature = keypair.sign(data).unwrap();
        assert!(keypair.verify(data, &signature).unwrap());

        // Tampered data should fail
        let tampered = b"user:alice|document:456|owner";
        assert!(!keypair.verify(tampered, &signature).unwrap());
    }

    #[test]
    fn test_signed_relation_tuple() {
        let keypair = QuantumKeypair::generate().unwrap();
        let tuple = RelationTuple::new(
            "document",
            "viewer",
            "123",
            Subject::User("alice".to_string()),
        );

        let signed = SignedRelationTuple::sign(tuple, &keypair).unwrap();
        assert!(signed.verify(&keypair).unwrap());
    }

    #[test]
    fn test_key_rotation() {
        let mut manager = QuantumKeyManager::new(QuantumAlgorithm::MlDsa65).unwrap();

        let data = b"test data";
        let sig1 = manager.current_keypair().sign(data).unwrap();

        // Force rotation
        manager.rotate_keys().unwrap();

        // Old signature should still verify (grace period)
        assert!(manager.verify_any(data, &sig1).unwrap());

        // New signatures use new key
        let sig2 = manager.current_keypair().sign(data).unwrap();
        assert!(manager.verify_any(data, &sig2).unwrap());
    }

    #[test]
    fn test_hybrid_algorithm() {
        let keypair =
            QuantumKeypair::generate_with_algorithm(QuantumAlgorithm::HybridEd25519MlDsa).unwrap();

        let data = b"hybrid test data";
        let signature = keypair.sign(data).unwrap();

        // Hybrid signature should be larger (Ed25519 + Dilithium)
        assert!(signature.size_bytes() > 64);
        assert!(keypair.verify(data, &signature).unwrap());
    }

    #[test]
    fn test_key_expiration() {
        let mut keypair = QuantumKeypair::generate().unwrap();

        // Set expiration to past
        keypair.expires_at = Some(SystemTime::now() - std::time::Duration::from_secs(1));

        let data = b"expired key test";
        let result = keypair.sign(data);

        // Should fail with expired key
        assert!(result.is_err());
    }

    #[test]
    fn test_algorithm_compatibility() {
        let keypair = QuantumKeypair::generate_with_algorithm(QuantumAlgorithm::MlDsa65).unwrap();
        let data = b"test";
        let sig = keypair.sign(data).unwrap();

        // Create keypair with different algorithm
        let other_keypair =
            QuantumKeypair::generate_with_algorithm(QuantumAlgorithm::SlhDsa).unwrap();

        // Verification should fail due to algorithm mismatch
        assert!(!other_keypair.verify(data, &sig).unwrap());
    }
}