1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
| """
ISO 21434 雷达安全防御机制
三层防御：
1. 参数随机化 — 随机改变 chirp 参数
2. 信号异常检测 — 检测不自然的回波模式
3. 多传感器交叉验证 — 雷达+摄像头+激光雷达一致性
"""
import numpy as np
from typing import Tuple, List
class RadarDefenseSystem:
"""雷达安全防御系统"""
def __init__(self):
self.chirp_params = {
'fc_base': 77e9,
'bw_base': 4e9,
'Tc_base': 50e-6,
'randomization_active': True,
}
self.param_history = []
self.anomaly_threshold = 3.0
self.consistency_check_enabled = True
def randomize_params(self) -> dict:
"""
防御1：随机化雷达参数
MadRadar 需要在 0.25s 内检测参数，
随机化使其检测到的参数很快失效
"""
if not self.chirp_params['randomization_active']:
return self.chirp_params
params = {
'fc': self.chirp_params['fc_base'] + np.random.uniform(-100e6, 100e6),
'bw': self.chirp_params['bw_base'] + np.random.uniform(-200e6, 200e6),
'Tc': self.chirp_params['Tc_base'] * np.random.uniform(0.8, 1.2),
'chirp_pattern': np.random.choice(['up', 'down', 'triangular']),
}
self.param_history.append(params)
return params
def detect_anomaly(self, range_doppler: np.ndarray,
baseline: np.ndarray) -> Tuple[bool, float]:
"""
防御2：信号异常检测
检测不自然的回波模式：
- 过强的点目标（幻影车通常 RCS 不自然）
- 不存在的速度-距离关联
- 突然出现/消失的目标
"""
diff = np.abs(range_doppler - baseline)
mean_diff = np.mean(diff)
std_diff = np.std(diff)
z_scores = (diff - mean_diff) / (std_diff + 1e-10)
max_z = np.max(np.abs(z_scores))
is_anomaly = max_z > self.anomaly_threshold
confidence = min(1.0, max_z / (self.anomaly_threshold * 2))
return is_anomaly, confidence
def cross_validate(self, radar_targets: List[dict],
camera_targets: List[dict],
lidar_targets: List[dict] = None) -> dict:
"""
防御3：多传感器交叉验证
雷达检测到的目标必须与摄像头/激光雷达一致
不一致 → 可能被欺骗
"""
radar_only = []
confirmed = []
for r_target in radar_targets:
matched = False
for c_target in camera_targets:
if self._targets_match(r_target, c_target):
confirmed.append(r_target)
matched = True
break
if not matched:
radar_only.append(r_target)
return {
'confirmed_targets': confirmed,
'radar_only_targets': radar_only,
'spoofing_suspected': len(radar_only) > 0,
'total_radar': len(radar_targets),
'total_confirmed': len(confirmed),
}
def _targets_match(self, t1: dict, t2: dict,
range_tol: float = 2.0,
angle_tol: float = 5.0) -> bool:
"""判断两个目标是否匹配"""
return (abs(t1.get('range', 0) - t2.get('range', 0)) < range_tol and
abs(t1.get('angle', 0) - t2.get('angle', 0)) < angle_tol)
if __name__ == "__main__":
defense = RadarDefenseSystem()
for i in range(3):
params = defense.randomize_params()
print(f"随机化 {i}: fc={params['fc']/1e9:.3f} GHz, "
f"bw={params['bw']/1e9:.3f} GHz, "
f"pattern={params['chirp_pattern']}")
np.random.seed(42)
baseline = np.random.randn(64, 64) * 0.1
normal_signal = baseline + np.random.randn(64, 64) * 0.05
spoofed_signal = baseline.copy()
spoofed_signal[30, 30] += 5.0
is_an, conf = defense.detect_anomaly(normal_signal, baseline)
print(f"\n正常信号: anomaly={is_an}, confidence={conf:.2f}")
is_an2, conf2 = defense.detect_anomaly(spoofed_signal, baseline)
print(f"欺骗信号: anomaly={is_an2}, confidence={conf2:.2f}")
radar_targets = [
{'range': 30, 'angle': 0, 'velocity': -5},
{'range': 50, 'angle': 5, 'velocity': -10},
]
camera_targets = [
{'range': 31, 'angle': 1, 'velocity': -5},
]
result = defense.cross_validate(radar_targets, camera_targets)
print(f"\n交叉验证: 确认={result['total_confirmed']}, "
f"仅雷达={len(result['radar_only_targets'])}, "
f"疑似欺骗={result['spoofing_suspected']}")
|
