562 lines
15 KiB
Rust
562 lines
15 KiB
Rust
// UCA - Unified Cross-Chain Auditor
|
||
// 统一跨链审计器
|
||
//
|
||
// 功能：
|
||
// 1. 跨链行为追踪 - 记录节点在所有链上的转发、中继行为
|
||
// 2. 生成可验证的跨链行为证明
|
||
// 3. 违规跨链惩罚 - 发现恶意行为并触发宪法治理层处罚
|
||
// 4. 为GIDS提供信誉评分数据
|
||
|
||
use super::types::{ExtendedDID, NetworkBehaviorAudit, BehaviorType};
|
||
use nac_udm::primitives::{Hash, Timestamp};
|
||
use serde::{Deserialize, Serialize};
|
||
use std::collections::HashMap;
|
||
|
||
/// 统一跨链审计器
|
||
#[derive(Debug, Clone)]
|
||
pub struct UnifiedCrossChainAuditor {
|
||
/// 审计记录（按节点DID分组）
|
||
audit_records: HashMap<String, Vec<NetworkBehaviorAudit>>,
|
||
|
||
/// 违规记录
|
||
violations: Vec<ViolationRecord>,
|
||
|
||
/// 行为统计（按节点DID）
|
||
behavior_stats: HashMap<String, NodeBehaviorStats>,
|
||
|
||
/// 是否运行
|
||
is_running: bool,
|
||
}
|
||
|
||
/// 违规记录
|
||
#[derive(Debug, Clone, Serialize, Deserialize)]
|
||
pub struct ViolationRecord {
|
||
/// 违规ID
|
||
pub violation_id: Hash,
|
||
|
||
/// 节点DID
|
||
pub node_did: ExtendedDID,
|
||
|
||
/// 链ID
|
||
pub chain_id: u64,
|
||
|
||
/// 违规类型
|
||
pub violation_type: ViolationType,
|
||
|
||
/// 违规详情
|
||
pub details: String,
|
||
|
||
/// 证据哈希
|
||
pub evidence_hash: Hash,
|
||
|
||
/// 严重程度（1-10）
|
||
pub severity: u8,
|
||
|
||
/// 时间戳
|
||
pub timestamp: Timestamp,
|
||
|
||
/// 是否已处罚
|
||
pub is_penalized: bool,
|
||
}
|
||
|
||
/// 违规类型
|
||
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
|
||
pub enum ViolationType {
|
||
/// 交易审查（恶意不转发交易）
|
||
TransactionCensorship,
|
||
|
||
/// 区块扣留（不传播区块）
|
||
BlockWithholding,
|
||
|
||
/// 双重中继（重复中继消息）
|
||
DoubleRelay,
|
||
|
||
/// 虚假状态证明
|
||
FalseStateProof,
|
||
|
||
/// 拒绝服务攻击
|
||
DenialOfService,
|
||
|
||
/// 恶意断开连接
|
||
MaliciousDisconnection,
|
||
}
|
||
|
||
/// 节点行为统计
|
||
#[derive(Debug, Clone, Serialize, Deserialize)]
|
||
pub struct NodeBehaviorStats {
|
||
/// 节点DID
|
||
pub node_did: String,
|
||
|
||
/// 总行为记录数
|
||
pub total_behaviors: usize,
|
||
|
||
/// 违规次数
|
||
pub violation_count: usize,
|
||
|
||
/// 成功转发次数
|
||
pub successful_forwards: usize,
|
||
|
||
/// 失败转发次数
|
||
pub failed_forwards: usize,
|
||
|
||
/// 跨链中继次数
|
||
pub cross_chain_relays: usize,
|
||
|
||
/// 最后活跃时间
|
||
pub last_active: Timestamp,
|
||
|
||
/// 信誉评分（0-100）
|
||
pub reputation_score: u8,
|
||
}
|
||
|
||
/// 行为证明
|
||
#[derive(Debug, Clone, Serialize, Deserialize)]
|
||
pub struct BehaviorProof {
|
||
/// 证明ID
|
||
pub proof_id: Hash,
|
||
|
||
/// 节点DID
|
||
pub node_did: ExtendedDID,
|
||
|
||
/// 行为类型
|
||
pub behavior_type: BehaviorType,
|
||
|
||
/// 证明数据
|
||
pub proof_data: Vec<u8>,
|
||
|
||
/// 见证节点列表
|
||
pub witnesses: Vec<ExtendedDID>,
|
||
|
||
/// 时间戳
|
||
pub timestamp: Timestamp,
|
||
}
|
||
|
||
impl UnifiedCrossChainAuditor {
|
||
/// 创建新的UCA实例
|
||
pub fn new() -> Self {
|
||
Self {
|
||
audit_records: HashMap::new(),
|
||
violations: Vec::new(),
|
||
behavior_stats: HashMap::new(),
|
||
is_running: false,
|
||
}
|
||
}
|
||
|
||
/// 启动审计器
|
||
pub fn start(&mut self) -> Result<(), String> {
|
||
if self.is_running {
|
||
return Err("UCA is already running".to_string());
|
||
}
|
||
|
||
self.is_running = true;
|
||
Ok(())
|
||
}
|
||
|
||
/// 停止审计器
|
||
pub fn stop(&mut self) -> Result<(), String> {
|
||
if !self.is_running {
|
||
return Err("UCA is not running".to_string());
|
||
}
|
||
|
||
self.is_running = false;
|
||
Ok(())
|
||
}
|
||
|
||
/// 记录网络行为
|
||
pub fn record_behavior(
|
||
&mut self,
|
||
node_did: ExtendedDID,
|
||
chain_id: u64,
|
||
behavior_type: BehaviorType,
|
||
details: String,
|
||
is_violation: bool,
|
||
) -> Result<Hash, String> {
|
||
if !self.is_running {
|
||
return Err("UCA is not running".to_string());
|
||
}
|
||
|
||
let audit_id = Hash::sha3_384(
|
||
format!("{}{}{}", node_did.to_string(), chain_id, Timestamp::now().as_secs())
|
||
.as_bytes()
|
||
);
|
||
|
||
let audit = NetworkBehaviorAudit {
|
||
audit_id: audit_id.clone(),
|
||
node_did: node_did.clone(),
|
||
chain_id,
|
||
behavior_type: behavior_type.clone(),
|
||
details: details.clone(),
|
||
is_violation,
|
||
timestamp: Timestamp::now(),
|
||
};
|
||
|
||
// 添加到审计记录
|
||
self.audit_records
|
||
.entry(node_did.to_string())
|
||
.or_insert_with(Vec::new)
|
||
.push(audit);
|
||
|
||
// 更新行为统计
|
||
self.update_behavior_stats(&node_did, &behavior_type, is_violation);
|
||
|
||
// 如果是违规行为，记录违规
|
||
if is_violation {
|
||
self.record_violation(
|
||
node_did,
|
||
chain_id,
|
||
self.infer_violation_type(&behavior_type),
|
||
details,
|
||
5, // 默认中等严重程度
|
||
)?;
|
||
}
|
||
|
||
Ok(audit_id)
|
||
}
|
||
|
||
/// 推断违规类型
|
||
fn infer_violation_type(&self, behavior_type: &BehaviorType) -> ViolationType {
|
||
match behavior_type {
|
||
BehaviorType::TransactionCensorship => ViolationType::TransactionCensorship,
|
||
BehaviorType::BlockPropagation => ViolationType::BlockWithholding,
|
||
BehaviorType::CrossChainRelay => ViolationType::DoubleRelay,
|
||
_ => ViolationType::DenialOfService,
|
||
}
|
||
}
|
||
|
||
/// 记录违规
|
||
pub fn record_violation(
|
||
&mut self,
|
||
node_did: ExtendedDID,
|
||
chain_id: u64,
|
||
violation_type: ViolationType,
|
||
details: String,
|
||
severity: u8,
|
||
) -> Result<Hash, String> {
|
||
let violation_id = Hash::sha3_384(
|
||
format!("{}{}{}", node_did.to_string(), chain_id, Timestamp::now().as_secs())
|
||
.as_bytes()
|
||
);
|
||
|
||
let evidence_hash = Hash::sha3_384(details.as_bytes());
|
||
|
||
let violation = ViolationRecord {
|
||
violation_id: violation_id.clone(),
|
||
node_did,
|
||
chain_id,
|
||
violation_type,
|
||
details,
|
||
evidence_hash,
|
||
severity,
|
||
timestamp: Timestamp::now(),
|
||
is_penalized: false,
|
||
};
|
||
|
||
self.violations.push(violation);
|
||
|
||
Ok(violation_id)
|
||
}
|
||
|
||
/// 更新行为统计
|
||
fn update_behavior_stats(
|
||
&mut self,
|
||
node_did: &ExtendedDID,
|
||
behavior_type: &BehaviorType,
|
||
is_violation: bool,
|
||
) {
|
||
let did_str = node_did.to_string();
|
||
|
||
let stats = self.behavior_stats
|
||
.entry(did_str.clone())
|
||
.or_insert_with(|| NodeBehaviorStats {
|
||
node_did: did_str,
|
||
total_behaviors: 0,
|
||
violation_count: 0,
|
||
successful_forwards: 0,
|
||
failed_forwards: 0,
|
||
cross_chain_relays: 0,
|
||
last_active: Timestamp::now(),
|
||
reputation_score: 100, // 初始满分
|
||
});
|
||
|
||
stats.total_behaviors += 1;
|
||
stats.last_active = Timestamp::now();
|
||
|
||
if is_violation {
|
||
stats.violation_count += 1;
|
||
// 每次违规扣10分，最低0分
|
||
stats.reputation_score = stats.reputation_score.saturating_sub(10);
|
||
} else {
|
||
// 正常行为加1分，最高100分
|
||
stats.reputation_score = stats.reputation_score.saturating_add(1).min(100);
|
||
}
|
||
|
||
match behavior_type {
|
||
BehaviorType::MessageForward => {
|
||
if is_violation {
|
||
stats.failed_forwards += 1;
|
||
} else {
|
||
stats.successful_forwards += 1;
|
||
}
|
||
}
|
||
BehaviorType::CrossChainRelay => {
|
||
stats.cross_chain_relays += 1;
|
||
}
|
||
_ => {}
|
||
}
|
||
}
|
||
|
||
/// 生成行为证明
|
||
pub fn generate_behavior_proof(
|
||
&self,
|
||
node_did: ExtendedDID,
|
||
behavior_type: BehaviorType,
|
||
proof_data: Vec<u8>,
|
||
witnesses: Vec<ExtendedDID>,
|
||
) -> Result<BehaviorProof, String> {
|
||
let proof_id = Hash::sha3_384(&proof_data);
|
||
|
||
Ok(BehaviorProof {
|
||
proof_id,
|
||
node_did,
|
||
behavior_type,
|
||
proof_data,
|
||
witnesses,
|
||
timestamp: Timestamp::now(),
|
||
})
|
||
}
|
||
|
||
/// 验证行为证明
|
||
pub fn verify_behavior_proof(&self, proof: &BehaviorProof) -> bool {
|
||
// 验证证明ID
|
||
let computed_id = Hash::sha3_384(&proof.proof_data);
|
||
if computed_id != proof.proof_id {
|
||
return false;
|
||
}
|
||
|
||
// 验证见证节点数量（至少需要3个见证）
|
||
if proof.witnesses.len() < 3 {
|
||
return false;
|
||
}
|
||
|
||
true
|
||
}
|
||
|
||
/// 获取节点审计记录
|
||
pub fn get_node_audits(&self, node_did: &str) -> Option<&Vec<NetworkBehaviorAudit>> {
|
||
self.audit_records.get(node_did)
|
||
}
|
||
|
||
/// 获取节点行为统计
|
||
pub fn get_node_stats(&self, node_did: &str) -> Option<&NodeBehaviorStats> {
|
||
self.behavior_stats.get(node_did)
|
||
}
|
||
|
||
/// 获取节点违规记录
|
||
pub fn get_node_violations(&self, node_did: &ExtendedDID) -> Vec<&ViolationRecord> {
|
||
self.violations
|
||
.iter()
|
||
.filter(|v| &v.node_did == node_did)
|
||
.collect()
|
||
}
|
||
|
||
/// 获取所有未处罚的违规
|
||
pub fn get_unpunished_violations(&self) -> Vec<&ViolationRecord> {
|
||
self.violations
|
||
.iter()
|
||
.filter(|v| !v.is_penalized)
|
||
.collect()
|
||
}
|
||
|
||
/// 标记违规已处罚
|
||
pub fn mark_violation_penalized(&mut self, violation_id: &Hash) -> Result<(), String> {
|
||
if let Some(violation) = self.violations.iter_mut().find(|v| &v.violation_id == violation_id) {
|
||
violation.is_penalized = true;
|
||
Ok(())
|
||
} else {
|
||
Err(format!("Violation not found: {:?}", violation_id))
|
||
}
|
||
}
|
||
|
||
/// 计算节点信誉评分
|
||
pub fn calculate_reputation(&self, node_did: &str) -> u8 {
|
||
if let Some(stats) = self.behavior_stats.get(node_did) {
|
||
stats.reputation_score
|
||
} else {
|
||
50 // 默认中等信誉
|
||
}
|
||
}
|
||
|
||
/// 获取审计统计
|
||
pub fn get_audit_stats(&self) -> AuditStats {
|
||
let total_audits: usize = self.audit_records.values().map(|v| v.len()).sum();
|
||
let total_violations = self.violations.len();
|
||
let unpunished_violations = self.violations.iter().filter(|v| !v.is_penalized).count();
|
||
|
||
let avg_reputation = if !self.behavior_stats.is_empty() {
|
||
let sum: u32 = self.behavior_stats.values().map(|s| s.reputation_score as u32).sum();
|
||
(sum / self.behavior_stats.len() as u32) as u8
|
||
} else {
|
||
0
|
||
};
|
||
|
||
AuditStats {
|
||
total_audits,
|
||
total_violations,
|
||
unpunished_violations,
|
||
monitored_nodes: self.behavior_stats.len(),
|
||
avg_reputation,
|
||
}
|
||
}
|
||
}
|
||
|
||
/// 审计统计
|
||
#[derive(Debug, Clone, Serialize, Deserialize)]
|
||
pub struct AuditStats {
|
||
/// 总审计记录数
|
||
pub total_audits: usize,
|
||
|
||
/// 总违规数
|
||
pub total_violations: usize,
|
||
|
||
/// 未处罚违规数
|
||
pub unpunished_violations: usize,
|
||
|
||
/// 监控节点数
|
||
pub monitored_nodes: usize,
|
||
|
||
/// 平均信誉评分
|
||
pub avg_reputation: u8,
|
||
}
|
||
|
||
impl Default for UnifiedCrossChainAuditor {
|
||
fn default() -> Self {
|
||
Self::new()
|
||
}
|
||
}
|
||
|
||
#[cfg(test)]
|
||
mod tests {
|
||
use super::*;
|
||
|
||
#[test]
|
||
fn test_uca_creation() {
|
||
let uca = UnifiedCrossChainAuditor::new();
|
||
assert!(!uca.is_running);
|
||
assert_eq!(uca.audit_records.len(), 0);
|
||
}
|
||
|
||
#[test]
|
||
fn test_record_behavior() {
|
||
let mut uca = UnifiedCrossChainAuditor::new();
|
||
uca.start().expect("mainnet: handle error");
|
||
|
||
let did = ExtendedDID::new(
|
||
"main".to_string(),
|
||
"cbp".to_string(),
|
||
"0x1234".to_string(),
|
||
);
|
||
|
||
let result = uca.record_behavior(
|
||
did.clone(),
|
||
1,
|
||
BehaviorType::MessageForward,
|
||
"Successfully forwarded message".to_string(),
|
||
false,
|
||
);
|
||
|
||
assert!(result.is_ok());
|
||
|
||
let audits = uca.get_node_audits(&did.to_string()).expect("mainnet: handle error");
|
||
assert_eq!(audits.len(), 1);
|
||
}
|
||
|
||
#[test]
|
||
fn test_record_violation() {
|
||
let mut uca = UnifiedCrossChainAuditor::new();
|
||
uca.start().expect("mainnet: handle error");
|
||
|
||
let did = ExtendedDID::new(
|
||
"main".to_string(),
|
||
"cbp".to_string(),
|
||
"0x1234".to_string(),
|
||
);
|
||
|
||
let result = uca.record_behavior(
|
||
did.clone(),
|
||
1,
|
||
BehaviorType::TransactionCensorship,
|
||
"Censored transaction".to_string(),
|
||
true, // 这是违规行为
|
||
);
|
||
|
||
assert!(result.is_ok());
|
||
|
||
let violations = uca.get_node_violations(&did);
|
||
assert_eq!(violations.len(), 1);
|
||
assert_eq!(violations[0].violation_type, ViolationType::TransactionCensorship);
|
||
}
|
||
|
||
#[test]
|
||
fn test_reputation_calculation() {
|
||
let mut uca = UnifiedCrossChainAuditor::new();
|
||
uca.start().expect("mainnet: handle error");
|
||
|
||
let did = ExtendedDID::new(
|
||
"main".to_string(),
|
||
"cbp".to_string(),
|
||
"0x1234".to_string(),
|
||
);
|
||
|
||
// 记录正常行为
|
||
for _ in 0..5 {
|
||
uca.record_behavior(
|
||
did.clone(),
|
||
1,
|
||
BehaviorType::MessageForward,
|
||
"Success".to_string(),
|
||
false,
|
||
).expect("mainnet: handle error");
|
||
}
|
||
|
||
// 记录违规行为
|
||
uca.record_behavior(
|
||
did.clone(),
|
||
1,
|
||
BehaviorType::TransactionCensorship,
|
||
"Violation".to_string(),
|
||
true,
|
||
).expect("mainnet: handle error");
|
||
|
||
let reputation = uca.calculate_reputation(&did.to_string());
|
||
|
||
// 初始100分，5次正常行为+5分=105（上限100），1次违规-10分=90
|
||
assert_eq!(reputation, 90);
|
||
}
|
||
|
||
#[test]
|
||
fn test_behavior_proof() {
|
||
let uca = UnifiedCrossChainAuditor::new();
|
||
|
||
let did = ExtendedDID::new(
|
||
"main".to_string(),
|
||
"cbp".to_string(),
|
||
"0x1234".to_string(),
|
||
);
|
||
|
||
let witnesses = vec![
|
||
ExtendedDID::new("main".to_string(), "cbp".to_string(), "0x2".to_string()),
|
||
ExtendedDID::new("main".to_string(), "cbp".to_string(), "0x3".to_string()),
|
||
ExtendedDID::new("main".to_string(), "cbp".to_string(), "0x4".to_string()),
|
||
];
|
||
|
||
let proof = uca.generate_behavior_proof(
|
||
did,
|
||
BehaviorType::MessageForward,
|
||
vec![1, 2, 3],
|
||
witnesses,
|
||
).expect("mainnet: handle error");
|
||
|
||
assert!(uca.verify_behavior_proof(&proof));
|
||
}
|
||
}
|