optirs_core/privacy/federated_privacy/
config.rs

1// Configuration structures for federated privacy algorithms
2
3use super::super::DifferentialPrivacyConfig;
4use std::time::Duration;
5
6/// Federated privacy configuration
7#[derive(Debug, Clone)]
8pub struct FederatedPrivacyConfig {
9    /// Base differential privacy config
10    pub base_config: DifferentialPrivacyConfig,
11
12    /// Number of participating clients per round
13    pub clients_per_round: usize,
14
15    /// Total number of clients in federation
16    pub total_clients: usize,
17
18    /// Client sampling strategy
19    pub sampling_strategy: ClientSamplingStrategy,
20
21    /// Secure aggregation settings
22    pub secure_aggregation: SecureAggregationConfig,
23
24    /// Privacy amplification settings
25    pub amplification_config: AmplificationConfig,
26
27    /// Cross-device privacy settings
28    pub cross_device_config: CrossDeviceConfig,
29
30    /// Federated composition method
31    pub composition_method: FederatedCompositionMethod,
32
33    /// Trust model
34    pub trust_model: TrustModel,
35
36    /// Communication privacy
37    pub communication_privacy: CommunicationPrivacyConfig,
38}
39
40/// Client sampling strategies for federated learning
41#[derive(Debug, Clone, Copy)]
42pub enum ClientSamplingStrategy {
43    /// Uniform random sampling
44    UniformRandom,
45
46    /// Stratified sampling based on data distribution
47    Stratified,
48
49    /// Importance sampling based on client importance
50    ImportanceSampling,
51
52    /// Poisson sampling for theoretical guarantees
53    PoissonSampling,
54
55    /// Fair sampling ensuring client diversity
56    FairSampling,
57}
58
59/// Secure aggregation configuration
60#[derive(Debug, Clone)]
61pub struct SecureAggregationConfig {
62    /// Enable secure aggregation
63    pub enabled: bool,
64
65    /// Minimum number of clients for aggregation
66    pub min_clients: usize,
67
68    /// Maximum number of dropouts tolerated
69    pub max_dropouts: usize,
70
71    /// Masking vector dimension
72    pub masking_dimension: usize,
73
74    /// Random seed sharing method
75    pub seed_sharing: SeedSharingMethod,
76
77    /// Quantization bits for compressed aggregation
78    pub quantization_bits: Option<u8>,
79
80    /// Enable differential privacy on aggregated result
81    pub aggregate_dp: bool,
82}
83
84/// Privacy amplification configuration
85#[derive(Debug, Clone)]
86pub struct AmplificationConfig {
87    /// Enable privacy amplification analysis
88    pub enabled: bool,
89
90    /// Subsampling amplification factor
91    pub subsampling_factor: f64,
92
93    /// Shuffling amplification (if applicable)
94    pub shuffling_enabled: bool,
95
96    /// Multi-round amplification
97    pub multi_round_amplification: bool,
98
99    /// Heterogeneous client amplification
100    pub heterogeneous_amplification: bool,
101}
102
103/// Cross-device privacy configuration
104#[derive(Debug, Clone, Default)]
105pub struct CrossDeviceConfig {
106    /// User-level privacy guarantees
107    pub user_level_privacy: bool,
108
109    /// Device clustering for privacy
110    pub device_clustering: bool,
111
112    /// Temporal privacy across rounds
113    pub temporal_privacy: bool,
114
115    /// Geographic privacy considerations
116    pub geographic_privacy: bool,
117
118    /// Demographic privacy protection
119    pub demographic_privacy: bool,
120}
121
122/// Federated composition methods
123#[derive(Debug, Clone, Copy, Default)]
124pub enum FederatedCompositionMethod {
125    /// Basic composition
126    Basic,
127
128    /// Advanced composition with amplification
129    AdvancedComposition,
130
131    /// Moments accountant for federated setting
132    #[default]
133    FederatedMomentsAccountant,
134
135    /// Renyi differential privacy
136    RenyiDP,
137
138    /// Zero-concentrated differential privacy
139    ZCDP,
140}
141
142/// Trust models for federated learning
143#[derive(Debug, Clone, Copy)]
144pub enum TrustModel {
145    /// Honest-but-curious clients
146    HonestButCurious,
147
148    /// Semi-honest with some malicious clients
149    SemiHonest,
150
151    /// Byzantine fault tolerance
152    Byzantine,
153
154    /// Fully malicious adversary
155    Malicious,
156}
157
158/// Communication privacy configuration
159#[derive(Debug, Clone)]
160pub struct CommunicationPrivacyConfig {
161    /// Encrypt communications
162    pub encryption_enabled: bool,
163
164    /// Use anonymous communication channels
165    pub anonymous_channels: bool,
166
167    /// Add communication noise
168    pub communication_noise: bool,
169
170    /// Traffic analysis protection
171    pub traffic_analysis_protection: bool,
172
173    /// Advanced threat modeling configuration
174    pub threat_modeling: AdvancedThreatModelingConfig,
175
176    /// Cross-silo federated learning configuration
177    pub cross_silo_config: Option<CrossSiloFederatedConfig>,
178}
179
180/// Advanced threat modeling configuration for comprehensive security analysis
181#[derive(Debug, Clone, Default)]
182pub struct AdvancedThreatModelingConfig {
183    /// Enable advanced threat analysis
184    pub enabled: bool,
185
186    /// Adversarial capabilities modeling
187    pub adversarial_capabilities: AdversarialCapabilities,
188
189    /// Attack surface analysis
190    pub attack_surface_analysis: AttackSurfaceConfig,
191
192    /// Threat intelligence integration
193    pub threat_intelligence: ThreatIntelligenceConfig,
194
195    /// Risk assessment framework
196    pub risk_assessment: RiskAssessmentConfig,
197
198    /// Countermeasure effectiveness evaluation
199    pub countermeasure_evaluation: CountermeasureEvaluationConfig,
200}
201
202/// Adversarial capabilities in federated learning environments
203#[derive(Debug, Clone)]
204pub struct AdversarialCapabilities {
205    /// Computational resources available to adversary
206    pub computational_resources: ComputationalThreatLevel,
207
208    /// Network access and control capabilities
209    pub network_capabilities: NetworkThreatCapabilities,
210
211    /// Data access and manipulation capabilities
212    pub data_capabilities: DataThreatCapabilities,
213
214    /// Model and algorithm knowledge
215    pub algorithmic_knowledge: AlgorithmicKnowledgeLevel,
216
217    /// Collusion potential among malicious clients
218    pub collusion_potential: CollusionThreatLevel,
219
220    /// Persistence and adaptability of attacks
221    pub attack_persistence: AttackPersistenceLevel,
222}
223
224/// Attack surface configuration for comprehensive analysis
225#[derive(Debug, Clone, Default)]
226pub struct AttackSurfaceConfig {
227    /// Client-side attack vectors
228    pub client_attack_vectors: ClientAttackVectors,
229
230    /// Server-side attack vectors
231    pub server_attack_vectors: ServerAttackVectors,
232
233    /// Communication channel vulnerabilities
234    pub communication_vulnerabilities: CommunicationVulnerabilities,
235
236    /// Aggregation phase vulnerabilities
237    pub aggregation_vulnerabilities: AggregationVulnerabilities,
238
239    /// Privacy mechanism vulnerabilities
240    pub privacy_mechanism_vulnerabilities: PrivacyMechanismVulnerabilities,
241}
242
243/// Threat intelligence integration for real-time threat assessment
244#[derive(Debug, Clone, Default)]
245pub struct ThreatIntelligenceConfig {
246    /// Enable threat intelligence feeds
247    pub enabled: bool,
248
249    /// Real-time threat monitoring
250    pub real_time_monitoring: bool,
251
252    /// Threat signature database
253    pub signature_database: ThreatSignatureDatabase,
254
255    /// Anomaly detection for novel threats
256    pub anomaly_detection: AnomalyDetectionConfig,
257
258    /// Threat correlation and analysis
259    pub threat_correlation: ThreatCorrelationConfig,
260}
261
262/// Risk assessment framework for quantitative security analysis
263#[derive(Debug, Clone)]
264pub struct RiskAssessmentConfig {
265    /// Risk assessment methodology
266    pub methodology: RiskAssessmentMethodology,
267
268    /// Risk tolerance levels
269    pub risk_tolerance: RiskToleranceLevels,
270
271    /// Impact assessment criteria
272    pub impact_assessment: ImpactAssessmentCriteria,
273
274    /// Likelihood estimation methods
275    pub likelihood_estimation: LikelihoodEstimationMethods,
276
277    /// Risk mitigation strategies
278    pub mitigation_strategies: RiskMitigationStrategies,
279}
280
281/// Effectiveness metrics for countermeasure evaluation
282#[derive(Debug, Clone, Default)]
283pub struct EffectivenessMetrics {
284    /// Accuracy of threat detection
285    pub detection_accuracy: f64,
286    /// False positive rate
287    pub false_positive_rate: f64,
288    /// False negative rate
289    pub false_negative_rate: f64,
290    /// Response time metrics
291    pub response_times: Vec<f64>,
292}
293
294/// Cost-benefit analysis configuration
295#[derive(Debug, Clone, Default)]
296pub struct CostBenefitAnalysisConfig {
297    /// Implementation costs
298    pub implementation_costs: Vec<f64>,
299    /// Operational costs
300    pub operational_costs: Vec<f64>,
301    /// Benefit metrics
302    pub benefits: Vec<f64>,
303    /// ROI calculation methods
304    pub roi_methods: Vec<String>,
305}
306
307/// Dynamic adaptation configuration
308#[derive(Debug, Clone, Default)]
309pub struct DynamicAdaptationConfig {
310    /// Adaptation triggers
311    pub triggers: Vec<String>,
312    /// Adaptation strategies
313    pub strategies: Vec<String>,
314    /// Learning rate for adaptation
315    pub learning_rate: f64,
316    /// Minimum adaptation threshold
317    pub min_threshold: f64,
318}
319
320/// Countermeasure optimization configuration
321#[derive(Debug, Clone, Default)]
322pub struct CountermeasureOptimizationConfig {
323    /// Optimization algorithms
324    pub algorithms: Vec<String>,
325    /// Target metrics
326    pub target_metrics: Vec<String>,
327    /// Constraints
328    pub constraints: Vec<String>,
329    /// Optimization frequency
330    pub frequency: String,
331}
332
333/// Countermeasure effectiveness evaluation framework
334#[derive(Debug, Clone, Default)]
335pub struct CountermeasureEvaluationConfig {
336    /// Effectiveness metrics
337    pub effectiveness_metrics: EffectivenessMetrics,
338
339    /// Cost-benefit analysis
340    pub cost_benefit_analysis: CostBenefitAnalysisConfig,
341
342    /// Dynamic adaptation based on threat landscape
343    pub dynamic_adaptation: DynamicAdaptationConfig,
344
345    /// Countermeasure optimization
346    pub optimization: CountermeasureOptimizationConfig,
347}
348
349/// Data marketplace configuration
350#[derive(Debug, Clone)]
351pub struct DataMarketplaceConfig {
352    /// Enable data marketplace
353    pub enabled: bool,
354    /// Pricing models
355    pub pricing_models: Vec<String>,
356    /// Quality metrics
357    pub quality_metrics: Vec<String>,
358    /// Access controls
359    pub access_controls: Vec<String>,
360}
361
362/// Regulatory compliance configuration
363#[derive(Debug, Clone)]
364pub struct RegulatoryComplianceConfig {
365    /// Applicable regulations
366    pub regulations: Vec<String>,
367    /// Compliance checks
368    pub compliance_checks: Vec<String>,
369    /// Reporting requirements
370    pub reporting_requirements: Vec<String>,
371    /// Audit trails
372    pub audit_trails: bool,
373}
374
375/// Audit and accountability configuration
376#[derive(Debug, Clone)]
377pub struct AuditAccountabilityConfig {
378    /// Audit logging
379    pub audit_logging: bool,
380    /// Accountability mechanisms
381    pub accountability_mechanisms: Vec<String>,
382    /// Verification methods
383    pub verification_methods: Vec<String>,
384    /// Compliance tracking
385    pub compliance_tracking: bool,
386}
387
388/// Trust establishment methods
389#[derive(Debug, Clone)]
390pub struct TrustEstablishmentMethods {
391    /// Certification authorities
392    pub certification_authorities: Vec<String>,
393    /// Reputation systems
394    pub reputation_systems: Vec<String>,
395    /// Verification protocols
396    pub verification_protocols: Vec<String>,
397}
398
399/// Trust verification mechanisms
400#[derive(Debug, Clone)]
401pub struct TrustVerificationMechanisms {
402    /// Verification methods
403    pub methods: Vec<String>,
404    /// Validation frequency
405    pub frequency: String,
406    /// Trust thresholds
407    pub thresholds: Vec<f64>,
408}
409
410/// Organization reputation system
411#[derive(Debug, Clone)]
412pub struct OrganizationReputationSystem {
413    /// Reputation metrics
414    pub metrics: Vec<String>,
415    /// Scoring algorithms
416    pub scoring_algorithms: Vec<String>,
417    /// Update frequencies
418    pub update_frequencies: Vec<String>,
419}
420
421/// Trust lifecycle management
422#[derive(Debug, Clone)]
423pub struct TrustLifecycleManagement {
424    /// Trust establishment phases
425    pub establishment_phases: Vec<String>,
426    /// Trust maintenance procedures
427    pub maintenance_procedures: Vec<String>,
428    /// Trust recovery mechanisms
429    pub recovery_mechanisms: Vec<String>,
430    /// Trust degradation triggers
431    pub degradation_triggers: Vec<String>,
432}
433
434/// Data governance configuration
435#[derive(Debug, Clone)]
436pub struct DataGovernanceConfig {
437    /// Data classification
438    pub classification: Vec<String>,
439    /// Access policies
440    pub access_policies: Vec<String>,
441    /// Quality standards
442    pub quality_standards: Vec<String>,
443    /// Retention policies
444    pub retention_policies: Vec<String>,
445}
446
447/// Privacy agreement configuration
448#[derive(Debug, Clone)]
449pub struct PrivacyAgreementConfig {
450    /// Agreement templates
451    pub templates: Vec<String>,
452    /// Negotiation protocols
453    pub negotiation_protocols: Vec<String>,
454    /// Enforcement mechanisms
455    pub enforcement_mechanisms: Vec<String>,
456    /// Compliance monitoring
457    pub compliance_monitoring: bool,
458}
459
460/// Data classification configuration
461#[derive(Debug, Clone)]
462pub struct DataClassificationConfig {
463    /// Classification schemes
464    pub schemes: Vec<String>,
465    /// Sensitivity levels
466    pub sensitivity_levels: Vec<String>,
467    /// Labeling rules
468    pub labeling_rules: Vec<String>,
469}
470
471/// Data lineage configuration
472#[derive(Debug, Clone)]
473pub struct DataLineageConfig {
474    /// Tracking methods
475    pub tracking_methods: Vec<String>,
476    /// Provenance recording
477    pub provenance_recording: bool,
478    /// Audit trails
479    pub audit_trails: bool,
480}
481
482/// Data quality assurance configuration
483#[derive(Debug, Clone)]
484pub struct DataQualityAssuranceConfig {
485    /// Quality metrics
486    pub metrics: Vec<String>,
487    /// Validation rules
488    pub validation_rules: Vec<String>,
489    /// Monitoring frequency
490    pub monitoring_frequency: String,
491}
492
493/// Data retention policies
494#[derive(Debug, Clone)]
495pub struct DataRetentionPolicies {
496    /// Retention periods
497    pub retention_periods: Vec<String>,
498    /// Disposal methods
499    pub disposal_methods: Vec<String>,
500    /// Archive policies
501    pub archive_policies: Vec<String>,
502}
503
504/// Cross-silo federated learning configuration for enterprise scenarios
505#[derive(Debug, Clone)]
506pub struct CrossSiloFederatedConfig {
507    /// Enable cross-silo federated learning
508    pub enabled: bool,
509
510    /// Organization trust levels and relationships
511    pub organization_trust: OrganizationTrustConfig,
512
513    /// Data governance and compliance
514    pub data_governance: DataGovernanceConfig,
515
516    /// Inter-organizational privacy agreements
517    pub privacy_agreements: PrivacyAgreementConfig,
518
519    /// Federated data marketplaces
520    pub data_marketplace: DataMarketplaceConfig,
521
522    /// Regulatory compliance framework
523    pub regulatory_compliance: RegulatoryComplianceConfig,
524
525    /// Audit and accountability mechanisms
526    pub audit_accountability: AuditAccountabilityConfig,
527}
528
529/// Organization trust configuration for cross-silo scenarios
530#[derive(Debug, Clone)]
531pub struct OrganizationTrustConfig {
532    /// Trust establishment methods
533    pub trust_establishment: TrustEstablishmentMethods,
534
535    /// Trust verification mechanisms
536    pub trust_verification: TrustVerificationMechanisms,
537
538    /// Reputation systems for organizations
539    pub reputation_system: OrganizationReputationSystem,
540
541    /// Trust degradation and recovery
542    pub trust_lifecycle: TrustLifecycleManagement,
543}
544
545// Supporting enums and types for the advanced configurations
546
547#[derive(Debug, Clone, Copy)]
548pub enum ComputationalThreatLevel {
549    Limited,     // Individual attacker with limited resources
550    Moderate,    // Small organization or group
551    Substantial, // Large organization or nation-state
552    Unlimited,   // Theoretical unlimited computational resources
553}
554
555#[derive(Debug, Clone, Default)]
556pub struct NetworkThreatCapabilities {
557    /// Can intercept communications
558    pub can_intercept: bool,
559    /// Can modify communications
560    pub can_modify: bool,
561    /// Can inject malicious communications
562    pub can_inject: bool,
563    /// Can perform traffic analysis
564    pub can_analyze_traffic: bool,
565    /// Can conduct timing attacks
566    pub can_timing_attack: bool,
567    /// Can perform network-level denial of service
568    pub can_dos: bool,
569}
570
571#[derive(Debug, Clone, Default)]
572pub struct DataThreatCapabilities {
573    /// Can access training data
574    pub can_access_training_data: bool,
575    /// Can modify training data
576    pub can_modify_training_data: bool,
577    /// Can inject poisoned data
578    pub can_inject_poisoned_data: bool,
579    /// Can perform membership inference
580    pub can_membership_inference: bool,
581    /// Can extract model parameters
582    pub can_extract_parameters: bool,
583    /// Can perform gradient inversion
584    pub can_gradient_inversion: bool,
585}
586
587#[derive(Debug, Clone, Copy)]
588pub enum AlgorithmicKnowledgeLevel {
589    BlackBox, // No knowledge of algorithms
590    GrayBox,  // Partial knowledge
591    WhiteBox, // Full algorithm knowledge
592    Adaptive, // Can adapt based on observations
593}
594
595#[derive(Debug, Clone, Copy)]
596pub enum CollusionThreatLevel {
597    None,        // No collusion
598    Limited,     // Small number of colluding clients
599    Substantial, // Significant fraction colluding
600    Majority,    // Majority collusion attack
601}
602
603#[derive(Debug, Clone, Copy)]
604pub enum AttackPersistenceLevel {
605    OneTime,      // Single attack attempt
606    Intermittent, // Sporadic attacks
607    Persistent,   // Continuous attack pressure
608    Adaptive,     // Evolving attack strategies
609}
610
611#[derive(Debug, Clone, Default)]
612pub struct ClientAttackVectors {
613    /// Model poisoning attacks
614    pub model_poisoning: bool,
615    /// Data poisoning attacks
616    pub data_poisoning: bool,
617    /// Gradient manipulation
618    pub gradient_manipulation: bool,
619    /// Local model extraction
620    pub local_model_extraction: bool,
621    /// Client impersonation
622    pub client_impersonation: bool,
623}
624
625#[derive(Debug, Clone, Default)]
626pub struct ServerAttackVectors {
627    /// Server compromise scenarios
628    pub server_compromise: bool,
629    /// Malicious aggregation
630    pub malicious_aggregation: bool,
631    /// Model backdoor injection
632    pub backdoor_injection: bool,
633    /// Privacy budget manipulation
634    pub budget_manipulation: bool,
635    /// Client discrimination
636    pub client_discrimination: bool,
637}
638
639#[derive(Debug, Clone, Default)]
640pub struct CommunicationVulnerabilities {
641    /// Man-in-the-middle attacks
642    pub mitm_attacks: bool,
643    /// Eavesdropping vulnerabilities
644    pub eavesdropping: bool,
645    /// Replay attacks
646    pub replay_attacks: bool,
647    /// Message injection
648    pub message_injection: bool,
649    /// Communication timing analysis
650    pub timing_analysis: bool,
651}
652
653#[derive(Debug, Clone, Default)]
654pub struct AggregationVulnerabilities {
655    /// Secure aggregation bypass
656    pub secure_aggregation_bypass: bool,
657    /// Aggregation manipulation
658    pub aggregation_manipulation: bool,
659    /// Statistical attacks on aggregation
660    pub statistical_attacks: bool,
661    /// Reconstruction attacks
662    pub reconstruction_attacks: bool,
663}
664
665#[derive(Debug, Clone, Default)]
666pub struct PrivacyMechanismVulnerabilities {
667    /// Differential privacy parameter inference
668    pub dp_parameter_inference: bool,
669    /// Privacy budget exhaustion attacks
670    pub budget_exhaustion: bool,
671    /// Composition attack vulnerabilities
672    pub composition_attacks: bool,
673    /// Auxiliary information attacks
674    pub auxiliary_info_attacks: bool,
675}
676
677#[derive(Debug, Clone, Default)]
678pub struct ThreatSignatureDatabase {
679    /// Known attack patterns
680    pub attack_patterns: Vec<AttackPattern>,
681    /// Threat actor profiles
682    pub threat_actors: Vec<ThreatActorProfile>,
683    /// Vulnerability signatures
684    pub vulnerability_signatures: Vec<VulnerabilitySignature>,
685}
686
687#[derive(Debug, Clone)]
688pub struct AttackPattern {
689    /// Pattern identifier
690    pub id: String,
691    /// Attack description
692    pub description: String,
693    /// Attack indicators
694    pub indicators: Vec<AttackIndicator>,
695    /// Severity level
696    pub severity: ThreatSeverity,
697    /// Mitigation recommendations
698    pub mitigations: Vec<String>,
699}
700
701#[derive(Debug, Clone)]
702pub struct ThreatActorProfile {
703    /// Actor identifier
704    pub id: String,
705    /// Actor capabilities
706    pub capabilities: AdversarialCapabilities,
707    /// Known attack methods
708    pub attack_methods: Vec<String>,
709    /// Targeting preferences
710    pub targeting_preferences: Vec<String>,
711}
712
713#[derive(Debug, Clone)]
714pub struct VulnerabilitySignature {
715    /// Vulnerability identifier
716    pub id: String,
717    /// Affected components
718    pub affected_components: Vec<String>,
719    /// Exploitation indicators
720    pub exploitation_indicators: Vec<String>,
721    /// Severity score
722    pub severity_score: f64,
723}
724
725#[derive(Debug, Clone)]
726pub struct AttackIndicator {
727    /// Indicator type
728    pub indicator_type: IndicatorType,
729    /// Indicator value or pattern
730    pub value: String,
731    /// Confidence level
732    pub confidence: f64,
733}
734
735#[derive(Debug, Clone, Copy)]
736pub enum IndicatorType {
737    NetworkTraffic,
738    GradientPattern,
739    ModelBehavior,
740    PerformanceAnomaly,
741    CommunicationPattern,
742}
743
744#[derive(Debug, Clone, Copy)]
745pub enum ThreatSeverity {
746    Low,
747    Medium,
748    High,
749    Critical,
750}
751
752#[derive(Debug, Clone)]
753pub struct AnomalyDetectionConfig {
754    /// Detection algorithms
755    pub algorithms: Vec<AnomalyDetectionAlgorithm>,
756    /// Detection thresholds
757    pub thresholds: AnomalyThresholds,
758    /// Response actions
759    pub response_actions: AnomalyResponseActions,
760}
761
762#[derive(Debug, Clone, Copy)]
763pub enum AnomalyDetectionAlgorithm {
764    StatisticalBaseline,
765    MachineLearningBased,
766    DeepLearningBased,
767    EnsembleMethods,
768}
769
770#[derive(Debug, Clone)]
771pub struct AnomalyThresholds {
772    /// Statistical significance threshold
773    pub statistical_threshold: f64,
774    /// Confidence threshold for ML-based detection
775    pub confidence_threshold: f64,
776    /// False positive tolerance
777    pub false_positive_rate: f64,
778}
779
780#[derive(Debug, Clone)]
781pub struct AnomalyResponseActions {
782    /// Alert generation
783    pub alert_generation: bool,
784    /// Automatic quarantine
785    pub automatic_quarantine: bool,
786    /// Enhanced monitoring
787    pub enhanced_monitoring: bool,
788    /// Incident escalation
789    pub incident_escalation: bool,
790}
791
792#[derive(Debug, Clone)]
793pub struct ThreatCorrelationConfig {
794    /// Correlation algorithms
795    pub correlation_algorithms: Vec<CorrelationAlgorithm>,
796    /// Temporal correlation window
797    pub temporal_window: Duration,
798    /// Cross-client correlation analysis
799    pub cross_client_correlation: bool,
800}
801
802#[derive(Debug, Clone, Copy)]
803pub enum CorrelationAlgorithm {
804    TemporalPatternMatching,
805    BehavioralProfiling,
806    GraphBasedAnalysis,
807    StatisticalCorrelation,
808}
809
810#[derive(Debug, Clone, Copy)]
811pub enum RiskAssessmentMethodology {
812    QualitativeAssessment,
813    QuantitativeAssessment,
814    SemiQuantitativeAssessment,
815    ScenarioBasedAssessment,
816}
817
818#[derive(Debug, Clone)]
819pub struct RiskToleranceLevels {
820    /// Privacy risk tolerance
821    pub privacy_risk_tolerance: f64,
822    /// Security risk tolerance
823    pub security_risk_tolerance: f64,
824    /// Utility risk tolerance
825    pub utility_risk_tolerance: f64,
826    /// Operational risk tolerance
827    pub operational_risk_tolerance: f64,
828}
829
830#[derive(Debug, Clone)]
831pub struct ImpactAssessmentCriteria {
832    /// Data confidentiality impact
833    pub confidentiality_impact: ImpactLevel,
834    /// Model integrity impact
835    pub integrity_impact: ImpactLevel,
836    /// Service availability impact
837    pub availability_impact: ImpactLevel,
838    /// Regulatory compliance impact
839    pub compliance_impact: ImpactLevel,
840}
841
842#[derive(Debug, Clone, Copy)]
843pub enum ImpactLevel {
844    Low,
845    Medium,
846    High,
847    Critical,
848}
849
850#[derive(Debug, Clone)]
851pub struct LikelihoodEstimationMethods {
852    /// Historical data analysis
853    pub historical_analysis: bool,
854    /// Expert judgment
855    pub expert_judgment: bool,
856    /// Threat modeling
857    pub threat_modeling: bool,
858    /// Simulation-based estimation
859    pub simulation_based: bool,
860}
861
862#[derive(Debug, Clone, Default)]
863pub struct RiskMitigationStrategies {
864    /// Risk avoidance strategies
865    pub avoidance_strategies: Vec<String>,
866    /// Risk mitigation controls
867    pub mitigation_controls: Vec<String>,
868    /// Risk transfer mechanisms
869    pub transfer_mechanisms: Vec<String>,
870    /// Risk acceptance criteria
871    pub acceptance_criteria: Vec<String>,
872}
873
874/// Seed sharing methods for secure aggregation
875#[derive(Debug, Clone, Copy)]
876pub enum SeedSharingMethod {
877    /// Shamir secret sharing
878    ShamirSecretSharing,
879
880    /// Threshold encryption
881    ThresholdEncryption,
882
883    /// Distributed key generation
884    DistributedKeyGeneration,
885}
886
887/// Byzantine-robust aggregation algorithms
888#[derive(Debug, Clone, Copy)]
889pub enum ByzantineRobustMethod {
890    /// Trimmed mean aggregation
891    TrimmedMean { trim_ratio: f64 },
892
893    /// Coordinate-wise median
894    CoordinateWiseMedian,
895
896    /// Krum aggregation
897    Krum { f: usize },
898
899    /// Multi-Krum aggregation
900    MultiKrum { f: usize, m: usize },
901
902    /// Bulyan aggregation
903    Bulyan { f: usize },
904
905    /// Centered clipping
906    CenteredClipping { tau: f64 },
907
908    /// FedAvg with outlier detection
909    FedAvgOutlierDetection { threshold: f64 },
910
911    /// Robust aggregation with reputation
912    ReputationWeighted { reputation_decay: f64 },
913}
914
915/// Personalization strategies for federated learning
916#[derive(Debug, Clone)]
917pub enum PersonalizationStrategy {
918    /// No personalization (standard federated learning)
919    None,
920
921    /// Fine-tuning on local data
922    FineTuning { local_epochs: usize },
923
924    /// Meta-learning based personalization (MAML)
925    MetaLearning { inner_lr: f64, outer_lr: f64 },
926
927    /// Clustered federated learning
928    ClusteredFL { num_clusters: usize },
929
930    /// Federated multi-task learning
931    MultiTask { task_similarity_threshold: f64 },
932
933    /// Personalized layers (some layers personalized, others shared)
934    PersonalizedLayers { personal_layer_indices: Vec<usize> },
935
936    /// Model interpolation
937    ModelInterpolation { interpolation_weight: f64 },
938
939    /// Adaptive personalization
940    Adaptive { adaptation_rate: f64 },
941}
942
943/// Communication compression strategies
944#[derive(Debug, Clone, Copy)]
945pub enum CompressionStrategy {
946    /// No compression
947    None,
948
949    /// Quantization with specified bits
950    Quantization { bits: u8 },
951
952    /// Top-K sparsification
953    TopK { k: usize },
954
955    /// Random sparsification
956    RandomSparsification { sparsity_ratio: f64 },
957
958    /// Error feedback compression
959    ErrorFeedback,
960
961    /// Gradient compression with memory
962    GradientMemory { memory_factor: f64 },
963
964    /// Low-rank approximation
965    LowRank { rank: usize },
966
967    /// Structured compression
968    Structured { structure_type: StructureType },
969}
970
971/// Structure types for compression
972#[derive(Debug, Clone, Copy)]
973pub enum StructureType {
974    Circulant,
975    Toeplitz,
976    Hankel,
977    BlockDiagonal,
978}
979
980/// Continual learning strategies in federated settings
981#[derive(Debug, Clone, Copy)]
982pub enum ContinualLearningStrategy {
983    /// Elastic Weight Consolidation (EWC)
984    EWC { lambda: f64 },
985
986    /// Memory-Aware Synapses (MAS)
987    MAS { lambda: f64 },
988
989    /// Progressive Neural Networks
990    Progressive,
991
992    /// Learning without Forgetting (LwF)
993    LwF { distillation_temperature: f64 },
994
995    /// Gradient Episodic Memory (GEM)
996    GEM { memory_size: usize },
997
998    /// Federated Continual Learning with Memory
999    FedContinual { memory_budget: usize },
1000
1001    /// Task-agnostic continual learning
1002    TaskAgnostic,
1003}
1004
1005/// Advanced federated learning configuration
1006#[derive(Debug, Clone)]
1007pub struct AdvancedFederatedConfig {
1008    /// Byzantine robustness settings
1009    pub byzantine_config: ByzantineRobustConfig,
1010
1011    /// Personalization settings
1012    pub personalization_config: PersonalizationConfig,
1013
1014    /// Adaptive privacy budgeting
1015    pub adaptive_budget_config: AdaptiveBudgetConfig,
1016
1017    /// Communication efficiency settings
1018    pub communication_config: CommunicationConfig,
1019
1020    /// Continual learning settings
1021    pub continual_learning_config: ContinualLearningConfig,
1022
1023    /// Multi-level privacy settings
1024    pub multi_level_privacy: MultiLevelPrivacyConfig,
1025}
1026
1027/// Byzantine robustness configuration
1028#[derive(Debug, Clone)]
1029pub struct ByzantineRobustConfig {
1030    /// Aggregation method
1031    pub method: ByzantineRobustMethod,
1032
1033    /// Expected number of Byzantine clients
1034    pub expected_byzantine_ratio: f64,
1035
1036    /// Enable dynamic Byzantine detection
1037    pub dynamic_detection: bool,
1038
1039    /// Reputation system settings
1040    pub reputation_system: ReputationSystemConfig,
1041
1042    /// Statistical tests for outlier detection
1043    pub statistical_tests: StatisticalTestConfig,
1044}
1045
1046/// Personalization configuration
1047#[derive(Debug, Clone)]
1048pub struct PersonalizationConfig {
1049    /// Personalization strategy
1050    pub strategy: PersonalizationStrategy,
1051
1052    /// Local adaptation parameters
1053    pub local_adaptation: LocalAdaptationConfig,
1054
1055    /// Clustering parameters for clustered FL
1056    pub clustering: ClusteringConfig,
1057
1058    /// Meta-learning parameters
1059    pub meta_learning: MetaLearningConfig,
1060
1061    /// Privacy-preserving personalization
1062    pub privacy_preserving: bool,
1063}
1064
1065/// Adaptive privacy budget configuration
1066#[derive(Debug, Clone)]
1067pub struct AdaptiveBudgetConfig {
1068    /// Enable adaptive budgeting
1069    pub enabled: bool,
1070
1071    /// Budget allocation strategy
1072    pub allocation_strategy: BudgetAllocationStrategy,
1073
1074    /// Dynamic privacy parameters
1075    pub dynamic_privacy: DynamicPrivacyConfig,
1076
1077    /// Client importance weighting
1078    pub importance_weighting: bool,
1079
1080    /// Contextual privacy adjustment
1081    pub contextual_adjustment: ContextualAdjustmentConfig,
1082}
1083
1084/// Communication efficiency configuration
1085#[derive(Debug, Clone)]
1086pub struct CommunicationConfig {
1087    /// Compression strategy
1088    pub compression: CompressionStrategy,
1089
1090    /// Lazy aggregation settings
1091    pub lazy_aggregation: LazyAggregationConfig,
1092
1093    /// Federated dropout settings
1094    pub federated_dropout: FederatedDropoutConfig,
1095
1096    /// Asynchronous update settings
1097    pub async_updates: AsyncUpdateConfig,
1098
1099    /// Bandwidth adaptation
1100    pub bandwidth_adaptation: BandwidthAdaptationConfig,
1101}
1102
1103/// Continual learning configuration
1104#[derive(Debug, Clone)]
1105pub struct ContinualLearningConfig {
1106    /// Continual learning strategy
1107    pub strategy: ContinualLearningStrategy,
1108
1109    /// Memory management settings
1110    pub memory_management: MemoryManagementConfig,
1111
1112    /// Task detection settings
1113    pub task_detection: TaskDetectionConfig,
1114
1115    /// Knowledge transfer settings
1116    pub knowledge_transfer: KnowledgeTransferConfig,
1117
1118    /// Catastrophic forgetting prevention
1119    pub forgetting_prevention: ForgettingPreventionConfig,
1120}
1121
1122/// Multi-level privacy configuration
1123#[derive(Debug, Clone)]
1124pub struct MultiLevelPrivacyConfig {
1125    /// Local differential privacy
1126    pub local_dp: LocalDPConfig,
1127
1128    /// Global differential privacy
1129    pub global_dp: GlobalDPConfig,
1130
1131    /// User-level privacy
1132    pub user_level: UserLevelPrivacyConfig,
1133
1134    /// Hierarchical privacy
1135    pub hierarchical: HierarchicalPrivacyConfig,
1136
1137    /// Context-aware privacy
1138    pub context_aware: ContextAwarePrivacyConfig,
1139}
1140
1141// Supporting configuration structures
1142
1143/// Reputation system configuration
1144#[derive(Debug, Clone)]
1145pub struct ReputationSystemConfig {
1146    pub enabled: bool,
1147    pub initial_reputation: f64,
1148    pub reputation_decay: f64,
1149    pub min_reputation: f64,
1150    pub outlier_penalty: f64,
1151    pub contribution_bonus: f64,
1152}
1153
1154/// Statistical test configuration for outlier detection
1155#[derive(Debug, Clone)]
1156pub struct StatisticalTestConfig {
1157    pub enabled: bool,
1158    pub test_type: StatisticalTestType,
1159    pub significancelevel: f64,
1160    pub window_size: usize,
1161    pub adaptive_threshold: bool,
1162}
1163
1164#[derive(Debug, Clone, Copy)]
1165pub enum StatisticalTestType {
1166    ZScore,
1167    ModifiedZScore,
1168    IQRTest,
1169    GrubbsTest,
1170    ChauventCriterion,
1171}
1172
1173/// Local adaptation configuration
1174#[derive(Debug, Clone)]
1175pub struct LocalAdaptationConfig {
1176    pub adaptation_rate: f64,
1177    pub local_epochs: usize,
1178    pub adaptation_frequency: usize,
1179    pub adaptation_method: AdaptationMethod,
1180    pub regularization_strength: f64,
1181}
1182
1183#[derive(Debug, Clone, Copy)]
1184pub enum AdaptationMethod {
1185    FineTuning,
1186    FeatureExtraction,
1187    LayerWiseAdaptation,
1188    AttentionBasedAdaptation,
1189}
1190
1191/// Clustering configuration
1192#[derive(Debug, Clone)]
1193pub struct ClusteringConfig {
1194    pub num_clusters: usize,
1195    pub clustering_method: ClusteringMethod,
1196    pub similarity_metric: SimilarityMetric,
1197    pub cluster_update_frequency: usize,
1198    pub privacy_preserving_clustering: bool,
1199}
1200
1201#[derive(Debug, Clone, Copy)]
1202pub enum ClusteringMethod {
1203    KMeans,
1204    DBSCAN,
1205    AgglomerativeClustering,
1206    SpectralClustering,
1207    PrivacyPreservingKMeans,
1208}
1209
1210#[derive(Debug, Clone, Copy)]
1211pub enum SimilarityMetric {
1212    CosineSimilarity,
1213    EuclideanDistance,
1214    ModelParameters,
1215    GradientSimilarity,
1216    LossLandscape,
1217}
1218
1219/// Meta-learning configuration
1220#[derive(Debug, Clone)]
1221pub struct MetaLearningConfig {
1222    pub inner_learning_rate: f64,
1223    pub outer_learning_rate: f64,
1224    pub inner_steps: usize,
1225    pub meta_batch_size: usize,
1226    pub adaptation_method: MetaAdaptationMethod,
1227}
1228
1229#[derive(Debug, Clone, Copy)]
1230pub enum MetaAdaptationMethod {
1231    MAML,
1232    Reptile,
1233    ProtoNets,
1234    RelationNets,
1235    FOMAML,
1236}
1237
1238/// Budget allocation strategy
1239#[derive(Debug, Clone, Copy)]
1240pub enum BudgetAllocationStrategy {
1241    Uniform,
1242    ProportionalToData,
1243    ProportionalToParticipation,
1244    UtilityBased,
1245    FairnessAware,
1246    AdaptiveAllocation,
1247}
1248
1249/// Dynamic privacy configuration
1250#[derive(Debug, Clone)]
1251pub struct DynamicPrivacyConfig {
1252    pub enabled: bool,
1253    pub adaptation_frequency: usize,
1254    pub privacy_sensitivity: f64,
1255    pub utility_weight: f64,
1256    pub fairness_weight: f64,
1257}
1258
1259/// Contextual adjustment configuration
1260#[derive(Debug, Clone)]
1261pub struct ContextualAdjustmentConfig {
1262    pub enabled: bool,
1263    pub context_factors: Vec<ContextFactor>,
1264    pub adjustment_sensitivity: f64,
1265    pub temporal_adaptation: bool,
1266}
1267
1268#[derive(Debug, Clone, Copy)]
1269pub enum ContextFactor {
1270    DataSensitivity,
1271    ClientTrustLevel,
1272    NetworkConditions,
1273    ModelAccuracy,
1274    ParticipationHistory,
1275}
1276
1277/// Lazy aggregation configuration
1278#[derive(Debug, Clone)]
1279pub struct LazyAggregationConfig {
1280    pub enabled: bool,
1281    pub aggregation_threshold: f64,
1282    pub staleness_tolerance: usize,
1283    pub gradient_similarity_threshold: f64,
1284}
1285
1286/// Federated dropout configuration
1287#[derive(Debug, Clone)]
1288pub struct FederatedDropoutConfig {
1289    pub enabled: bool,
1290    pub dropout_probability: f64,
1291    pub adaptive_dropout: bool,
1292    pub importance_sampling: bool,
1293}
1294
1295/// Asynchronous update configuration
1296#[derive(Debug, Clone)]
1297pub struct AsyncUpdateConfig {
1298    pub enabled: bool,
1299    pub staleness_threshold: usize,
1300    pub mixing_coefficient: f64,
1301    pub buffering_strategy: BufferingStrategy,
1302}
1303
1304#[derive(Debug, Clone, Copy)]
1305pub enum BufferingStrategy {
1306    FIFO,
1307    LIFO,
1308    PriorityBased,
1309    AdaptiveMixing,
1310}
1311
1312/// Bandwidth adaptation configuration
1313#[derive(Debug, Clone, Default)]
1314pub struct BandwidthAdaptationConfig {
1315    pub enabled: bool,
1316    pub compression_adaptation: bool,
1317    pub transmission_scheduling: bool,
1318    pub quality_of_service: QoSConfig,
1319}
1320
1321/// Quality of Service configuration
1322#[derive(Debug, Clone)]
1323pub struct QoSConfig {
1324    pub priority_levels: usize,
1325    pub latency_targets: Vec<f64>,
1326    pub throughput_targets: Vec<f64>,
1327    pub fairness_constraints: bool,
1328}
1329
1330/// Memory management configuration
1331#[derive(Debug, Clone)]
1332pub struct MemoryManagementConfig {
1333    pub memory_budget: usize,
1334    pub eviction_strategy: EvictionStrategy,
1335    pub compression_enabled: bool,
1336    pub memory_adaptation: bool,
1337}
1338
1339#[derive(Debug, Clone, Copy)]
1340pub enum EvictionStrategy {
1341    LRU,
1342    LFU,
1343    FIFO,
1344    ImportanceBased,
1345    TemporalDecay,
1346}
1347
1348/// Task detection configuration
1349#[derive(Debug, Clone)]
1350pub struct TaskDetectionConfig {
1351    pub enabled: bool,
1352    pub detection_method: TaskDetectionMethod,
1353    pub sensitivity_threshold: f64,
1354    pub adaptation_delay: usize,
1355}
1356
1357#[derive(Debug, Clone, Copy)]
1358pub enum TaskDetectionMethod {
1359    GradientBased,
1360    LossBased,
1361    StatisticalTest,
1362    ChangePointDetection,
1363    EnsembleMethods,
1364}
1365
1366/// Knowledge transfer configuration
1367#[derive(Debug, Clone)]
1368pub struct KnowledgeTransferConfig {
1369    pub transfer_method: KnowledgeTransferMethod,
1370    pub transfer_strength: f64,
1371    pub selective_transfer: bool,
1372    pub privacy_preserving: bool,
1373}
1374
1375#[derive(Debug, Clone, Copy)]
1376pub enum KnowledgeTransferMethod {
1377    ParameterTransfer,
1378    FeatureTransfer,
1379    AttentionTransfer,
1380    DistillationBased,
1381    GradientBased,
1382}
1383
1384/// Forgetting prevention configuration
1385#[derive(Debug, Clone)]
1386pub struct ForgettingPreventionConfig {
1387    pub method: ForgettingPreventionMethod,
1388    pub regularization_strength: f64,
1389    pub memory_replay_ratio: f64,
1390    pub importance_estimation: ImportanceEstimationMethod,
1391}
1392
1393#[derive(Debug, Clone, Copy)]
1394pub enum ForgettingPreventionMethod {
1395    EWC,
1396    MAS,
1397    PackNet,
1398    ProgressiveNets,
1399    MemoryReplay,
1400}
1401
1402#[derive(Debug, Clone, Copy)]
1403pub enum ImportanceEstimationMethod {
1404    FisherInformation,
1405    GradientNorm,
1406    PathIntegral,
1407    AttentionWeights,
1408}
1409
1410/// Local differential privacy configuration
1411#[derive(Debug, Clone)]
1412pub struct LocalDPConfig {
1413    pub enabled: bool,
1414    pub epsilon: f64,
1415    pub mechanism: LocalDPMechanism,
1416    pub data_preprocessing: DataPreprocessingConfig,
1417}
1418
1419#[derive(Debug, Clone, Copy)]
1420pub enum LocalDPMechanism {
1421    Randomized,
1422    Duchi,
1423    RAPPOR,
1424    PrivUnit,
1425    Harmony,
1426}
1427
1428/// Global differential privacy configuration
1429#[derive(Debug, Clone)]
1430pub struct GlobalDPConfig {
1431    pub epsilon: f64,
1432    pub delta: f64,
1433    pub composition_method: CompositionMethod,
1434    pub amplification_analysis: bool,
1435}
1436
1437#[derive(Debug, Clone, Copy)]
1438pub enum CompositionMethod {
1439    Basic,
1440    Advanced,
1441    RDP,
1442    ZCDP,
1443    Moments,
1444}
1445
1446/// User-level privacy configuration
1447#[derive(Debug, Clone)]
1448pub struct UserLevelPrivacyConfig {
1449    pub enabled: bool,
1450    pub user_epsilon: f64,
1451    pub user_delta: f64,
1452    pub cross_device_correlation: bool,
1453    pub temporal_correlation: bool,
1454}
1455
1456/// Hierarchical privacy configuration
1457#[derive(Debug, Clone)]
1458pub struct HierarchicalPrivacyConfig {
1459    pub levels: Vec<PrivacyLevel>,
1460    pub level_allocation: LevelAllocationStrategy,
1461    pub inter_level_composition: bool,
1462}
1463
1464#[derive(Debug, Clone)]
1465pub struct PrivacyLevel {
1466    pub name: String,
1467    pub epsilon: f64,
1468    pub delta: f64,
1469    pub scope: PrivacyScope,
1470}
1471
1472#[derive(Debug, Clone, Copy)]
1473pub enum PrivacyScope {
1474    Individual,
1475    Group,
1476    Organization,
1477    Global,
1478}
1479
1480#[derive(Debug, Clone, Copy)]
1481pub enum LevelAllocationStrategy {
1482    Uniform,
1483    ProportionalToSensitivity,
1484    OptimalAllocation,
1485    AdaptiveAllocation,
1486}
1487
1488/// Context-aware privacy configuration
1489#[derive(Debug, Clone)]
1490pub struct ContextAwarePrivacyConfig {
1491    pub enabled: bool,
1492    pub context_sensitivity: f64,
1493    pub dynamic_adjustment: bool,
1494    pub privacy_preferences: PrivacyPreferencesConfig,
1495}
1496
1497/// Privacy preferences configuration
1498#[derive(Debug, Clone)]
1499pub struct PrivacyPreferencesConfig {
1500    pub user_controlled: bool,
1501    pub preference_learning: bool,
1502    pub default_privacy_level: PrivacyLevel,
1503    pub granular_control: bool,
1504}
1505
1506/// Data preprocessing configuration for local DP
1507#[derive(Debug, Clone)]
1508pub struct DataPreprocessingConfig {
1509    pub normalization: bool,
1510    pub discretization: bool,
1511    pub dimensionality_reduction: bool,
1512    pub feature_selection: bool,
1513}
1514
1515// Default implementations for configurations
1516
1517impl Default for FederatedPrivacyConfig {
1518    fn default() -> Self {
1519        Self {
1520            base_config: DifferentialPrivacyConfig::default(),
1521            clients_per_round: 100,
1522            total_clients: 1000,
1523            sampling_strategy: ClientSamplingStrategy::UniformRandom,
1524            secure_aggregation: SecureAggregationConfig::default(),
1525            amplification_config: AmplificationConfig::default(),
1526            cross_device_config: CrossDeviceConfig::default(),
1527            composition_method: FederatedCompositionMethod::FederatedMomentsAccountant,
1528            trust_model: TrustModel::HonestButCurious,
1529            communication_privacy: CommunicationPrivacyConfig::default(),
1530        }
1531    }
1532}
1533
1534impl Default for SecureAggregationConfig {
1535    fn default() -> Self {
1536        Self {
1537            enabled: false,
1538            min_clients: 10,
1539            max_dropouts: 5,
1540            masking_dimension: 1000,
1541            seed_sharing: SeedSharingMethod::ShamirSecretSharing,
1542            quantization_bits: None,
1543            aggregate_dp: true,
1544        }
1545    }
1546}
1547
1548impl Default for AmplificationConfig {
1549    fn default() -> Self {
1550        Self {
1551            enabled: true,
1552            subsampling_factor: 1.0,
1553            shuffling_enabled: false,
1554            multi_round_amplification: true,
1555            heterogeneous_amplification: false,
1556        }
1557    }
1558}
1559
1560impl Default for CommunicationPrivacyConfig {
1561    fn default() -> Self {
1562        Self {
1563            encryption_enabled: true,
1564            anonymous_channels: false,
1565            communication_noise: false,
1566            traffic_analysis_protection: false,
1567            threat_modeling: AdvancedThreatModelingConfig::default(),
1568            cross_silo_config: None,
1569        }
1570    }
1571}
1572
1573impl Default for AdversarialCapabilities {
1574    fn default() -> Self {
1575        Self {
1576            computational_resources: ComputationalThreatLevel::Limited,
1577            network_capabilities: NetworkThreatCapabilities::default(),
1578            data_capabilities: DataThreatCapabilities::default(),
1579            algorithmic_knowledge: AlgorithmicKnowledgeLevel::BlackBox,
1580            collusion_potential: CollusionThreatLevel::None,
1581            attack_persistence: AttackPersistenceLevel::OneTime,
1582        }
1583    }
1584}
1585
1586impl Default for AnomalyDetectionConfig {
1587    fn default() -> Self {
1588        Self {
1589            algorithms: vec![AnomalyDetectionAlgorithm::StatisticalBaseline],
1590            thresholds: AnomalyThresholds::default(),
1591            response_actions: AnomalyResponseActions::default(),
1592        }
1593    }
1594}
1595
1596impl Default for AnomalyThresholds {
1597    fn default() -> Self {
1598        Self {
1599            statistical_threshold: 0.95,
1600            confidence_threshold: 0.8,
1601            false_positive_rate: 0.05,
1602        }
1603    }
1604}
1605
1606impl Default for AnomalyResponseActions {
1607    fn default() -> Self {
1608        Self {
1609            alert_generation: true,
1610            automatic_quarantine: false,
1611            enhanced_monitoring: true,
1612            incident_escalation: false,
1613        }
1614    }
1615}
1616
1617impl Default for ThreatCorrelationConfig {
1618    fn default() -> Self {
1619        Self {
1620            correlation_algorithms: vec![CorrelationAlgorithm::StatisticalCorrelation],
1621            temporal_window: Duration::from_secs(3600), // 1 hour
1622            cross_client_correlation: false,
1623        }
1624    }
1625}
1626
1627impl Default for RiskAssessmentConfig {
1628    fn default() -> Self {
1629        Self {
1630            methodology: RiskAssessmentMethodology::QualitativeAssessment,
1631            risk_tolerance: RiskToleranceLevels::default(),
1632            impact_assessment: ImpactAssessmentCriteria::default(),
1633            likelihood_estimation: LikelihoodEstimationMethods::default(),
1634            mitigation_strategies: RiskMitigationStrategies::default(),
1635        }
1636    }
1637}
1638
1639impl Default for RiskToleranceLevels {
1640    fn default() -> Self {
1641        Self {
1642            privacy_risk_tolerance: 0.1,
1643            security_risk_tolerance: 0.05,
1644            utility_risk_tolerance: 0.2,
1645            operational_risk_tolerance: 0.15,
1646        }
1647    }
1648}
1649
1650impl Default for ImpactAssessmentCriteria {
1651    fn default() -> Self {
1652        Self {
1653            confidentiality_impact: ImpactLevel::Medium,
1654            integrity_impact: ImpactLevel::High,
1655            availability_impact: ImpactLevel::Medium,
1656            compliance_impact: ImpactLevel::High,
1657        }
1658    }
1659}
1660
1661impl Default for LikelihoodEstimationMethods {
1662    fn default() -> Self {
1663        Self {
1664            historical_analysis: true,
1665            expert_judgment: true,
1666            threat_modeling: false,
1667            simulation_based: false,
1668        }
1669    }
1670}
1671
1672impl Default for ReputationSystemConfig {
1673    fn default() -> Self {
1674        Self {
1675            enabled: false,
1676            initial_reputation: 1.0,
1677            reputation_decay: 0.95,
1678            min_reputation: 0.1,
1679            outlier_penalty: 0.1,
1680            contribution_bonus: 0.05,
1681        }
1682    }
1683}
1684
1685impl Default for StatisticalTestConfig {
1686    fn default() -> Self {
1687        Self {
1688            enabled: false,
1689            test_type: StatisticalTestType::ZScore,
1690            significancelevel: 0.05,
1691            window_size: 10,
1692            adaptive_threshold: false,
1693        }
1694    }
1695}
1696
1697impl Default for LocalAdaptationConfig {
1698    fn default() -> Self {
1699        Self {
1700            adaptation_rate: 0.01,
1701            local_epochs: 1,
1702            adaptation_frequency: 1,
1703            adaptation_method: AdaptationMethod::FineTuning,
1704            regularization_strength: 0.01,
1705        }
1706    }
1707}
1708
1709impl Default for ClusteringConfig {
1710    fn default() -> Self {
1711        Self {
1712            num_clusters: 5,
1713            clustering_method: ClusteringMethod::KMeans,
1714            similarity_metric: SimilarityMetric::CosineSimilarity,
1715            cluster_update_frequency: 10,
1716            privacy_preserving_clustering: false,
1717        }
1718    }
1719}
1720
1721impl Default for MetaLearningConfig {
1722    fn default() -> Self {
1723        Self {
1724            inner_learning_rate: 0.01,
1725            outer_learning_rate: 0.001,
1726            inner_steps: 5,
1727            meta_batch_size: 32,
1728            adaptation_method: MetaAdaptationMethod::MAML,
1729        }
1730    }
1731}
1732
1733impl Default for DynamicPrivacyConfig {
1734    fn default() -> Self {
1735        Self {
1736            enabled: false,
1737            adaptation_frequency: 10,
1738            privacy_sensitivity: 1.0,
1739            utility_weight: 0.5,
1740            fairness_weight: 0.3,
1741        }
1742    }
1743}
1744
1745impl Default for ContextualAdjustmentConfig {
1746    fn default() -> Self {
1747        Self {
1748            enabled: false,
1749            context_factors: vec![ContextFactor::DataSensitivity],
1750            adjustment_sensitivity: 0.1,
1751            temporal_adaptation: false,
1752        }
1753    }
1754}
1755
1756impl Default for LazyAggregationConfig {
1757    fn default() -> Self {
1758        Self {
1759            enabled: false,
1760            aggregation_threshold: 0.9,
1761            staleness_tolerance: 5,
1762            gradient_similarity_threshold: 0.8,
1763        }
1764    }
1765}
1766
1767impl Default for FederatedDropoutConfig {
1768    fn default() -> Self {
1769        Self {
1770            enabled: false,
1771            dropout_probability: 0.1,
1772            adaptive_dropout: false,
1773            importance_sampling: false,
1774        }
1775    }
1776}
1777
1778impl Default for AsyncUpdateConfig {
1779    fn default() -> Self {
1780        Self {
1781            enabled: false,
1782            staleness_threshold: 10,
1783            mixing_coefficient: 0.9,
1784            buffering_strategy: BufferingStrategy::FIFO,
1785        }
1786    }
1787}
1788
1789impl Default for QoSConfig {
1790    fn default() -> Self {
1791        Self {
1792            priority_levels: 3,
1793            latency_targets: vec![100.0, 200.0, 500.0],
1794            throughput_targets: vec![10.0, 5.0, 1.0],
1795            fairness_constraints: true,
1796        }
1797    }
1798}
1799
1800impl Default for MemoryManagementConfig {
1801    fn default() -> Self {
1802        Self {
1803            memory_budget: 1000,
1804            eviction_strategy: EvictionStrategy::LRU,
1805            compression_enabled: false,
1806            memory_adaptation: false,
1807        }
1808    }
1809}
1810
1811impl Default for TaskDetectionConfig {
1812    fn default() -> Self {
1813        Self {
1814            enabled: false,
1815            detection_method: TaskDetectionMethod::GradientBased,
1816            sensitivity_threshold: 0.1,
1817            adaptation_delay: 5,
1818        }
1819    }
1820}
1821
1822impl Default for KnowledgeTransferConfig {
1823    fn default() -> Self {
1824        Self {
1825            transfer_method: KnowledgeTransferMethod::ParameterTransfer,
1826            transfer_strength: 0.5,
1827            selective_transfer: false,
1828            privacy_preserving: true,
1829        }
1830    }
1831}
1832
1833impl Default for ForgettingPreventionConfig {
1834    fn default() -> Self {
1835        Self {
1836            method: ForgettingPreventionMethod::EWC,
1837            regularization_strength: 0.1,
1838            memory_replay_ratio: 0.1,
1839            importance_estimation: ImportanceEstimationMethod::FisherInformation,
1840        }
1841    }
1842}
1843
1844impl Default for AdaptiveBudgetConfig {
1845    fn default() -> Self {
1846        Self {
1847            enabled: false,
1848            allocation_strategy: BudgetAllocationStrategy::Uniform,
1849            dynamic_privacy: DynamicPrivacyConfig::default(),
1850            importance_weighting: false,
1851            contextual_adjustment: ContextualAdjustmentConfig::default(),
1852        }
1853    }
1854}
optirs_core/privacy/federated_privacy/config.rs

optirs_core/privacy/federated_privacy/
config.rs
