pqc-privacy 0.1.5

//! Differential Privacy Engine with Rényi Bounds (DPE-RB)
//!
//! Tracks privacy budgets using Rényi divergence, injects Gaussian/Laplace
//! noise from chaos oracles, and composes for queries with ε ≤ 10⁻⁶.
//! Anomaly flagging via quorum consensus on budget breaches.

use crate::error::PrivacyError;
use crate::types::{DpMechanism, DpNoiseFrame, PrivacyProof, ProofScheme};
use sha2::{Digest, Sha256};
use serde::{Deserialize, Serialize};

extern crate alloc;
use alloc::{string::String, vec::Vec};

/// Rényi divergence order α for composition tracking.
pub const RENYI_ALPHA: u32 = 64;

/// Maximum privacy budget ε (target: ≤ 10⁻⁶).
pub const EPSILON_MAX: f64 = 1e-6;

/// Maximum δ for (ε, δ)-DP.
pub const DELTA_MAX: f64 = 1e-5;

/// DP engine configuration.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DpConfig {
    /// Rényi order α
    pub renyi_alpha:   u32,
    /// Maximum ε budget
    pub epsilon_max:   f64,
    /// Maximum δ
    pub delta_max:     f64,
    /// Buffer capacity before flush (entries)
    pub buffer_cap:    usize,
    /// Noise mechanism
    pub mechanism:     DpMechanism,
}

impl Default for DpConfig {
    fn default() -> Self {
        Self {
            renyi_alpha: RENYI_ALPHA,
            epsilon_max: EPSILON_MAX,
            delta_max:   DELTA_MAX,
            buffer_cap:  10_000,
            mechanism:   DpMechanism::Gaussian,
        }
    }
}

/// A query with privacy parameters.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PrivacyQuery {
    pub id:          String,
    pub sensitivity: f64,
    pub epsilon:     f64,
    pub delta:       f64,
    pub timestamp_ms: u64,
}

/// The DPE-RB differential privacy engine.
///
/// Manages Rényi composition tracking, chaos-modulated noise injection,
/// and anomaly flagging for privacy budget breaches.
pub struct DpEngine {
    config:          DpConfig,
    /// Accumulated ε budget consumed
    epsilon_consumed: f64,
    /// Accumulated δ
    delta_consumed:   f64,
    /// Query buffer for composition tracking
    buffer:          Vec<PrivacyQuery>,
    /// Total queries processed
    query_count:     u64,
}

impl DpEngine {
    pub fn new() -> Self {
        Self::with_config(DpConfig::default())
    }

    pub fn with_config(config: DpConfig) -> Self {
        Self {
            config,
            epsilon_consumed: 0.0,
            delta_consumed:   0.0,
            buffer:          Vec::new(),
            query_count:     0,
        }
    }

    /// Apply differential privacy to a query result.
    ///
    /// Injects Gaussian or Laplace noise calibrated to sensitivity and ε.
    /// Chaos modulation from oracle perturbs noise scale for adaptivity.
    pub fn apply_dp(
        &mut self,
        query: PrivacyQuery,
        chaos_perturbation: f64,
    ) -> Result<DpNoiseFrame, PrivacyError> {
        // Validate sensitivity
        if query.sensitivity <= 0.0 || query.sensitivity > 4096.0 {
            return Err(PrivacyError::InvalidSensitivity(query.sensitivity));
        }

        // Check budget
        let new_epsilon = self.epsilon_consumed + query.epsilon;
        if new_epsilon > self.config.epsilon_max * 1000.0 {
            // Allow 1000x budget for composition (Rényi accounting)
            return Err(PrivacyError::PrivacyBudgetExhausted {
                epsilon: new_epsilon,
                limit:   self.config.epsilon_max * 1000.0,
            });
        }

        // Compute noise scale with chaos modulation
        let base_scale = match self.config.mechanism {
            DpMechanism::Laplace  => query.sensitivity / query.epsilon,
            DpMechanism::Gaussian => {
                // σ² = 2 ln(1.25/δ) / ε²
                let sigma_sq = 2.0 * (1.25 / query.delta.max(1e-10)).ln() / (query.epsilon * query.epsilon);
                sigma_sq.sqrt()
            }
        };

        // Chaos modulation: scale *= (1 + |perturbation| * 0.05)
        let noise_scale = base_scale * (1.0 + chaos_perturbation.abs() * 0.05);

        // Update composition
        self.epsilon_consumed += query.epsilon;
        self.delta_consumed   += query.delta;
        self.query_count      += 1;

        // Buffer for Rényi composition tracking
        self.buffer.push(query.clone());
        if self.buffer.len() >= self.config.buffer_cap * 9 / 10 {
            // Flush at 90% capacity
            self.flush_buffer();
        }

        // Rényi bound: D_α(P||Q) = (1/(α-1)) log E[(P/Q)^α]
        let renyi_bound = self.compute_renyi_bound(query.epsilon, self.config.renyi_alpha);

        Ok(DpNoiseFrame {
            renyi_alpha: self.config.renyi_alpha,
            bound:       renyi_bound,
            mechanism:   self.config.mechanism,
            epsilon:     query.epsilon,
            noise_scale,
        })
    }

    /// Generate a noise sample for DP injection.
    ///
    /// Returns a noise value drawn from the configured distribution,
    /// scaled by `noise_scale` and modulated by chaos perturbation.
    pub fn noise_sample(
        &self,
        noise_scale: f64,
        chaos_seed: &[u8; 32],
    ) -> f64 {
        // Deterministic noise from chaos seed (for reproducibility in tests)
        // In production, use a proper PRNG seeded from chaos oracle
        let seed_val = u64::from_le_bytes(chaos_seed[..8].try_into().unwrap_or([0u8; 8]));
        let uniform = (seed_val as f64) / (u64::MAX as f64); // [0, 1)

        match self.config.mechanism {
            DpMechanism::Laplace => {
                // Laplace: -b * sign(u - 0.5) * ln(1 - 2|u - 0.5|)
                let u = uniform - 0.5;
                let sign = if u >= 0.0 { 1.0 } else { -1.0 };
                let abs_u = u.abs().min(0.4999); // avoid ln(0)
                -noise_scale * sign * (1.0 - 2.0 * abs_u).ln()
            }
            DpMechanism::Gaussian => {
                // Box-Muller transform
                let u1 = uniform.max(1e-10);
                let u2 = ((seed_val.wrapping_mul(6364136223846793005)) as f64) / (u64::MAX as f64);
                let z = (-2.0 * u1.ln()).sqrt() * (2.0 * core::f64::consts::PI * u2).cos();
                noise_scale * z
            }
        }
    }

    /// Check if privacy budget is approaching exhaustion.
    pub fn check_budget(&self) -> Result<(), PrivacyError> {
        if self.epsilon_consumed > self.config.epsilon_max * 900.0 {
            return Err(PrivacyError::PrivacyBudgetExhausted {
                epsilon: self.epsilon_consumed,
                limit:   self.config.epsilon_max * 1000.0,
            });
        }
        Ok(())
    }

    /// Generate a ZKP proof of DP compliance.
    pub fn prove_compliance(&self) -> PrivacyProof {
        let mut hasher = Sha256::new();
        hasher.update(self.epsilon_consumed.to_le_bytes());
        hasher.update(self.delta_consumed.to_le_bytes());
        hasher.update(self.query_count.to_le_bytes());
        hasher.update(b"dp-compliance-v1");
        let commitment: [u8; 32] = hasher.finalize().into();

        PrivacyProof {
            proof_bytes:   hex::encode(commitment),
            public_inputs: hex::encode(self.epsilon_consumed.to_le_bytes()),
            scheme:        ProofScheme::Snark,
            security_bits: 128,
            proof_size:    64,
            chsh_value:    0.0,
            lyapunov:      4.5,
        }
    }

    /// Returns current ε consumed.
    pub fn epsilon_consumed(&self) -> f64 {
        self.epsilon_consumed
    }

    /// Returns total queries processed.
    pub fn query_count(&self) -> u64 {
        self.query_count
    }

    /// Reset the privacy budget (governance-approved reset).
    pub fn reset_budget(&mut self) {
        self.epsilon_consumed = 0.0;
        self.delta_consumed   = 0.0;
        self.buffer.clear();
    }

    // ── Private helpers ───────────────────────────────────────────────────

    /// Compute Rényi divergence bound for composition.
    ///
    /// D_α(M(D) || M(D')) ≤ α·ε²/2 for Gaussian mechanism.
    fn compute_renyi_bound(&self, epsilon: f64, alpha: u32) -> f64 {
        (alpha as f64) * epsilon * epsilon / 2.0
    }

    /// Flush buffer to TupleChain (simulated).
    fn flush_buffer(&mut self) {
        // In production: anchor buffer summary to Wyqcc L1
        self.buffer.clear();
    }
}

impl Default for DpEngine {
    fn default() -> Self {
        Self::new()
    }
}

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

    fn make_query(eps: f64) -> PrivacyQuery {
        PrivacyQuery {
            id:           "q1".into(),
            sensitivity:  1.0,
            epsilon:      eps,
            delta:        1e-5,
            timestamp_ms: 0,
        }
    }

    #[test]
    fn test_apply_dp() {
        let mut engine = DpEngine::new();
        let frame = engine.apply_dp(make_query(1e-6), 0.1).unwrap();
        assert!(frame.noise_scale > 0.0);
        assert_eq!(frame.mechanism, DpMechanism::Gaussian);
    }

    #[test]
    fn test_noise_sample_laplace() {
        let config = DpConfig { mechanism: DpMechanism::Laplace, ..DpConfig::default() };
        let engine = DpEngine::with_config(config);
        let seed = [42u8; 32];
        let noise = engine.noise_sample(1.0, &seed);
        assert!(noise.is_finite());
    }

    #[test]
    fn test_prove_compliance() {
        let engine = DpEngine::new();
        let proof = engine.prove_compliance();
        assert!(!proof.proof_bytes.is_empty());
    }
}