Rust网络编程与AI辅助安全通信：从入门到精通

// TCP/IP协议栈层次示意图
/*
应用层: HTTP, FTP, SMTP, DNS等
传输层: TCP, UDP
网络层: IP, ICMP, ARP等
链路层: Ethernet, Wi-Fi等
*/

// TCP服务器端示例
use std::io::{Read, Write};
use std::net::{TcpListener, TcpStream};
use std::thread;

fn handle_client(mut stream: TcpStream) {
    let mut buffer = [0; 1024];
    
    // 读取客户端发送的数据
    match stream.read(&mut buffer) {
        Ok(size) => {
            // 处理接收到的数据
            let received = String::from_utf8_lossy(&buffer[..size]);
            println!("接收到数据: {}", received);
            
            // 发送响应数据
            let response = "数据已收到";
            stream.write(response.as_bytes()).expect("发送响应失败");
        },
        Err(e) => {
            eprintln!("读取数据错误: {:?}", e);
        }
    }
}

fn main() {
    // 绑定服务器地址和端口
    let listener = TcpListener::bind("127.0.0.1:8080").expect("绑定端口失败");
    println!("服务器启动，监听端口8080...");
    
    // 接受客户端连接
    for stream in listener.incoming() {
        match stream {
            Ok(stream) => {
                // 为每个客户端创建一个新线程处理
                thread::spawn(|| {
                    handle_client(stream);
                });
            },
            Err(e) => {
                eprintln!("连接错误: {:?}", e);
            }
        }
    }
}

// TCP客户端示例
use std::io::{Read, Write};
use std::net::TcpStream;

fn main() {
    // 连接到服务器
    let mut stream = TcpStream::connect("127.0.0.1:8080").expect("连接服务器失败");
    
    // 发送数据到服务器
    let message = "你好，Rust网络编程！";
    stream.write(message.as_bytes()).expect("发送数据失败");
    
    // 读取服务器响应
    let mut buffer = [0; 1024];
    match stream.read(&mut buffer) {
        Ok(size) => {
            let response = String::from_utf8_lossy(&buffer[..size]);
            println!("服务器响应: {}", response);
        },
        Err(e) => {
            eprintln!("读取响应错误: {:?}", e);
        }
    }
}

// 简单的异步函数示例
async fn say_hello() {
    println!("Hello, 异步世界！");
}

async fn main_async() {
    // 调用异步函数
    say_hello().await;
}

// 在实际应用中，需要运行时来执行异步代码
fn main() {
    // 使用tokio运行时
    // tokio::runtime::Runtime::new().unwrap().block_on(main_async());
}

// 使用Tokio的异步TCP服务器示例
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use tokio::net::TcpListener;

#[tokio::main]
async fn main() {
    // 绑定服务器地址和端口
    let listener = TcpListener::bind("127.0.0.1:8080").await.expect("绑定端口失败");
    println!("异步服务器启动，监听端口8080...");
    
    // 接受客户端连接
    loop {
        let (mut socket, _) = listener.accept().await.expect("接受连接失败");
        
        // 为每个客户端创建一个新的异步任务处理
        tokio::spawn(async move {
            let mut buffer = [0; 1024];
            
            // 读取客户端发送的数据
            match socket.read(&mut buffer).await {
                Ok(size) if size > 0 => {
                    // 处理接收到的数据
                    let received = String::from_utf8_lossy(&buffer[..size]);
                    println!("接收到数据: {}", received);
                    
                    // 发送响应数据
                    let response = "数据已收到";
                    if let Err(e) = socket.write_all(response.as_bytes()).await {
                        eprintln!("发送响应失败: {:?}", e);
                    }
                },
                Ok(_) => {},
                Err(e) => {
                    eprintln!("读取数据错误: {:?}", e);
                }
            }
        });
    }
}

// 使用Tokio的异步TCP客户端示例
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use tokio::net::TcpStream;

#[tokio::main]
async fn main() {
    // 连接到服务器
    let mut stream = TcpStream::connect("127.0.0.1:8080").await.expect("连接服务器失败");
    
    // 发送数据到服务器
    let message = "你好，Rust异步网络编程！";
    stream.write_all(message.as_bytes()).await.expect("发送数据失败");
    
    // 读取服务器响应
    let mut buffer = [0; 1024];
    match stream.read(&mut buffer).await {
        Ok(size) => {
            let response = String::from_utf8_lossy(&buffer[..size]);
            println!("服务器响应: {}", response);
        },
        Err(e) => {
            eprintln!("读取响应错误: {:?}", e);
        }
    }
}

// 套接字类型示意图
/*
套接字类型:
- 流式套接字 (SOCK_STREAM): 基于TCP协议，提供可靠的、面向连接的通信
- 数据报套接字 (SOCK_DGRAM): 基于UDP协议，提供不可靠的、无连接的通信
- 原始套接字 (SOCK_RAW): 直接访问IP协议，用于网络诊断和自定义协议开发
*/

// 使用Rust标准库创建UDP套接字示例
use std::net::{UdpSocket, SocketAddr};

fn main() {
    // 创建UDP套接字
    let socket = UdpSocket::bind("127.0.0.1:8080").expect("绑定端口失败");
    println!("UDP服务器启动，监听端口8080...");
    
    // 接收数据
    let mut buffer = [0; 1024];
    loop {
        match socket.recv_from(&mut buffer) {
            Ok((size, addr)) => {
                // 处理接收到的数据
                let received = String::from_utf8_lossy(&buffer[..size]);
                println!("从 {} 接收到数据: {}", addr, received);
                
                // 发送响应数据
                let response = "数据已收到";
                socket.send_to(response.as_bytes(), addr).expect("发送响应失败");
            },
            Err(e) => {
                eprintln!("接收数据错误: {:?}", e);
            }
        }
    }
}

// 使用Rust标准库创建UDP客户端示例
use std::net::{UdpSocket, SocketAddr};

fn main() {
    // 创建UDP套接字
    let socket = UdpSocket::bind("127.0.0.1:0").expect("创建套接字失败");
    
    // 设置服务器地址
    let server_addr: SocketAddr = "127.0.0.1:8080".parse().expect("解析地址失败");
    
    // 发送数据到服务器
    let message = "你好，UDP通信！";
    socket.send_to(message.as_bytes(), server_addr).expect("发送数据失败");
    
    // 接收服务器响应
    let mut buffer = [0; 1024];
    match socket.recv_from(&mut buffer) {
        Ok((size, addr)) => {
            let response = String::from_utf8_lossy(&buffer[..size]);
            println!("从 {} 接收到响应: {}", addr, response);
        },
        Err(e) => {
            eprintln!("接收响应错误: {:?}", e);
        }
    }
}

多线程服务器架构:
主线程: 接受新连接 → 创建工作线程 → 继续接受连接
  ↓
工作线程1: 处理客户端1的请求
  ↓
工作线程2: 处理客户端2的请求
  ↓
...

// 简单的线程池实现
use std::sync::mpsc;
use std::sync::Arc;
use std::sync::Mutex;
use std::thread;

// 任务类型
type Job = Box<dyn FnOnce() + Send + 'static>;

// 工作线程
struct Worker {
    id: usize,
    thread: Option<thread::JoinHandle<()>>,
}

impl Worker {
    fn new(id: usize, receiver: Arc<Mutex<mpsc::Receiver<Job>>>) -> Worker {
        let thread = thread::spawn(move || loop {
            let job = receiver.lock().unwrap().recv();
            
            match job {
                Ok(job) => {
                    println!("工作线程 {} 执行任务", id);
                    job();
                },
                Err(_) => {
                    println!("工作线程 {} 断开连接", id);
                    break;
                }
            }
        });
        
        Worker {
            id,
            thread: Some(thread),
        }
    }
}

// 线程池
pub struct ThreadPool {
    workers: Vec<Worker>,
    sender: mpsc::Sender<Job>,
}

impl ThreadPool {
    // 创建新的线程池
    pub fn new(size: usize) -> ThreadPool {
        assert!(size > 0);
        
        let (sender, receiver) = mpsc::channel();
        let receiver = Arc::new(Mutex::new(receiver));
        
        let mut workers = Vec::with_capacity(size);
        
        for id in 0..size {
            workers.push(Worker::new(id, Arc::clone(&receiver)));
        }
        
        ThreadPool {
            workers,
            sender,
        }
    }
    
    // 执行任务
    pub fn execute<F>(&self, f: F)
    where
        F: FnOnce() + Send + 'static,
    {
        let job = Box::new(f);
        self.sender.send(job).unwrap();
    }
}

impl Drop for ThreadPool {
    fn drop(&mut self) {
        // 关闭发送端，使所有工作线程退出循环
        drop(&self.sender);
        
        // 等待所有工作线程结束
        for worker in &mut self.workers {
            println!("等待工作线程 {} 结束", worker.id);
            
            if let Some(thread) = worker.thread.take() {
                thread.join().unwrap();
            }
        }
    }
}

// 使用线程池的多线程TCP服务器
use std::io::{Read, Write};
use std::net::{TcpListener, TcpStream};

// 导入上面实现的ThreadPool
// use crate::thread_pool::ThreadPool;

fn handle_client(mut stream: TcpStream) {
    let mut buffer = [0; 1024];
    
    // 读取客户端发送的数据
    match stream.read(&mut buffer) {
        Ok(size) => {
            // 处理接收到的数据
            let received = String::from_utf8_lossy(&buffer[..size]);
            println!("接收到数据: {}", received);
            
            // 发送响应数据
            let response = "数据已收到";
            stream.write(response.as_bytes()).expect("发送响应失败");
        },
        Err(e) => {
            eprintln!("读取数据错误: {:?}", e);
        }
    }
}

fn main() {
    // 绑定服务器地址和端口
    let listener = TcpListener::bind("127.0.0.1:8080").expect("绑定端口失败");
    println!("多线程服务器启动，监听端口8080...");
    
    // 创建线程池，包含4个工作线程
    let pool = ThreadPool::new(4);
    
    // 接受客户端连接
    for stream in listener.incoming() {
        match stream {
            Ok(stream) => {
                // 提交任务到线程池
                pool.execute(|| {
                    handle_client(stream);
                });
            },
            Err(e) => {
                eprintln!("连接错误: {:?}", e);
            }
        }
    }
}

事件循环模型:
事件循环 → 检查事件 → 处理就绪事件 → 再次检查事件
  ↓            ↓              ↓
新连接      可读数据      可写数据

// 使用Tokio的事件驱动TCP服务器
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use tokio::net::{TcpListener, TcpStream};
use tokio::sync::broadcast;

#[tokio::main]
async fn main() {
    // 绑定服务器地址和端口
    let listener = TcpListener::bind("127.0.0.1:8080").await.expect("绑定端口失败");
    println!("事件驱动服务器启动，监听端口8080...");
    
    // 创建广播通道，用于在客户端之间广播消息
    let (tx, _) = broadcast::channel(10);
    
    // 接受客户端连接
    loop {
        let (socket, addr) = listener.accept().await.expect("接受连接失败");
        println!("客户端 {} 已连接", addr);
        
        // 为每个客户端创建一个新的异步任务处理
        let tx = tx.clone();
        let mut rx = tx.subscribe();
        
        tokio::spawn(async move {
            handle_client(socket, addr, tx, rx).await;
        });
    }
}

// 处理客户端连接的异步函数
async fn handle_client(
    mut socket: TcpStream,
    addr: std::net::SocketAddr,
    tx: broadcast::Sender<String>,
    mut rx: broadcast::Receiver<String>,
) {
    let mut buffer = [0; 1024];
    let (mut reader, mut writer) = socket.split();
    
    // 创建两个任务，一个用于读取客户端数据，一个用于向客户端发送数据
    let read_task = tokio::spawn(async move {
        loop {
            match reader.read(&mut buffer).await {
                Ok(0) => {
                    // 连接关闭
                    println!("客户端 {} 已断开连接", addr);
                    break;
                },
                Ok(size) => {
                    // 处理接收到的数据
                    let received = String::from_utf8_lossy(&buffer[..size]);
                    println!("从 {} 接收到数据: {}", addr, received);
                    
                    // 广播消息给其他客户端
                    let message = format!("[{}]: {}", addr, received);
                    if let Err(e) = tx.send(message) {
                        eprintln!("广播消息失败: {:?}", e);
                    }
                },
                Err(e) => {
                    eprintln!("读取数据错误: {:?}", e);
                    break;
                }
            }
        }
    });
    
    let write_task = tokio::spawn(async move {
        loop {
            // 接收广播消息
            match rx.recv().await {
                Ok(message) => {
                    // 发送消息给客户端
                    if let Err(e) = writer.write_all(message.as_bytes()).await {
                        eprintln!("发送消息失败: {:?}", e);
                        break;
                    }
                },
                Err(e) => {
                    eprintln!("接收广播消息失败: {:?}", e);
                    break;
                }
            }
        }
    });
    
    // 等待任一任务完成
    tokio::select! {
        _ = read_task => {},
        _ = write_task => {},
    }
}

自定义协议设计步骤:
1. 确定协议的目的和范围
2. 定义消息格式和数据结构
3. 设计状态机和交互流程
4. 实现协议编解码逻辑
5. 测试和验证协议实现

// 简单的自定义协议实现
use std::io::{Read, Write};
use std::net::{TcpListener, TcpStream};
use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt};

// 消息类型枚举
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum MessageType {
    Request = 1,
    Response = 2,
    Error = 3,
}

// 消息结构体
#[derive(Debug)]
struct Message {
    msg_type: MessageType,
    payload: Vec<u8>,
}

impl Message {
    // 创建新的消息
    fn new(msg_type: MessageType, payload: Vec<u8>) -> Self {
        Message {
            msg_type,
            payload,
        }
    }
    
    // 编码消息为字节序列
    fn encode(&self) -> Vec<u8> {
        let mut buffer = Vec::new();
        
        // 写入消息类型（1字节）
        buffer.write_u8(self.msg_type as u8).unwrap();
        
        // 写入 payload 长度（4字节，大端序）
        buffer.write_u32::<BigEndian>(self.payload.len() as u32).unwrap();
        
        // 写入 payload 数据
        buffer.extend(&self.payload);
        
        buffer
    }
    
    // 从字节序列解码消息
    fn decode(mut reader: impl Read) -> Result<Self, std::io::Error> {
        // 读取消息类型
        let msg_type = match reader.read_u8()? {
            1 => MessageType::Request,
            2 => MessageType::Response,
            3 => MessageType::Error,
            _ => return Err(std::io::Error::new(
                std::io::ErrorKind::InvalidData,
                "无效的消息类型"
            )),
        };
        
        // 读取 payload 长度
        let payload_len = reader.read_u32::<BigEndian>()?;
        
        // 读取 payload 数据
        let mut payload = vec![0; payload_len as usize];
        reader.read_exact(&mut payload)?;
        
        Ok(Message {
            msg_type,
            payload,
        })
    }
}

// 使用自定义协议的服务器
fn protocol_server() {
    let listener = TcpListener::bind("127.0.0.1:8080").expect("绑定端口失败");
    println!("自定义协议服务器启动，监听端口8080...");
    
    for stream in listener.incoming() {
        match stream {
            Ok(mut stream) => {
                // 解码客户端发送的消息
                match Message::decode(&mut stream) {
                    Ok(message) => {
                        println!("接收到消息: {:?}", message);
                        
                        // 处理请求消息
                        if message.msg_type == MessageType::Request {
                            // 从payload中提取请求内容
                            let request = String::from_utf8_lossy(&message.payload);
                            println!("请求内容: {}", request);
                            
                            // 创建响应消息
                            let response_content = format!("收到请求: {}", request);
                            let response = Message::new(
                                MessageType::Response,
                                response_content.into_bytes()
                            );
                            
                            // 发送响应消息
                            let encoded_response = response.encode();
                            stream.write_all(&encoded_response).expect("发送响应失败");
                        }
                    },
                    Err(e) => {
                        eprintln!("解码消息错误: {:?}", e);
                        
                        // 发送错误消息
                        let error_message = Message::new(
                            MessageType::Error,
                            format!("解码错误: {:?}", e).into_bytes()
                        );
                        let encoded_error = error_message.encode();
                        stream.write_all(&encoded_error).expect("发送错误消息失败");
                    },
                }
            },
            Err(e) => {
                eprintln!("连接错误: {:?}", e);
            }
        }
    }
}

// 使用自定义协议的客户端
fn protocol_client() {
    let mut stream = TcpStream::connect("127.0.0.1:8080").expect("连接服务器失败");
    
    // 创建请求消息
    let request_content = "你好，自定义协议！";
    let request = Message::new(
        MessageType::Request,
        request_content.into_bytes()
    );
    
    // 发送请求消息
    let encoded_request = request.encode();
    stream.write_all(&encoded_request).expect("发送请求失败");
    
    // 接收并解码响应消息
    match Message::decode(&mut stream) {
        Ok(response) => {
            println!("收到响应: {:?}", response);
            
            // 从payload中提取响应内容
            let response_content = String::from_utf8_lossy(&response.payload);
            println!("响应内容: {}", response_content);
        },
        Err(e) => {
            eprintln!("解码响应错误: {:?}", e);
        },
    }
}

fn main() {
    // 根据需要调用服务器或客户端函数
    // protocol_server();
    // protocol_client();
}

AI威胁检测流程:
数据收集 → 数据预处理 → 特征提取 → 模型训练 → 威胁检测 → 告警响应
  ↓         ↓             ↓           ↓            ↓          ↓
网络流量  数据清洗     特征工程   机器学习   异常识别   安全措施

// 简单的AI威胁检测系统示例
use std::collections::HashMap;
use std::fs::File;
use std::io::{BufRead, BufReader};
use std::net::{TcpListener, TcpStream};
use std::sync::Arc;
use std::sync::Mutex;
use std::thread;
use std::time::Duration;

// 简单的异常检测模型
struct AnomalyDetector {
    // 存储正常流量的统计数据
    stats: HashMap<String, (f64, f64)>, // (均值, 标准差)
    threshold: f64, // 异常阈值（标准差倍数）
}

impl AnomalyDetector {
    // 创建新的异常检测器
    fn new(threshold: f64) -> Self {
        AnomalyDetector {
            stats: HashMap::new(),
            threshold,
        }
    }
    
    // 加载训练数据，计算统计信息
    fn load_training_data(&mut self, file_path: &str) {
        let file = File::open(file_path).expect("无法打开训练数据文件");
        let reader = BufReader::new(file);
        
        // 临时存储每个特征的所有值
        let mut feature_values: HashMap<String, Vec<f64>> = HashMap::new();
        
        // 读取文件中的每行数据
        for line in reader.lines() {
            if let Ok(line) = line {
                let parts: Vec<&str> = line.split(',').collect();
                if parts.len() >= 2 {
                    let feature = parts[0].to_string();
                    if let Ok(value) = parts[1].parse::<f64>() {
                        feature_values.entry(feature).or_insert_with(Vec::new).push(value);
                    }
                }
            }
        }
        
        // 计算每个特征的均值和标准差
        for (feature, values) in feature_values {
            let mean = calculate_mean(&values);
            let std_dev = calculate_std_dev(&values, mean);
            self.stats.insert(feature, (mean, std_dev));
        }
    }
    
    // 检测异常
    fn detect_anomaly(&self, feature: &str, value: f64) -> bool {
        if let Some(&(mean, std_dev)) = self.stats.get(feature) {
            let z_score = (value - mean).abs() / std_dev;
            z_score > self.threshold
        } else {
            // 如果特征不在统计数据中，默认不认为是异常
            false
        }
    }
    
    // 更新统计数据
    fn update_stats(&mut self, feature: &str, value: f64) {
        if let Some(&(mut mean, mut std_dev)) = self.stats.get(feature) {
            // 简单的增量更新（实际应用中应该使用更复杂的算法）
            let count = 100.0; // 假设已经有100个样本
            let new_mean = (mean * count + value) / (count + 1.0);
            let new_std_dev = ((std_dev.powi(2) * count) + (value - new_mean).powi(2)) / (count + 1.0).sqrt();
            self.stats.insert(feature.to_string(), (new_mean, new_std_dev));
        } else {
            // 如果是新特征，直接添加
            self.stats.insert(feature.to_string(), (value, 0.0));
        }
    }
}

// 计算均值
fn calculate_mean(values: &[f64]) -> f64 {
    if values.is_empty() {
        return 0.0;
    }
    values.iter().sum::<f64>() / values.len() as f64
}

// 计算标准差
fn calculate_std_dev(values: &[f64], mean: f64) -> f64 {
    if values.len() <= 1 {
        return 0.0;
    }
    let variance = values.iter().map(|&x| (x - mean).powi(2)).sum::<f64>() / (values.len() - 1) as f64;
    variance.sqrt()
}

// 网络流量监控器
struct NetworkMonitor {
    detector: Arc<Mutex<AnomalyDetector>>,
}

impl NetworkMonitor {
    // 创建新的网络监控器
    fn new(detector: AnomalyDetector) -> Self {
        NetworkMonitor {
            detector: Arc::new(Mutex::new(detector)),
        }
    }
    
    // 监控网络连接
    fn monitor_connection(&self, stream: TcpStream) {
        let peer_addr = stream.peer_addr().unwrap();
        println!("开始监控连接: {}", peer_addr);
        
        // 获取连接的基本信息
        let local_addr = stream.local_addr().unwrap();
        let protocol = "TCP";
        
        // 模拟收集一些网络流量特征
        let packet_size = 1024.0 + rand::random::<f64>() * 4096.0; // 随机包大小
        let packet_rate = 10.0 + rand::random::<f64>() * 50.0; // 随机包速率
        
        // 检测异常
        let detector = self.detector.lock().unwrap();
        let size_anomaly = detector.detect_anomaly("packet_size", packet_size);
        let rate_anomaly = detector.detect_anomaly("packet_rate", packet_rate);
        
        // 如果检测到异常，输出告警
        if size_anomaly || rate_anomaly {
            println!("🚨 异常检测告警 🚨");
            println!("连接: {} -> {}", peer_addr, local_addr);
            println!("协议: {}", protocol);
            if size_anomaly {
                println!("⚠️  异常包大小: {:.2}", packet_size);
            }
            if rate_anomaly {
                println!("⚠️  异常包速率: {:.2} 包/秒", packet_rate);
            }
            println!("------------------------");
        }
        
        // 更新统计数据（在实际应用中应该在线更新）
        // drop(detector);
        // let mut detector = self.detector.lock().unwrap();
        // detector.update_stats("packet_size", packet_size);
        // detector.update_stats("packet_rate", packet_rate);
    }
    
    // 启动监控服务器
    fn start(&self) {
        let listener = TcpListener::bind("127.0.0.1:8080").expect("绑定端口失败");
        println!("AI威胁检测系统启动，监听端口8080...");
        
        for stream in listener.incoming() {
            match stream {
                Ok(stream) => {
                    let monitor = self.clone();
                    thread::spawn(move || {
                        monitor.monitor_connection(stream);
                    });
                },
                Err(e) => {
                    eprintln!("连接错误: {:?}", e);
                }
            }
        }
    }
}

// 实现Clone trait
impl Clone for NetworkMonitor {
    fn clone(&self) -> Self {
        NetworkMonitor {
            detector: Arc::clone(&self.detector),
        }
    }
}

fn main() {
    // 创建异常检测器，设置阈值为3.0（超过均值3个标准差认为是异常）
    let mut detector = AnomalyDetector::new(3.0);
    
    // 加载训练数据（实际应用中应该有真实的训练数据）
    // detector.load_training_data("training_data.csv");
    
    // 手动添加一些样本统计数据（因为没有真实的训练数据）
    detector.stats.insert("packet_size".to_string(), (1500.0, 500.0)); // 均值1500，标准差500
    detector.stats.insert("packet_rate".to_string(), (20.0, 10.0)); // 均值20，标准差10
    
    // 创建网络监控器
    let monitor = NetworkMonitor::new(detector);
    
    // 启动监控服务器
    monitor.start();
}

网络流量特征类型:
- 基本特征: 包大小、包速率、连接数、字节数等
- 时序特征: 流量的时间分布、周期性等
- 协议特征: 协议分布、端口分布、请求方法分布等
- 行为特征: 连接持续时间、重试次数、失败率等

// 简单的网络流量分析器
use std::collections::HashMap;
use std::net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr};
use std::sync::Arc;
use std::sync::Mutex;
use std::time::{Duration, Instant};

// 流量统计数据
struct FlowStats {
    total_bytes: u64,
    total_packets: u64,
    start_time: Instant,
    last_seen: Instant,
}

impl FlowStats {
    // 创建新的流量统计数据
    fn new() -> Self {
        let now = Instant::now();
        FlowStats {
            total_bytes: 0,
            total_packets: 0,
            start_time: now,
            last_seen: now,
        }
    }
    
    // 更新流量统计数据
    fn update(&mut self, bytes: u64) {
        self.total_bytes += bytes;
        self.total_packets += 1;
        self.last_seen = Instant::now();
    }
    
    // 获取流量持续时间
    fn duration(&self) -> Duration {
        self.last_seen.duration_since(self.start_time)
    }
    
    // 获取平均流量速率（字节/秒）
    fn average_rate(&self) -> f64 {
        let duration = self.duration().as_secs_f64();
        if duration > 0.0 {
            self.total_bytes as f64 / duration
        } else {
            0.0
        }
    }
}

// 网络流量分析器
struct TrafficAnalyzer {
    // 存储每个连接的流量统计数据
    connection_stats: Arc<Mutex<HashMap<SocketAddr, FlowStats>>>,
    // 存储每个IP地址的流量统计数据
    ip_stats: Arc<Mutex<HashMap<IpAddr, FlowStats>>>,
    // 清理间隔（秒）
    cleanup_interval: Duration,
}

impl TrafficAnalyzer {
    // 创建新的流量分析器
    fn new(cleanup_interval: Duration) -> Self {
        TrafficAnalyzer {
            connection_stats: Arc::new(Mutex::new(HashMap::new())),
            ip_stats: Arc::new(Mutex::new(HashMap::new())),
            cleanup_interval,
        }
    }
    
    // 记录网络流量
    fn record_traffic(&self, source: SocketAddr, dest: SocketAddr, bytes: u64) {
        // 更新连接统计数据
        {
            let mut connection_stats = self.connection_stats.lock().unwrap();
            // 更新源到目标的连接统计
            connection_stats
                .entry(source)
                .or_insert_with(FlowStats::new)
                .update(bytes);
            // 更新目标到源的连接统计
            connection_stats
                .entry(dest)
                .or_insert_with(FlowStats::new)
                .update(bytes);
        }
        
        // 更新IP统计数据
        {
            let mut ip_stats = self.ip_stats.lock().unwrap();
            // 更新源IP的统计
            ip_stats
                .entry(source.ip())
                .or_insert_with(FlowStats::new)
                .update(bytes);
            // 更新目标IP的统计
            ip_stats
                .entry(dest.ip())
                .or_insert_with(FlowStats::new)
                .update(bytes);
        }
    }
    
    // 检测异常流量
    fn detect_anomalies(&self) -> Vec<Anomaly> {
        let mut anomalies = Vec::new();
        let now = Instant::now();
        
        // 检查连接统计数据
        {
            let connection_stats = self.connection_stats.lock().unwrap();
            for (addr, stats) in connection_stats.iter() {
                // 检查连接持续时间
                let duration = stats.duration().as_secs();
                if duration > 3600 { // 超过1小时的连接可能是异常
                    anomalies.push(Anomaly::new(
                        AnomalyType::LongLivedConnection,
                        format!("长时间连接: {} (持续时间: {}秒)", addr, duration)
                    ));
                }
                
                // 检查流量速率
                let rate = stats.average_rate();
                if rate > 10_000_000.0 { // 超过10MB/s的流量可能是异常
                    anomalies.push(Anomaly::new(
                        AnomalyType::HighTrafficRate,
                        format!("高流量速率: {} ({:.2} MB/s)", addr, rate / 1_000_000.0)
                    ));
                }
                
                // 检查数据包数量
                if stats.total_packets > 100_000 { // 超过10万个数据包可能是异常
                    anomalies.push(Anomaly::new(
                        AnomalyType::HighPacketCount,
                        format!("高数据包数量: {} ({})", addr, stats.total_packets)
                    ));
                }
                
                // 检查连接是否过期
                if now.duration_since(stats.last_seen) > self.cleanup_interval {
                    // 在实际应用中，这里应该清理过期的连接统计数据
                }
            }
        }
        
        // 检查IP统计数据
        {
            let ip_stats = self.ip_stats.lock().unwrap();
            for (ip, stats) in ip_stats.iter() {
                // 检查IP的总流量
                if stats.total_bytes > 1_000_000_000 { // 超过1GB的流量可能是异常
                    anomalies.push(Anomaly::new(
                        AnomalyType::HighTotalTraffic,
                        format!("高总流量: {} ({:.2} GB)", ip, stats.total_bytes as f64 / 1_000_000_000.0)
                    ));
                }
            }
        }
        
        anomalies
    }
    
    // 启动定期清理任务
    fn start_cleanup_task(&self) {
        let connection_stats = Arc::clone(&self.connection_stats);
        let cleanup_interval = self.cleanup_interval;
        
        std::thread::spawn(move || {
            loop {
                std::thread::sleep(cleanup_interval);
                
                let now = Instant::now();
                let mut connection_stats = connection_stats.lock().unwrap();
                
                // 清理过期的连接统计数据
                connection_stats.retain(|_addr, stats| {
                    now.duration_since(stats.last_seen) <= cleanup_interval
                });
                
                println!("清理后剩余连接数: {}", connection_stats.len());
            }
        });
    }
}

// 异常类型枚举
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum AnomalyType {
    LongLivedConnection,
    HighTrafficRate,
    HighPacketCount,
    HighTotalTraffic,
    SuspiciousPattern,
}

// 异常结构体
#[derive(Debug)]
struct Anomaly {
    anomaly_type: AnomalyType,
    description: String,
}

impl Anomaly {
    // 创建新的异常
    fn new(anomaly_type: AnomalyType, description: String) -> Self {
        Anomaly {
            anomaly_type,
            description,
        }
    }
}

fn main() {
    // 创建流量分析器，设置清理间隔为5分钟
    let analyzer = TrafficAnalyzer::new(Duration::from_secs(300));
    
    // 启动清理任务
    analyzer.start_cleanup_task();
    
    // 模拟记录一些网络流量
    let source1: SocketAddr = "192.168.1.100:54321".parse().unwrap();
    let dest1: SocketAddr = "10.0.0.1:80".parse().unwrap();
    
    let source2: SocketAddr = "192.168.1.101:54322".parse().unwrap();
    let dest2: SocketAddr = "10.0.0.1:80".parse().unwrap();
    
    // 记录正常流量
    for _ in 0..100 {
        analyzer.record_traffic(source1, dest1, 1500);
        analyzer.record_traffic(source2, dest2, 1200);
        std::thread::sleep(Duration::from_millis(10));
    }
    
    // 记录可能的异常流量
    analyzer.record_traffic(source1, dest1, 10_000_000); // 大流量
    
    // 检测异常
    let anomalies = analyzer.detect_anomalies();
    
    // 输出检测结果
    if !anomalies.is_empty() {
        println!("🚨 检测到异常流量 🚨");
        for anomaly in anomalies {
            println!("- {:?}: {}", anomaly.anomaly_type, anomaly.description);
        }
    } else {
        println!("✅ 未检测到异常流量");
    }
}

自动安全响应工作流:
威胁检测 → 风险评估 → 响应决策 → 执行响应 → 效果评估
  ↓          ↓            ↓            ↓          ↓
识别异常  确定严重程度 选择响应策略 采取安全措施 验证措施效果

// 简单的自动安全响应系统
use std::collections::HashMap;
use std::net::{IpAddr, SocketAddr};
use std::sync::Arc;
use std::sync::Mutex;
use std::thread;
use std::time::{Duration, Instant};

// 响应动作枚举
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum ResponseAction {
    Alert,
    BlockIP,
    BlockPort,
    RateLimit,
    Quarantine,
}

// 安全事件结构体
#[derive(Debug)]
struct SecurityEvent {
    event_id: String,
    event_type: String,
    source: SocketAddr,
    severity: u32, // 1-低, 2-中, 3-高, 4-严重
    timestamp: Instant,
    description: String,
}

impl SecurityEvent {
    // 创建新的安全事件
    fn new(event_type: String, source: SocketAddr, severity: u32, description: String) -> Self {
        // 生成简单的事件ID
        let timestamp = Instant::now();
        let event_id = format!("{}-{:?}", event_type, timestamp);
        
        SecurityEvent {
            event_id,
            event_type,
            source,
            severity,
            timestamp,
            description,
        }
    }
}

// 安全策略结构体
struct SecurityPolicy {
    // 不同严重程度的事件对应的响应动作
    severity_responses: HashMap<u32, Vec<ResponseAction>>,
    // 被阻止的IP地址列表
    blocked_ips: Arc<Mutex<HashMap<IpAddr, Instant>>>,
    // 被阻止的端口列表
    blocked_ports: Arc<Mutex<HashMap<u16, Instant>>>,
    // 阻止的持续时间
    block_duration: Duration,
}

impl SecurityPolicy {
    // 创建新的安全策略
    fn new(block_duration: Duration) -> Self {
        let mut severity_responses = HashMap::new();
        
        // 配置不同严重程度的响应动作
        severity_responses.insert(1, vec![ResponseAction::Alert]);
        severity_responses.insert(2, vec![ResponseAction::Alert, ResponseAction::RateLimit]);
        severity_responses.insert(3, vec![ResponseAction::Alert, ResponseAction::BlockIP]);
        severity_responses.insert(4, vec![ResponseAction::Alert, ResponseAction::BlockIP, ResponseAction::Quarantine]);
        
        SecurityPolicy {
            severity_responses,
            blocked_ips: Arc::new(Mutex::new(HashMap::new())),
            blocked_ports: Arc::new(Mutex::new(HashMap::new())),
            block_duration,
        }
    }
    
    // 根据安全事件确定响应动作
    fn determine_actions(&self, event: &SecurityEvent) -> Vec<ResponseAction> {
        if let Some(actions) = self.severity_responses.get(&event.severity) {
            actions.clone()
        } else {
            // 默认只发送告警
            vec![ResponseAction::Alert]
        }
    }
    
    // 检查IP是否被阻止
    fn is_ip_blocked(&self, ip: &IpAddr) -> bool {
        let blocked_ips = self.blocked_ips.lock().unwrap();
        if let Some(block_time) = blocked_ips.get(ip) {
            // 检查阻止是否已过期
            Instant::now().duration_since(*block_time) < self.block_duration
        } else {
            false
        }
    }
    
    // 检查端口是否被阻止
    fn is_port_blocked(&self, port: u16) -> bool {
        let blocked_ports = self.blocked_ports.lock().unwrap();
        if let Some(block_time) = blocked_ports.get(&port) {
            // 检查阻止是否已过期
            Instant::now().duration_since(*block_time) < self.block_duration
        } else {
            false
        }
    }
    
    // 执行响应动作
    fn execute_actions(&self, event: &SecurityEvent, actions: &[ResponseAction]) {
        println!("执行响应动作 for 事件: {}", event.event_id);
        
        for action in actions {
            match action {
                ResponseAction::Alert => {
                    self.send_alert(event);
                },
                ResponseAction::BlockIP => {
                    self.block_ip(event.source.ip());
                },
                ResponseAction::BlockPort => {
                    self.block_port(event.source.port());
                },
                ResponseAction::RateLimit => {
                    self.rate_limit(event.source);
                },
                ResponseAction::Quarantine => {
                    self.quarantine(event.source.ip());
                },
            }
        }
    }
    
    // 发送告警
    fn send_alert(&self, event: &SecurityEvent) {
        println!("🚨 安全告警 🚨");
        println!("事件ID: {}", event.event_id);
        println!("事件类型: {}", event.event_type);
        println!("源地址: {}", event.source);
        println!("严重程度: {}", event.severity);
        println!("描述: {}", event.description);
        println!("------------------------");
    }
    
    // 阻止IP地址
    fn block_ip(&self, ip: IpAddr) {
        println!("🔒 阻止IP地址: {}", ip);
        let mut blocked_ips = self.blocked_ips.lock().unwrap();
        blocked_ips.insert(ip, Instant::now());
    }
    
    // 阻止端口
    fn block_port(&self, port: u16) {
        println!("🔒 阻止端口: {}", port);
        let mut blocked_ports = self.blocked_ports.lock().unwrap();
        blocked_ports.insert(port, Instant::now());
    }
    
    // 限速
    fn rate_limit(&self, source: SocketAddr) {
        println!("⏱️  限制源地址的速率: {}", source);
        // 实际应用中应该配置网络设备或应用层的速率限制
    }
    
    // 隔离
    fn quarantine(&self, ip: IpAddr) {
        println!("🛡️  隔离IP地址: {}", ip);
        // 实际应用中应该将IP地址移动到隔离网络区域
    }
    
    // 启动定期清理任务，移除过期的阻止记录
    fn start_cleanup_task(&self) {
        let blocked_ips = Arc::clone(&self.blocked_ips);
        let blocked_ports = Arc::clone(&self.blocked_ports);
        let block_duration = self.block_duration;
        
        thread::spawn(move || {
            loop {
                thread::sleep(block_duration / 2);
                let now = Instant::now();
                
                // 清理过期的IP阻止记录
                {
                    let mut blocked_ips = blocked_ips.lock().unwrap();
                    blocked_ips.retain(|_ip, block_time| {
                        now.duration_since(*block_time) < block_duration
                    });
                }
                
                // 清理过期的端口阻止记录
                {
                    let mut blocked_ports = blocked_ports.lock().unwrap();
                    blocked_ports.retain(|_port, block_time| {
                        now.duration_since(*block_time) < block_duration
                    });
                }
                
                println!("清理过期的阻止记录完成");
            }
        });
    }
}

// 自动安全响应系统
struct AutoResponseSystem {
    policy: SecurityPolicy,
    // 事件队列
    event_queue: Arc<Mutex<Vec<SecurityEvent>>>,
    // 最大处理线程数
    max_threads: usize,
}

impl AutoResponseSystem {
    // 创建新的自动响应系统
    fn new(policy: SecurityPolicy, max_threads: usize) -> Self {
        AutoResponseSystem {
            policy,
            event_queue: Arc::new(Mutex::new(Vec::new())),
            max_threads,
        }
    }
    
    // 添加安全事件到队列
    fn add_event(&self, event: SecurityEvent) {
        let mut event_queue = self.event_queue.lock().unwrap();
        event_queue.push(event);
    }
    
    // 启动事件处理线程池
    fn start_processing(&self) {
        // 启动策略的清理任务
        self.policy.start_cleanup_task();
        
        let policy = &self.policy;
        let event_queue = Arc::clone(&self.event_queue);
        
        // 创建固定数量的处理线程
        for i in 0..self.max_threads {
            let policy = policy.clone();
            let event_queue = Arc::clone(&event_queue);
            
            thread::spawn(move || {
                println!("启动事件处理线程 {}", i);
                loop {
                    // 从队列中获取一个事件
                    let event = {
                        let mut event_queue = event_queue.lock().unwrap();
                        event_queue.pop()
                    };
                    
                    if let Some(event) = event {
                        // 确定响应动作
                        let actions = policy.determine_actions(&event);
                        
                        // 执行响应动作
                        policy.execute_actions(&event, &actions);
                    } else {
                        // 如果队列为空，短暂休眠避免CPU占用过高
                        thread::sleep(Duration::from_millis(100));
                    }
                }
            });
        }
    }
    
    // 检查连接是否被允许
    fn is_connection_allowed(&self, source: &SocketAddr) -> bool {
        // 检查IP是否被阻止
        if self.policy.is_ip_blocked(&source.ip()) {
            return false;
        }
        
        // 检查端口是否被阻止
        if self.policy.is_port_blocked(source.port()) {
            return false;
        }
        
        // 连接被允许
        true
    }
}

// 实现Clone trait
impl Clone for SecurityPolicy {
    fn clone(&self) -> Self {
        SecurityPolicy {
            severity_responses: self.severity_responses.clone(),
            blocked_ips: Arc::clone(&self.blocked_ips),
            blocked_ports: Arc::clone(&self.blocked_ports),
            block_duration: self.block_duration,
        }
    }
}

fn main() {
    // 创建安全策略，设置阻止持续时间为1小时
    let policy = SecurityPolicy::new(Duration::from_secs(3600));
    
    // 创建自动响应系统，设置最大处理线程数为4
    let response_system = AutoResponseSystem::new(policy, 4);
    
    // 启动事件处理
    response_system.start_processing();
    
    // 模拟生成一些安全事件
    let source1: SocketAddr = "192.168.1.100:54321".parse().unwrap();
    let source2: SocketAddr = "192.168.1.101:54322".parse().unwrap();
    
    // 添加低严重性事件
    let event1 = SecurityEvent::new(
        "可疑访问".to_string(),
        source1,
        1,
        "检测到来自该IP的可疑扫描活动".to_string()
    );
    response_system.add_event(event1);
    
    // 添加中严重性事件
    let event2 = SecurityEvent::new(
        "暴力破解尝试".to_string(),
        source2,
        2,
        "检测到多次失败的登录尝试".to_string()
    );
    response_system.add_event(event2);
    
    // 添加高严重性事件
    let event3 = SecurityEvent::new(
        "恶意软件通信".to_string(),
        source1,
        3,
        "检测到与已知恶意软件C&C服务器的通信".to_string()
    );
    response_system.add_event(event3);
    
    // 添加严重事件
    let event4 = SecurityEvent::new(
        "数据泄露尝试".to_string(),
        source2,
        4,
        "检测到大量敏感数据外发".to_string()
    );
    response_system.add_event(event4);
    
    // 模拟检查连接是否被允许
    thread::sleep(Duration::from_secs(1)); // 等待事件处理完成
    
    println!("\n检查连接是否被允许:");
    println!("源地址 {}: {}", source1, if response_system.is_connection_allowed(&source1) { "允许" } else { "阻止" });
    println!("源地址 {}: {}", source2, if response_system.is_connection_allowed(&source2) { "允许" } else { "阻止" });
    
    // 保持程序运行一段时间
    thread::sleep(Duration::from_secs(5));
}

TLS握手过程:
1. 客户端发送ClientHello消息，包含支持的协议版本、加密套件等
2. 服务器发送ServerHello消息，包含选择的协议版本、加密套件等
3. 服务器发送证书，供客户端验证服务器身份
4. 服务器发送ServerHelloDone消息
5. 客户端验证服务器证书，然后生成预主密钥，并使用服务器公钥加密发送给服务器
6. 客户端和服务器基于预主密钥生成会话密钥
7. 客户端发送Finished消息，使用会话密钥加密
8. 服务器发送Finished消息，使用会话密钥加密
9. 握手完成，后续通信使用会话密钥加密

// 使用Rustls实现TLS服务器示例
use rustls_pemfile::{certs, rsa_private_keys};
use std::fs::File;
use std::io::{self, BufReader, Read, Write};
use std::net::TcpListener;
use std::sync::Arc;

fn main() {
    // 设置TLS证书和私钥
    let cert_file = &mut BufReader::new(File::open("server.crt").expect("无法打开证书文件"));
    let key_file = &mut BufReader::new(File::open("server.key").expect("无法打开私钥文件"));
    
    // 读取证书链
    let cert_chain = certs(cert_file)
        .expect("无法读取证书")
        .into_iter()
        .map(rustls::Certificate)
        .collect();
    
    // 读取私钥
    let mut keys = rsa_private_keys(key_file)
        .expect("无法读取私钥");
    let private_key = rustls::PrivateKey(keys.remove(0));
    
    // 创建TLS配置
    let mut tls_config = rustls::ServerConfig::builder()
        .with_safe_defaults()
        .with_no_client_auth()
        .with_single_cert(cert_chain, private_key)
        .expect("无法创建TLS配置");
    
    // 设置ALPN协议（可选）
    tls_config.alpn_protocols = vec![b"h2".to_vec(), b"http/1.1".to_vec()];
    
    // 创建TLS服务器
    let tls_config = Arc::new(tls_config);
    let tcp_listener = TcpListener::bind("127.0.0.1:8443").expect("无法绑定端口");
    
    println!("TLS服务器启动，监听端口8443...");
    
    // 接受客户端连接
    for stream in tcp_listener.incoming() {
        match stream {
            Ok(stream) => {
                // 为每个客户端创建一个新线程处理
                let tls_config = Arc::clone(&tls_config);
                std::thread::spawn(move || {
                    handle_tls_connection(stream, tls_config);
                });
            },
            Err(e) => {
                eprintln!("连接错误: {:?}", e);
            }
        }
    }
}

// 处理TLS连接
fn handle_tls_connection(
    stream: std::net::TcpStream,
    config: Arc<rustls::ServerConfig>,
) {
    let peer_addr = stream.peer_addr().unwrap();
    println!("接受来自 {} 的TLS连接", peer_addr);
    
    // 创建TLS会话
    let mut tls_session = rustls::ServerConnection::new(Arc::clone(&config)).unwrap();
    let mut tls_stream = rustls::Stream::new(&mut tls_session, stream);
    
    // 读取客户端发送的数据
    let mut buffer = [0; 1024];
    match tls_stream.read(&mut buffer) {
        Ok(size) => {
            let received = String::from_utf8_lossy(&buffer[..size]);
            println!("接收到数据: {}", received);
            
            // 发送响应数据
            let response = "安全连接已建立，数据已收到";
            tls_stream.write(response.as_bytes()).expect("发送响应失败");
        },
        Err(e) => {
            eprintln!("读取数据错误: {:?}", e);
        }
    }
}

// 使用Rustls实现TLS客户端示例
use rustls_pemfile::certs;
use std::fs::File;
use std::io::{self, BufReader, Read, Write};
use std::net::TcpStream;
use std::sync::Arc;

fn main() {
    // 创建TLS配置
    let mut tls_config = rustls::ClientConfig::builder()
        .with_safe_defaults()
        .with_root_certificates(rustls::RootCertStore::empty())
        .with_no_client_auth();
    
    // 可选：加载自定义CA证书
    // load_ca_certs(&mut tls_config);
    
    // 禁用证书验证（仅用于测试，生产环境请勿使用）
    tls_config.dangerous().set_certificate_verifier(
        Arc::new(NoCertificateVerification),
    );
    
    // 设置ALPN协议（可选）
    tls_config.alpn_protocols = vec![b"h2".to_vec(), b"http/1.1".to_vec()];
    
    // 创建TLS客户端
    let tls_config = Arc::new(tls_config);
    let dns_name = rustls::ServerName::try_from("localhost")
        .expect("无效的DNS名称");
    
    // 连接到服务器
    let tcp_stream = TcpStream::connect("127.0.0.1:8443").expect("连接服务器失败");
    let mut tls_session = rustls::ClientConnection::new(Arc::clone(&tls_config), dns_name).unwrap();
    let mut tls_stream = rustls::Stream::new(&mut tls_session, tcp_stream);
    
    // 发送数据到服务器
    let message = "你好，安全的TLS通信！";
    tls_stream.write(message.as_bytes()).expect("发送数据失败");
    
    // 读取服务器响应
    let mut buffer = [0; 1024];
    match tls_stream.read(&mut buffer) {
        Ok(size) => {
            let response = String::from_utf8_lossy(&buffer[..size]);
            println!("服务器响应: {}", response);
        },
        Err(e) => {
            eprintln!("读取响应错误: {:?}", e);
        }
    }
}

// 加载CA证书（可选）
fn load_ca_certs(config: &mut rustls::ClientConfig) {
    let ca_file = &mut BufReader::new(File::open("ca.crt").expect("无法打开CA证书文件"));
    let ca_certs = certs(ca_file)
        .expect("无法读取CA证书")
        .into_iter()
        .map(rustls::Certificate)
        .collect();
    
    config.root_store.add_parsable_certificates(&ca_certs);
}

// 证书验证器（用于测试环境，生产环境请勿使用）
struct NoCertificateVerification;

impl rustls::client::ServerCertVerifier for NoCertificateVerification {
    fn verify_server_cert(
        &self,
        _end_entity: &rustls::Certificate,
        _intermediates: &[rustls::Certificate],
        _server_name: &rustls::ServerName,
        _scts: &mut dyn Iterator<Item = &[u8]>,
        _ocsp_response: &[u8],
        _now: std::time::SystemTime,
    ) -> Result<rustls::client::ServerCertVerified, rustls::Error> {
        // 总是返回成功，不验证证书
        Ok(rustls::client::ServerCertVerified::assertion())
    }
}

端到端加密流程:
1. 发送方生成随机对称密钥
2. 发送方使用对称密钥加密数据
3. 发送方使用接收方的公钥加密对称密钥
4. 发送方将加密的数据和加密的对称密钥发送给接收方
5. 接收方使用自己的私钥解密对称密钥
6. 接收方使用解密后的对称密钥解密数据

// 简单的端到端加密通信示例
use ring::aead::{self, Aad, Nonce, UnboundKey, BoundKey, LessSafeKey};
use ring::agreement::{self, EphemeralPrivateKey, UnparsedPublicKey};
use ring::digest;
use ring::hmac;
use ring::rand::SystemRandom;

// 生成密钥对
fn generate_key_pair() -> (Vec<u8>, Vec<u8>) {
    let rng = SystemRandom::new();
    
    // 生成临时私钥
    let private_key = EphemeralPrivateKey::generate(&agreement::X25519, &rng).unwrap();
    
    // 获取公钥
    let public_key_bytes = private_key.compute_public_key().unwrap().as_ref().to_vec();
    
    // 私钥以DER格式存储（实际应用中应该使用安全的存储方式）
    let private_key_bytes = private_key.key_der().to_vec();
    
    (private_key_bytes, public_key_bytes)
}

// 生成共享密钥
fn generate_shared_key(
    private_key_bytes: &[u8],
    peer_public_key_bytes: &[u8],
) -> Result<Vec<u8>, ring::error::Unspecified> {
    // 解析私钥
    let private_key = EphemeralPrivateKey::try_from(private_key_bytes)?;
    
    // 解析对方公钥
    let peer_public_key = UnparsedPublicKey::new(&agreement::X25519, peer_public_key_bytes);
    
    // 生成共享密钥
    let rng = SystemRandom::new();
    let shared_key = agreement::agree_ephemeral(
        private_key,
        &peer_public_key,
        ring::error::Unspecified,
        |shared_secret| {
            // 使用HKDF从共享密钥派生加密密钥
            let mut key = vec![0; 32]; // AES-256密钥长度
            let salt = [0; 32]; // 实际应用中应该使用随机salt
            let info = b"end-to-end encryption";
            
            ring::hkdf::extract_and_expand(
                digest::SHA256,
                Some(&salt),
                shared_secret,
                info,
                &mut key,
            );
            
            Ok(key)
        },
    )?;
    
    Ok(shared_key)
}

// 加密数据
fn encrypt_data(
    key: &[u8],
    data: &[u8],
) -> Result<(Vec<u8>, Vec<u8>), ring::error::Unspecified> {
    // 创建AEAD密钥
    let unbound_key = UnboundKey::new(&aead::AES_256_GCM, key)?;
    let mut key = LessSafeKey::new(unbound_key);
    
    // 生成随机nonce
    let rng = SystemRandom::new();
    let mut nonce_bytes = [0; 12]; // AES-GCM推荐的nonce长度
    rng.fill(&mut nonce_bytes)?;
    let nonce = Nonce::assume_unique_for_key(nonce_bytes);
    
    // 创建AAD（可选的额外认证数据）
    let aad = Aad::empty();
    
    // 加密数据（需要额外的空间存储认证标签）
    let mut ciphertext = data.to_vec();
    let tag_len = aead::AES_256_GCM.tag_len();
    ciphertext.resize(data.len() + tag_len, 0);
    
    let aad = Aad::empty();
    key.seal_in_place_append_tag(nonce, aad, &mut ciphertext)?;
    
    Ok((nonce_bytes.to_vec(), ciphertext))
}

// 解密数据
fn decrypt_data(
    key: &[u8],
    nonce: &[u8],
    ciphertext: &[u8],
) -> Result<Vec<u8>, ring::error::Unspecified> {
    // 创建AEAD密钥
    let unbound_key = UnboundKey::new(&aead::AES_256_GCM, key)?;
    let mut key = LessSafeKey::new(unbound_key);
    
    // 解析nonce
    let nonce = Nonce::assume_unique_for_key(*array_ref![nonce, 0, 12]);
    
    // 创建AAD
    let aad = Aad::empty();
    
    // 解密数据
    let mut plaintext = ciphertext.to_vec();
    let plaintext_len = key.open_in_place(nonce, aad, &mut plaintext)?;
    plaintext.truncate(plaintext_len);
    
    Ok(plaintext)
}

// 计算数据的MAC（消息认证码）
fn compute_mac(key: &[u8], data: &[u8]) -> Vec<u8> {
    // 创建HMAC密钥
    let key = hmac::Key::new(hmac::HMAC_SHA256, key);
    
    // 计算HMAC
    let tag = hmac::sign(&key, data);
    
    // 返回MAC值
    tag.as_ref().to_vec()
}

// 验证MAC
fn verify_mac(key: &[u8], data: &[u8], mac: &[u8]) -> bool {
    // 创建HMAC密钥
    let key = hmac::Key::new(hmac::HMAC_SHA256, key);
    
    // 验证HMAC
    hmac::verify(&key, data, mac).is_ok()
}

fn main() {
    // 生成Alice的密钥对
    let (alice_private_key, alice_public_key) = generate_key_pair();
    println!("Alice的公钥: {:?}", hex::encode(&alice_public_key));
    
    // 生成Bob的密钥对
    let (bob_private_key, bob_public_key) = generate_key_pair();
    println!("Bob的公钥: {:?}", hex::encode(&bob_public_key));
    
    // Alice生成与Bob通信的共享密钥
    let alice_shared_key = generate_shared_key(&alice_private_key, &bob_public_key).unwrap();
    println!("Alice生成的共享密钥: {:?}", hex::encode(&alice_shared_key));
    
    // Bob生成与Alice通信的共享密钥
    let bob_shared_key = generate_shared_key(&bob_private_key, &alice_public_key).unwrap();
    println!("Bob生成的共享密钥: {:?}", hex::encode(&bob_shared_key));
    
    // 验证两个共享密钥是否相同
    assert_eq!(alice_shared_key, bob_shared_key);
    println!("✅ 共享密钥验证成功，双方生成的共享密钥相同");
    
    // Alice加密消息
    let plaintext = b"这是一条端到端加密的消息！";
    let (nonce, ciphertext) = encrypt_data(&alice_shared_key, plaintext).unwrap();
    println!("加密后的数据: {:?}", hex::encode(&ciphertext));
    println!("使用的nonce: {:?}", hex::encode(&nonce));
    
    // Alice计算MAC
    let mac = compute_mac(&alice_shared_key, &ciphertext);
    println!("计算的MAC: {:?}", hex::encode(&mac));
    
    // 模拟传输过程（实际应用中应该通过网络发送）
    // 在实际应用中，应该使用TLS等安全协议来保护传输过程中的nonce、ciphertext和mac
    
    // Bob验证MAC
    let mac_valid = verify_mac(&bob_shared_key, &ciphertext, &mac);
    println!("MAC验证结果: {}", mac_valid);
    
    // Bob解密消息
    let decrypted_data = decrypt_data(&bob_shared_key, &nonce, &ciphertext).unwrap();
    println!("解密后的数据: {:?}", String::from_utf8_lossy(&decrypted_data));
    
    // 验证解密后的数据是否与原始数据相同
    assert_eq!(decrypted_data, plaintext);
    println!("✅ 数据解密成功，解密后的数据与原始数据相同");
}

// 辅助函数：从切片中提取固定大小的数组
use std::convert::TryInto;

fn array_ref<T, const N: usize>(slice: &[T]) -> &[T; N] {
    slice.try_into().expect("slice length does not match array length")
}

密钥生命周期管理:
密钥生成 → 密钥存储 → 密钥分发 → 密钥使用 → 密钥轮换 → 密钥销毁
  ↓          ↓            ↓            ↓            ↓            ↓
安全生成  加密存储  安全传输  访问控制  定期更新  安全删除

// 简单的密钥管理系统
use aes_gcm::{Aes256Gcm, KeyInit, aead::{Aead, Nonce}};
use rand::RngCore;
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use std::fs::{File, OpenOptions};
use std::io::{Read, Write};
use std::sync::Arc;
use std::sync::Mutex;
use std::time::{Duration, SystemTime, UNIX_EPOCH};

// 密钥类型枚举
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
enum KeyType {
    Encryption,
    Signing,
    Authentication,
    KeyEncryptionKey,
}

// 密钥结构体
#[derive(Debug, Serialize, Deserialize)]
struct Key {
    id: String,
    key_type: KeyType,
    key_material: Vec<u8>,
    created_at: u64,
    expires_at: Option<u64>,
    metadata: HashMap<String, String>,
}

impl Key {
    // 创建新的密钥
    fn new(
        key_type: KeyType,
        key_material: Vec<u8>,
        expires_at: Option<u64>,
        metadata: HashMap<String, String>,
    ) -> Self {
        let id = format!("{}-{}", key_type_to_string(key_type), SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_millis());
        let created_at = SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_secs();
        
        Key {
            id,
            key_type,
            key_material,
            created_at,
            expires_at,
            metadata,
        }
    }
    
    // 检查密钥是否过期
    fn is_expired(&self) -> bool {
        if let Some(expires_at) = self.expires_at {
            let now = SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_secs();
            now > expires_at
        } else {
            false
        }
    }
    
    // 更新密钥的过期时间
    fn update_expiration(&mut self, expires_at: Option<u64>) {
        self.expires_at = expires_at;
    }
}

// 将密钥类型转换为字符串
fn key_type_to_string(key_type: KeyType) -> String {
    match key_type {
        KeyType::Encryption => "enc".to_string(),
        KeyType::Signing => "sig".to_string(),
        KeyType::Authentication => "auth".to_string(),
        KeyType::KeyEncryptionKey => "kek".to_string(),
    }
}

// 密钥管理器
struct KeyManager {
    // 存储密钥的哈希表
    keys: Arc<Mutex<HashMap<String, Key>>>,
    // 主密钥加密密钥
    kek: Option<[u8; 32]>,
    // 密钥存储文件路径
    storage_path: String,
    // 自动保存间隔
    auto_save_interval: Duration,
}

impl KeyManager {
    // 创建新的密钥管理器
    fn new(storage_path: String, auto_save_interval: Duration) -> Self {
        let keys = Arc::new(Mutex::new(HashMap::new()));
        
        KeyManager {
            keys,
            kek: None,
            storage_path,
            auto_save_interval,
        }
    }
    
    // 设置主密钥加密密钥
    fn set_kek(&mut self, kek: [u8; 32]) {
        self.kek = Some(kek);
    }
    
    // 生成新密钥
    fn generate_key(
        &self,
        key_type: KeyType,
        key_size: usize,
        expires_in: Option<Duration>,
        metadata: HashMap<String, String>,
    ) -> Result<Key, String> {
        // 生成随机密钥材料
        let mut key_material = vec![0; key_size];
        let mut rng = rand::thread_rng();
        rng.fill_bytes(&mut key_material);
        
        // 计算过期时间
        let expires_at = if let Some(duration) = expires_in {
            Some(SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_secs() + duration.as_secs())
        } else {
            None
        };
        
        // 创建密钥
        let key = Key::new(key_type, key_material, expires_at, metadata);
        
        // 存储密钥
        let mut keys = self.keys.lock().unwrap();
        keys.insert(key.id.clone(), key.clone());
        
        Ok(key)
    }
    
    // 获取密钥
    fn get_key(&self, key_id: &str) -> Result<Key, String> {
        let keys = self.keys.lock().unwrap();
        
        if let Some(key) = keys.get(key_id) {
            // 检查密钥是否过期
            if key.is_expired() {
                return Err("密钥已过期".to_string());
            }
            
            Ok(key.clone())
        } else {
            Err("未找到指定的密钥".to_string())
        }
    }
    
    // 删除密钥
    fn delete_key(&self, key_id: &str) -> Result<(), String> {
        let mut keys = self.keys.lock().unwrap();
        
        if keys.remove(key_id).is_some() {
            Ok(())
        } else {
            Err("未找到指定的密钥".to_string())
        }
    }
    
    // 列出所有密钥（不包含密钥材料）
    fn list_keys(&self) -> Vec<KeySummary> {
        let keys = self.keys.lock().unwrap();
        
        keys.values()
            .map(|key| KeySummary {
                id: key.id.clone(),
                key_type: key.key_type,
                created_at: key.created_at,
                expires_at: key.expires_at,
                is_expired: key.is_expired(),
            })
            .collect()
    }
    
    // 保存密钥到文件
    fn save_keys(&self) -> Result<(), String> {
        let keys = self.keys.lock().unwrap();
        
        // 序列化密钥
        let serialized = serde_json::to_string(&*keys).map_err(|e| e.to_string())?;
        
        // 如果设置了KEK，加密序列化的数据
        let data_to_write = if let Some(kek) = &self.kek {
            // 生成随机nonce
            let mut nonce_bytes = [0; 12];
            let mut rng = rand::thread_rng();
            rng.fill_bytes(&mut nonce_bytes);
            let nonce = Nonce::<Aes256Gcm>::from_slice(&nonce_bytes);
            
            // 创建AES-GCM加密器
            let cipher = Aes256Gcm::new_from_slice(kek).map_err(|e| e.to_string())?;
            
            // 加密数据
            let ciphertext = cipher.encrypt(nonce, serialized.as_bytes().as_ref()).map_err(|e| e.to_string())?;
            
            // 合并nonce和密文
            let mut encrypted_data = Vec::with_capacity(nonce_bytes.len() + ciphertext.len());
            encrypted_data.extend_from_slice(&nonce_bytes);
            encrypted_data.extend_from_slice(&ciphertext);
            
            encrypted_data
        } else {
            // 不加密，直接保存明文
            serialized.into_bytes()
        };
        
        // 写入文件
        let mut file = File::create(&self.storage_path).map_err(|e| e.to_string())?;
        file.write_all(&data_to_write).map_err(|e| e.to_string())?;
        
        Ok(())
    }
    
    // 从文件加载密钥
    fn load_keys(&self) -> Result<(), String> {
        // 检查文件是否存在
        if !std::path::Path::new(&self.storage_path).exists() {
            return Ok(());
        }
        
        // 读取文件内容
        let mut file = File::open(&self.storage_path).map_err(|e| e.to_string())?;
        let mut data = Vec::new();
        file.read_to_end(&mut data).map_err(|e| e.to_string())?;
        
        // 如果设置了KEK，解密数据
        let serialized = if let Some(kek) = &self.kek {
            // 分离nonce和密文
            if data.len() < 12 {
                return Err("加密数据格式错误".to_string());
            }
            
            let nonce_bytes = &data[0..12];
            let ciphertext = &data[12..];
            let nonce = Nonce::<Aes256Gcm>::from_slice(nonce_bytes);
            
            // 创建AES-GCM解密器
            let cipher = Aes256Gcm::new_from_slice(kek).map_err(|e| e.to_string())?;
            
            // 解密数据
            let plaintext = cipher.decrypt(nonce, ciphertext.as_ref()).map_err(|e| e.to_string())?;
            
            // 转换为字符串
            String::from_utf8(plaintext).map_err(|e| e.to_string())?
        } else {
            // 直接解析明文
            String::from_utf8(data).map_err(|e| e.to_string())?
        };
        
        // 反序列化密钥
        let keys: HashMap<String, Key> = serde_json::from_str(&serialized).map_err(|e| e.to_string())?;
        
        // 更新密钥管理器中的密钥
        let mut keys_map = self.keys.lock().unwrap();
        *keys_map = keys;
        
        Ok(())
    }
    
    // 启动自动保存任务
    fn start_auto_save(&self) {
        let keys_manager = self.clone();
        let interval = self.auto_save_interval;
        
        std::thread::spawn(move || {
            loop {
                std::thread::sleep(interval);
                
                if let Err(e) = keys_manager.save_keys() {
                    eprintln!("自动保存密钥失败: {}", e);
                } else {
                    println!("自动保存密钥成功");
                }
            }
        });
    }
    
    // 轮换过期的密钥
    fn rotate_expired_keys(&self) {
        let keys = self.keys.lock().unwrap();
        let expired_keys: Vec<String> = keys
            .iter()
            .filter(|(_, key)| key.is_expired())
            .map(|(id, _)| id.clone())
            .collect();
        
        drop(keys);
        
        for key_id in expired_keys {
            // 在实际应用中，这里应该生成新的密钥并替换过期的密钥
            println!("密钥 {} 已过期，需要轮换", key_id);
            // 注意：实际的密钥轮换应该更加复杂，包括通知依赖该密钥的系统等
        }
    }
}

// 实现Clone trait
impl Clone for KeyManager {
    fn clone(&self) -> Self {
        KeyManager {
            keys: Arc::clone(&self.keys),
            kek: self.kek,
            storage_path: self.storage_path.clone(),
            auto_save_interval: self.auto_save_interval,
        }
    }
}

// 密钥摘要（不包含密钥材料）
#[derive(Debug)]
struct KeySummary {
    id: String,
    key_type: KeyType,
    created_at: u64,
    expires_at: Option<u64>,
    is_expired: bool,
}

fn main() {
    // 创建密钥管理器，设置存储文件路径和自动保存间隔
    let mut key_manager = KeyManager::new("keys.json".to_string(), Duration::from_secs(60));
    
    // 生成并设置主密钥加密密钥（实际应用中应该安全地获取这个密钥）
    let mut kek = [0; 32];
    let mut rng = rand::thread_rng();
    rng.fill_bytes(&mut kek);
    key_manager.set_kek(kek);
    
    // 尝试从文件加载密钥
    if let Err(e) = key_manager.load_keys() {
        eprintln!("加载密钥失败: {}", e);
    } else {
        println!("加载密钥成功");
    }
    
    // 启动自动保存任务
    key_manager.start_auto_save();
    
    // 生成一些测试密钥
    let mut metadata = HashMap::new();
    metadata.insert("purpose".to_string(), "测试加密".to_string());
    
    let encryption_key = key_manager.generate_key(
        KeyType::Encryption,
        32, // AES-256
        Some(Duration::from_days(30)), // 30天后过期
        metadata,
    ).unwrap();
    
    println!("生成加密密钥: {}", encryption_key.id);
    
    let mut metadata = HashMap::new();
    metadata.insert("purpose".to_string(), "测试签名".to_string());
    
    let signing_key = key_manager.generate_key(
        KeyType::Signing,
        64, // Ed25519
        Some(Duration::from_days(90)), // 90天后过期
        metadata,
    ).unwrap();
    
    println!("生成签名密钥: {}", signing_key.id);
    
    // 列出所有密钥
    println!("\n所有密钥:");
    let key_summaries = key_manager.list_keys();
    for summary in key_summaries {
        println!("- ID: {}, 类型: {:?}, 已过期: {}", 
                 summary.id, summary.key_type, summary.is_expired);
    }
    
    // 获取密钥
    if let Ok(key) = key_manager.get_key(&encryption_key.id) {
        println!("\n获取密钥: {}", key.id);
        println!("类型: {:?}", key.key_type);
        println!("密钥材料长度: {} 字节", key.key_material.len());
        println!("创建时间: {}", key.created_at);
        println!("过期时间: {:?}", key.expires_at);
        println!("元数据: {:?}", key.metadata);
    }
    
    // 手动保存密钥
    if let Err(e) = key_manager.save_keys() {
        eprintln!("手动保存密钥失败: {}", e);
    } else {
        println!("\n手动保存密钥成功");
    }
    
    // 模拟密钥轮换（通常应该定期运行）
    key_manager.rotate_expired_keys();
    
    // 保持程序运行一段时间
    std::thread::sleep(Duration::from_secs(10));
  }

Rust网络安全最佳实践:
├── 输入验证与净化
├── 错误处理与日志记录
├── 权限最小化
├── 安全的依赖管理
└── 安全配置

智能安全监控与响应架构:
┌───────────────┐      ┌───────────────┐      ┌───────────────┐
│  数据采集层   │ ──→  │  分析处理层   │ ──→  │  响应执行层   │
└───────────────┘      └───────────────┘      └───────────────┘
        ↑                                         │
        └─────────────────────────────────────────┘
                     反馈循环