自动驾驶系统安全取证深度分析

sudo apt install ros-humble-lidar-geometry
ros2 topic echo /points_raw --field data | head -n 100
python3 -c "
import numpy as np
points = np.frombuffer(raw_data, dtype=np.float32).reshape(-1, 4)
detections = points[points[:, 3] > 30.0]
print(f'High-intensity points: {len(detections)}')
anomalies = np.where(np.abs(np.diff(points[:, 2])) > 5.0)[0]
print(f'Distance jump anomalies at indices: {anomalies}')
"

import torch
import torchvision.transforms as transforms
from torchvision.models.detection import fasterrcnn_resnet50_fpn

model = fasterrcnn_resnet50_fpn(pretrained=True)
model.eval()

transform = transforms.Compose([
    transforms.ToTensor(),
])

def analyze_patch_suspicion(image_tensor):
    confidence_scores = []
    with torch.no_grad():
        predictions = model(image_tensor.unsqueeze(0))
    for score in predictions[0]['scores']:
        confidence_scores.append(score.item())
    if len(confidence_scores) > 0:
        max_conf = max(confidence_scores)
        score_variance = np.var(confidence_scores)
        if max_conf > 0.95 and score_variance < 0.01:
            return True, "Suspicious uniform confidence pattern"
    return False, "Normal detection pattern"

def detect_visual_anomalies(frame):
    hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
    saturation = hsv[:, :, 1]
    mean_sat = np.mean(saturation)
    std_sat = np.std(saturation)
    if mean_sat > 200 and std_sat < 20:
        return True, "Unusually uniform high-saturation region detected"
    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
    edges = cv2.Canny(gray, 100, 200)
    edge_density = np.sum(edges > 0) / edges.size
    if edge_density > 0.35:
        return True, "Abnormally high edge density detected"
    return False, "No visual anomalies"

sudo python3 radar_spoofer.py --target-radar 77e9 --mode spoof \
    --distance 50.0 --velocity -30.0 --rcs 10.0 \
    --signal-type FMCW --bandwidth 4e9 --chirp-rate 20e6
python3 analyze_radar_capture.py \
    --input radar_capture.raw \
    --fft-size 4096 \
    --doppler-analysis --range-doppler-map

import torch
import torch.nn.functional as F

def fgsm_attack(model, image, target, epsilon=0.03):
    image.requires_grad = True
    output = model(image.unsqueeze(0))
    loss = F.cross_entropy(output, target.unsqueeze(0))
    model.zero_grad()
    loss.backward()
    perturbed = image + epsilon * image.grad.sign()
    perturbed = torch.clamp(perturbed, 0, 1)
    return perturbed

def pgd_attack(model, image, target, epsilon=0.03, alpha=0.007, num_steps=40):
    perturbed = image.clone().detach()
    for _ in range(num_steps):
        perturbed.requires_grad = True
        output = model(perturbed.unsqueeze(0))
        loss = F.cross_entropy(output, target.unsqueeze(0))
        model.zero_grad()
        loss.backward()
        adv_data = perturbed + alpha * perturbed.grad.sign()
        eta = torch.clamp(adv_data - image, -epsilon, epsilon)
        perturbed = torch.clamp(image + eta, 0, 1).detach()
    return perturbed

def detect_adversarial_input(image, model, threshold=0.85):
    with torch.no_grad():
        output = model(image.unsqueeze(0))
        probs = F.softmax(output, dim=1)
        max_prob = torch.max(probs).item()
        entropy = -torch.sum(probs * torch.log(probs + 1e-8)).item()
    suspicious = False
    reasons = []
    if max_prob > threshold:
        suspicious = True
        reasons.append(f"Abnormally high confidence: {max_prob:.4f}")
    if entropy < 0.1:
        suspicious = True
        reasons.append(f"Abnormally low entropy: {entropy:.4f}")
    grad = torch.autograd.grad(
        F.cross_entropy(output, target.unsqueeze(0)), image
    )[0]
    grad_norm = torch.norm(grad).item()
    if grad_norm > 5.0:
        suspicious = True
        reasons.append(f"Abnormally high gradient norm: {grad_norm:.4f}")
    return suspicious, reasons, max_prob, entropy, grad_norm

import torch
import torch.nn as nn
from sklearn.metrics import roc_curve, auc

class NeuralCleanseDetector:
    def __init__(self, model, num_classes=10):
        self.model = model
        self.num_classes = num_classes

    def detect_backdoor(self, target_class, num_steps=1000, lr=0.1):
        trigger = torch.randn(1, 3, 32, 32, requires_grad=True)
        mask = torch.randn(1, 1, 32, 32, requires_grad=True)
        mask = torch.sigmoid(mask)
        optimizer = torch.optim.Adam([trigger, mask], lr=lr)
        for step in range(num_steps):
            optimizer.zero_grad()
            poisoned_input = mask * trigger + (1 - mask) * clean_input
            output = self.model(poisoned_input)
            loss_clean = F.cross_entropy(output, torch.tensor([target_class]))
            reg_loss = torch.sum(torch.abs(mask))
            total_loss = loss_clean + 0.001 * reg_loss
            total_loss.backward()
            optimizer.step()
        trigger_norm = torch.norm(mask * trigger).item()
        return trigger, mask, trigger_norm

    def spectral_signature_detection(self, activations, threshold=0.5):
        mean_act = torch.mean(activations, dim=0)
        centered = activations - mean_act
        _, s, _ = torch.svd(centered)
        s_normalized = s / torch.sum(s)
        if s_normalized[0] > threshold:
            return True, s_normalized[:5].tolist()
        return False, s_normalized[:5].tolist()

    def activation_clustering(self, representations, true_labels):
        from sklearn.cluster import KMeans
        from sklearn.metrics import silhouette_score
        kmeans = KMeans(n_clusters=2, random_state=42)
        clusters = kmeans.fit_predict(representations.numpy())
        score = silhouette_score(representations.numpy(), clusters)
        cluster_0_mask = clusters == 0
        cluster_1_mask = clusters == 1
        purity_0 = np.mean(true_labels[cluster_0_mask] == np.mode(true_labels[cluster_0_mask])[0])
        purity_1 = np.mean(true_labels[cluster_1_mask] == np.mode(true_labels[cluster_1_mask])[0])
        if purity_0 > 0.95 and purity_1