quantrs2_device/security/
engines.rs

1//! Security engines and result types
2
3use serde::{Deserialize, Serialize};
4use std::time::{Duration, SystemTime};
5use uuid::Uuid;
6
7use super::config::*;
8use super::types::*;
9use crate::{DeviceError, DeviceResult};
10
11/// Data structures for security operations
12#[derive(Debug, Clone, Serialize, Deserialize, Default)]
13pub struct SecurityOperationInfo {
14    pub operation_id: String,
15}
16
17impl SecurityOperationInfo {
18    pub fn from_operation(operation: SecurityOperation) -> Self {
19        Self {
20            operation_id: operation.operation_id,
21        }
22    }
23}
24
25#[derive(Debug, Clone, Serialize, Deserialize, Default)]
26pub struct ThreatDetectionResults {
27    pub threats_detected: usize,
28    pub high_severity_threats: usize,
29    pub medium_severity_threats: usize,
30    pub low_severity_threats: usize,
31    pub false_positives: usize,
32    pub detection_algorithms_used: Vec<ThreatDetectionAlgorithm>,
33    pub overall_risk_score: f64,
34    pub detection_time: Duration,
35}
36
37impl ThreatDetectionResults {
38    pub fn merge(traditional: Self, ml: Self) -> Self {
39        Self {
40            threats_detected: traditional.threats_detected + ml.threats_detected,
41            high_severity_threats: traditional.high_severity_threats + ml.high_severity_threats,
42            medium_severity_threats: traditional.medium_severity_threats
43                + ml.medium_severity_threats,
44            low_severity_threats: traditional.low_severity_threats + ml.low_severity_threats,
45            false_positives: traditional.false_positives + ml.false_positives,
46            detection_algorithms_used: [
47                traditional.detection_algorithms_used,
48                ml.detection_algorithms_used,
49            ]
50            .concat(),
51            overall_risk_score: f64::midpoint(
52                traditional.overall_risk_score,
53                ml.overall_risk_score,
54            ),
55            detection_time: traditional.detection_time + ml.detection_time,
56        }
57    }
58}
59
60#[derive(Debug, Clone, Serialize, Deserialize, Default)]
61pub struct AccessControlAuditResults {
62    pub audit_id: String,
63    pub access_attempts: usize,
64    pub successful_authentications: usize,
65    pub failed_authentications: usize,
66    pub authorization_decisions: usize,
67    pub policy_violations: usize,
68    pub anomalous_access_patterns: usize,
69    pub risk_score: f64,
70}
71
72#[derive(Debug, Clone, Serialize, Deserialize, Default)]
73pub struct CryptographicOperationResults {
74    pub operations_executed: usize,
75    pub algorithms_used: Vec<PostQuantumAlgorithm>,
76    pub key_operations: usize,
77    pub signature_operations: usize,
78    pub encryption_operations: usize,
79    pub performance_metrics: CryptographicPerformanceMetrics,
80}
81
82#[derive(Debug, Clone, Serialize, Deserialize, Default)]
83pub struct ComplianceAssessmentResults {
84    pub compliance_score: f64,
85}
86
87#[derive(Debug, Clone, Serialize, Deserialize, Default)]
88pub struct SecurityAnalyticsResults {
89    pub analytics_score: f64,
90}
91
92#[derive(Debug, Clone, Serialize, Deserialize, Default)]
93pub struct RiskAssessmentResults {
94    pub risk_score: f64,
95}
96
97#[derive(Debug, Clone, Serialize, Deserialize, Default)]
98pub struct IncidentResponseAction {
99    pub action_id: String,
100}
101
102#[derive(Debug, Clone, Serialize, Deserialize, Default)]
103pub struct SecurityMetrics {
104    pub overall_security_score: f64,
105    pub threat_detection_rate: f64,
106    pub false_positive_rate: f64,
107    pub incident_response_time: Duration,
108    pub compliance_score: f64,
109    pub risk_score: f64,
110    pub encryption_coverage: f64,
111    pub access_control_effectiveness: f64,
112}
113
114#[derive(Debug, Clone, Serialize, Deserialize, Default)]
115pub struct SecurityPerformanceImpact {
116    pub performance_overhead: f64,
117}
118
119#[derive(Debug, Clone, Serialize, Deserialize, Default)]
120pub struct SecurityRecommendation {
121    pub recommendation_id: String,
122    pub category: SecurityRecommendationCategory,
123    pub priority: RecommendationPriority,
124    pub title: String,
125    pub description: String,
126    pub expected_impact: f64,
127    pub implementation_effort: ImplementationEffort,
128    pub timeline: Duration,
129}
130
131#[derive(Debug, Clone, Serialize, Deserialize)]
132pub struct SecurityExecutionMetadata {
133    pub start_time: SystemTime,
134    pub end_time: Option<SystemTime>,
135    pub total_duration: Option<Duration>,
136    pub security_config: QuantumSecurityConfig,
137    pub threat_landscape: ThreatLandscape,
138    pub compliance_status: ComplianceStatus,
139    pub security_posture: SecurityPosture,
140}
141
142impl Default for SecurityExecutionMetadata {
143    fn default() -> Self {
144        Self {
145            start_time: SystemTime::UNIX_EPOCH,
146            end_time: None,
147            total_duration: None,
148            security_config: QuantumSecurityConfig::default(),
149            threat_landscape: ThreatLandscape::default(),
150            compliance_status: ComplianceStatus::default(),
151            security_posture: SecurityPosture::default(),
152        }
153    }
154}
155
156#[derive(Debug, Clone, Serialize, Deserialize, Default)]
157pub struct AuthenticationCredentials {
158    pub credential_type: String,
159    pub credential_data: Vec<u8>,
160}
161
162#[derive(Debug, Clone, Serialize, Deserialize, Default)]
163pub struct SecurityPolicyParameters {
164    pub policy_id: String,
165}
166
167#[derive(Debug, Clone, Serialize, Deserialize, Default)]
168pub struct IncidentResponseParameters {
169    pub incident_id: String,
170}
171
172#[derive(Debug, Clone, Serialize, Deserialize)]
173pub struct EncryptedData {
174    pub data: Vec<u8>,
175    pub algorithm: PostQuantumAlgorithm,
176    pub classification: SecurityClassification,
177    pub key_id: String,
178    pub timestamp: SystemTime,
179    pub integrity_hash: Vec<u8>,
180}
181
182impl Default for EncryptedData {
183    fn default() -> Self {
184        Self {
185            data: Vec::new(),
186            algorithm: PostQuantumAlgorithm::default(),
187            classification: SecurityClassification::default(),
188            key_id: String::new(),
189            timestamp: SystemTime::UNIX_EPOCH,
190            integrity_hash: Vec::new(),
191        }
192    }
193}
194
195#[derive(Debug, Clone, Serialize, Deserialize)]
196pub struct AuthenticationResult {
197    pub user_id: String,
198    pub authenticated: bool,
199    pub authentication_method: AuthenticationMethod,
200    pub security_level: SecurityLevel,
201    pub session_token: String,
202    pub expires_at: SystemTime,
203    pub additional_verification_required: bool,
204}
205
206impl Default for AuthenticationResult {
207    fn default() -> Self {
208        Self {
209            user_id: String::new(),
210            authenticated: false,
211            authentication_method: AuthenticationMethod::default(),
212            security_level: SecurityLevel::default(),
213            session_token: String::new(),
214            expires_at: SystemTime::UNIX_EPOCH,
215            additional_verification_required: false,
216        }
217    }
218}
219
220#[derive(Debug, Clone, Serialize, Deserialize)]
221pub struct AuthorizationResult {
222    pub user_id: String,
223    pub resource: String,
224    pub authorized: bool,
225    pub granted_permissions: Vec<String>,
226    pub authorization_model: AuthorizationModel,
227    pub decision_factors: Vec<String>,
228    pub expires_at: SystemTime,
229}
230
231impl Default for AuthorizationResult {
232    fn default() -> Self {
233        Self {
234            user_id: String::new(),
235            resource: String::new(),
236            authorized: false,
237            granted_permissions: Vec::new(),
238            authorization_model: AuthorizationModel::default(),
239            decision_factors: Vec::new(),
240            expires_at: SystemTime::UNIX_EPOCH,
241        }
242    }
243}
244
245#[derive(Debug, Clone, Serialize, Deserialize, Default)]
246pub struct QuantumThreatDetectionResult {
247    pub target_system: String,
248    pub threats_detected: usize,
249    pub quantum_state_anomalies: usize,
250    pub quantum_noise_anomalies: usize,
251    pub decoherence_attacks: usize,
252    pub side_channel_attacks: usize,
253    pub risk_score: f64,
254    pub detection_confidence: f64,
255}
256
257#[derive(Debug, Clone, Serialize, Deserialize, Default)]
258pub struct QuantumRiskAssessment {
259    pub asset_id: String,
260    pub risk_score: f64,
261}
262
263#[derive(Debug, Clone, Serialize, Deserialize, Default)]
264pub struct SecurityReport {
265    pub report_id: String,
266}
267
268#[derive(Debug, Clone, Serialize, Deserialize, Default)]
269pub struct SecurityOperationContext {
270    pub context_id: String,
271}
272
273#[derive(Debug, Clone, Serialize, Deserialize, Default)]
274pub struct SecurityRequirement {
275    pub requirement_id: String,
276}
277
278#[derive(Debug, Clone, Serialize, Deserialize, Default)]
279pub struct CryptographicPerformanceMetrics {
280    pub operation_time: Duration,
281}
282
283#[derive(Debug, Clone, Serialize, Deserialize, Default)]
284pub struct ThreatLandscape {
285    pub threat_level: String,
286}
287
288#[derive(Debug, Clone, Serialize, Deserialize, Default)]
289pub struct ComplianceStatus {
290    pub compliance_level: String,
291}
292
293#[derive(Debug, Clone, Serialize, Deserialize, Default)]
294pub struct SecurityPosture {
295    pub overall_posture_score: f64,
296    pub maturity_level: SecurityMaturityLevel,
297    pub key_strengths: Vec<String>,
298    pub areas_for_improvement: Vec<String>,
299    pub risk_exposure: f64,
300}
301
302/// Security operation definition
303#[derive(Debug, Clone, Serialize, Deserialize)]
304pub struct SecurityOperation {
305    /// Operation identifier
306    pub operation_id: String,
307    /// Operation type
308    pub operation_type: SecurityOperationType,
309    /// Target system or resource
310    pub target: String,
311    /// Requesting user
312    pub user_id: String,
313    /// Security requirements
314    pub security_requirements: Vec<SecurityRequirement>,
315    /// Classification level
316    pub classification: SecurityClassification,
317    /// Operation context
318    pub context: SecurityOperationContext,
319    /// Risk tolerance
320    pub risk_tolerance: f64,
321}
322
323/// Comprehensive execution result for quantum security operations
324#[derive(Debug, Clone, Serialize, Deserialize)]
325pub struct QuantumSecurityExecutionResult {
326    /// Execution identifier
327    pub execution_id: String,
328    /// Security execution status
329    pub status: QuantumSecurityExecutionStatus,
330    /// Security operations performed
331    pub security_operations: Vec<SecurityOperationInfo>,
332    /// Threat detection results
333    pub threat_detection_results: ThreatDetectionResults,
334    /// Access control audit results
335    pub access_control_results: AccessControlAuditResults,
336    /// Cryptographic operations results
337    pub cryptographic_results: CryptographicOperationResults,
338    /// Compliance assessment results
339    pub compliance_results: ComplianceAssessmentResults,
340    /// Security analytics results
341    pub security_analytics: SecurityAnalyticsResults,
342    /// Risk assessment results
343    pub risk_assessment: RiskAssessmentResults,
344    /// Incident response actions
345    pub incident_response_actions: Vec<IncidentResponseAction>,
346    /// Security metrics
347    pub security_metrics: SecurityMetrics,
348    /// Performance impact analysis
349    pub performance_impact: SecurityPerformanceImpact,
350    /// Recommendations
351    pub security_recommendations: Vec<SecurityRecommendation>,
352    /// Execution metadata
353    pub execution_metadata: SecurityExecutionMetadata,
354}
quantrs2_device/security/engines.rs

quantrs2_device/security/
engines.rs
