129 lines
4.2 KiB
Rust
129 lines
4.2 KiB
Rust
//! Advanced mitigation pipeline example
|
|
|
|
use aimds_response::{
|
|
AdaptiveMitigator, AuditLogger, FeedbackSignal, MetaLearningEngine, ResponseSystem,
|
|
RollbackManager,
|
|
};
|
|
use std::time::Duration;
|
|
|
|
#[tokio::main]
|
|
async fn main() -> Result<(), Box<dyn std::error::Error>> {
|
|
tracing_subscriber::fmt()
|
|
.with_max_level(tracing::Level::DEBUG)
|
|
.init();
|
|
|
|
println!("=== AIMDS Response Layer - Advanced Pipeline ===\n");
|
|
|
|
// Create components
|
|
let system = ResponseSystem::new().await?;
|
|
let mut meta_learner = MetaLearningEngine::new();
|
|
let audit_logger = AuditLogger::new();
|
|
let rollback_mgr = RollbackManager::new();
|
|
|
|
// Simulate multiple threat scenarios
|
|
let threats = create_threat_scenarios();
|
|
|
|
println!("Processing {} threat scenarios...\n", threats.len());
|
|
|
|
for (i, threat) in threats.iter().enumerate() {
|
|
println!("--- Scenario {} ---", i + 1);
|
|
println!("Threat ID: {}", threat.id);
|
|
println!("Severity: {}", threat.severity);
|
|
println!("Confidence: {:.2}", threat.confidence);
|
|
|
|
// Apply mitigation
|
|
let outcome = system.mitigate(threat).await?;
|
|
|
|
println!("✓ Mitigation applied: {}", outcome.strategy_id);
|
|
println!(" Actions: {:?}", outcome.actions_applied);
|
|
|
|
// Learn from outcome
|
|
meta_learner.learn_from_incident(threat).await;
|
|
|
|
// Create feedback
|
|
let feedback = FeedbackSignal {
|
|
strategy_id: outcome.strategy_id.clone(),
|
|
success: outcome.success,
|
|
effectiveness_score: outcome.effectiveness_score(),
|
|
timestamp: chrono::Utc::now(),
|
|
context: Some(format!("scenario_{}", i + 1)),
|
|
};
|
|
|
|
// Optimize based on feedback
|
|
meta_learner.optimize_strategy(&[feedback]);
|
|
|
|
println!(
|
|
" Optimization level: {}\n",
|
|
meta_learner.current_optimization_level()
|
|
);
|
|
|
|
// Small delay between scenarios
|
|
tokio::time::sleep(Duration::from_millis(100)).await;
|
|
}
|
|
|
|
// Display final statistics
|
|
println!("\n=== Final Statistics ===");
|
|
|
|
let metrics = system.metrics().await;
|
|
println!("Total mitigations: {}", metrics.total_mitigations);
|
|
println!("Successful: {}", metrics.successful_mitigations);
|
|
println!("Learned patterns: {}", metrics.learned_patterns);
|
|
println!("Active strategies: {}", metrics.active_strategies);
|
|
println!(
|
|
"Optimization level: {}/25",
|
|
metrics.optimization_level
|
|
);
|
|
|
|
let audit_stats = audit_logger.statistics().await;
|
|
println!("\n=== Audit Statistics ===");
|
|
println!("Total mitigations: {}", audit_stats.total_mitigations);
|
|
println!("Success rate: {:.2}%", audit_stats.success_rate() * 100.0);
|
|
println!("Total actions: {}", audit_stats.total_actions_applied);
|
|
|
|
println!("\n✓ Advanced pipeline completed!");
|
|
|
|
Ok(())
|
|
}
|
|
|
|
fn create_threat_scenarios() -> Vec<aimds_response::meta_learning::ThreatIncident> {
|
|
use aimds_response::meta_learning::{AttackType, ThreatIncident, ThreatType};
|
|
|
|
vec![
|
|
ThreatIncident {
|
|
id: "threat-001".to_string(),
|
|
threat_type: ThreatType::Attack(AttackType::SqlInjection),
|
|
severity: 9,
|
|
confidence: 0.95,
|
|
timestamp: chrono::Utc::now(),
|
|
},
|
|
ThreatIncident {
|
|
id: "threat-002".to_string(),
|
|
threat_type: ThreatType::Attack(AttackType::XSS),
|
|
severity: 7,
|
|
confidence: 0.88,
|
|
timestamp: chrono::Utc::now(),
|
|
},
|
|
ThreatIncident {
|
|
id: "threat-003".to_string(),
|
|
threat_type: ThreatType::Anomaly(0.92),
|
|
severity: 6,
|
|
confidence: 0.85,
|
|
timestamp: chrono::Utc::now(),
|
|
},
|
|
ThreatIncident {
|
|
id: "threat-004".to_string(),
|
|
threat_type: ThreatType::Attack(AttackType::DDoS),
|
|
severity: 10,
|
|
confidence: 0.98,
|
|
timestamp: chrono::Utc::now(),
|
|
},
|
|
ThreatIncident {
|
|
id: "threat-005".to_string(),
|
|
threat_type: ThreatType::Intrusion(8),
|
|
severity: 8,
|
|
confidence: 0.91,
|
|
timestamp: chrono::Utc::now(),
|
|
},
|
|
]
|
|
}
|