边缘AI推理安全取证深度分析

pip install onnx onnxruntime onnxsim protobuf
pip install netron tensorflow-lite
pip install torch torchvision
pip install scikit-learn numpy pandas
apt install uboot-tools mtd-utils
apt install nvidia-jetpack

import numpy as np
import onnx
from onnx import helper, TensorProto

def detect_ptq_anomaly(model_path):
    model = onnx.load(model_path)
    initializer_names = {init.name for init in model.graph.initializer}
    suspicious_scales = []
    
    for init in model.graph.initializer:
        if init.name.endswith('_scale') or init.name.endswith('_zero_point'):
            data = np.array(init.float_data if init.data_type == 1 else init.int32_data)
            if len(data) > 0:
                mean_val = np.mean(data)
                std_val = np.std(data)
                if std_val > 3 * mean_val or np.any(data < 0):
                    suspicious_scales.append({
                        'name': init.name,
                        'mean': float(mean_val),
                        'std': float(std_val),
                        'min': float(np.min(data)),
                        'max': float(np.max(data))
                    })
    
    return suspicious_scales

def compare_inference_outputs(clean_model, suspect_model, input_data):
    import onnxruntime as ort
    
    sess_clean = ort.InferenceSession(clean_model)
    sess_suspect = ort.InferenceSession(suspect_model)
    
    output_clean = sess_clean.run(None, {'input': input_data})[0]
    output_suspect = sess_suspect.run(None, {'input': input_data})[0]
    
    cosine_sim = np.dot(output_clean.flatten(), output_suspect.flatten()) / (
        np.linalg.norm(output_clean) * np.linalg.norm(output_suspect)
    )
    
    max_diff = np.max(np.abs(output_clean - output_suspect))
    mean_diff = np.mean(np.abs(output_clean - output_suspect))
    
    return {
        'cosine_similarity': float(cosine_sim),
        'max_difference': float(max_diff),
        'mean_difference': float(mean_diff),
        'anomaly': cosine_sim < 0.99 or max_diff > 0.1
    }

import numpy as np

def analyze_int8_weight_distribution(model_path):
    import onnx
    model = onnx.load(model_path)
    anomalies = []
    
    for init in model.graph.initializer:
        if init.data_type == TensorProto.INT8:
            data = np.array(init.int32_data).astype(np.int8)
            hist, bins = np.histogram(data, bins=256, range=(-128, 127))
            
            non_zero_ratio = np.count_nonzero(data) / len(data)
            
            entropy = -np.sum((hist[hist>0]/len(data)) * np.log2(hist[hist>0]/len(data)))
            
            unique_values = len(np.unique(data))
            compression_ratio = unique_values / 256
            
            if non_zero_ratio > 0.95 and entropy < 5.0:
                anomalies.append({
                    'tensor': init.name,
                    'anomaly_type': 'suspicious_sparse_pattern',
                    'non_zero_ratio': non_zero_ratio,
                    'entropy': float(entropy),
                    'unique_values': unique_values
                })
            
            if unique_values < 10:
                anomalies.append({
                    'tensor': init.name,
                    'anomaly_type': 'extreme_quantization_outlier',
                    'unique_values': unique_values,
                    'compression_ratio': compression_ratio
                })
    
    return anomalies

python3 -c "
import onnx
from onnx import shape_inference
import sys

model = onnx.load(sys.argv[1])
onnx.checker.check_model(model)

graph = model.graph
print(f'Nodes: {len(graph.node)}')
print(f'Initializers: {len(graph.initializer)}')
print(f'Inputs: {len(graph.input)}')
print(f'Outputs: {len(graph.output)}')

for node in graph.node:
    if node.op_type in ['MatMul', 'Gemm', 'Conv']:
        print(f'SensitiveOp: {node.op_type} -> {node.output}')
    if any(p for p in node.attribute if p.name == 'axis'):
        print(f'AxisAttr: {node.name} axis={getattr(p, \"i\", None)}')
" model.onnx

trtexec --onnx=model.onnx --saveEngine=model.engine --verbose 2>&1 | \
    grep -E "(Layer|Reorder|Scale|Activation|Convolution)" | \
    head -50

python3 -c "
from openvino.runtime import Core
import numpy as np

core = Core()
model = core.read_model('model.xml')

for node in model.get_ordered_ops():
    if 'Constant' in node.get_type_name():
        weights = node.data
        if weights is not None:
            stats = {
                'name': node.get_friendly_name(),
                'shape': list(node.shape),
                'mean': float(np.mean(weights)),
                'std': float(np.std(weights)),
                'min': float(np.min(weights)),
                'max': float(np.max(weights))
            }
            if stats['std'] > 10 * abs(stats['mean']):
                print(f'ANOMALY: {stats}')
" 2>/dev/null

源模型(PyTorch) → [恶意转换脚本] → ONNX → [篡改的TensorRT] → 部署引擎
                        ↑                                    ↑
                  权重扰动插入                         层融合篡改
                  算子替换                           精度降级
                  元数据注入                         内存布局修改

import hashlib
import os

def compute_model_chain_hash(model_dir):
    file_hashes = {}
    for root, dirs, files in os.walk(model_dir):
        for f in sorted(files):
            if f.endswith(('.onnx', '.engine', '.tflite', '.xml', '.bin')):
                path = os.path.join(root, f)
                with open(path, 'rb') as fp:
                    file_hashes[path] = hashlib.sha256(fp.read()).hexdigest()
    return file_hashes

def verify_conversion_integrity(source_hash, converted_hashes, expected_mapping):
    results = []
    for src, dst in expected_mapping.items():
        if src not in source_hash:
            results.append({'file': src, 'status': 'MISSING_SOURCE'})
            continue
        if dst not in converted_hashes:
            results.append({'file': dst, 'status': 'MISSING_CONVERTED'})
            continue
        results.append({
            'source': src,
            'converted': dst,
            'source_hash': source_hash[src][:16],
            'converted_hash': converted_hashes[dst][:16],
            'status': 'PRESENT'
        })
    return results

import numpy as np
from collections import defaultdict
import json

def detect_model_extraction_queries(log_file):
    with open(log_file, 'r') as f:
        logs = [json.loads(line) for line in f]
    
    query_patterns = defaultdict(list)
    for entry in logs:
        query_patterns[entry.get('source_ip', 'unknown')].append(entry)
    
    suspicious_sources = []
    for ip, queries in query_patterns.items():
        if len(queries) < 100:
            continue
        
        timestamps = [q.get('timestamp', 0) for q in queries]
        intervals = np.diff(sorted(timestamps))
        
        if len(intervals) > 0:
            mean_interval = np.mean(intervals)
            std_interval = np.std(intervals)
            
            unique_inputs = len(set(q.get('input_hash', '') for q in queries))
            query_diversity = unique_inputs / len(queries)
            
            if query_diversity > 0.95 and mean_interval < 1.0:
                suspicious_sources.append({
                    'source_ip': ip,
                    'query_count': len(queries),
                    'query_diversity': query_diversity,
                    'mean_interval': float(mean_interval),
                    'std_interval': float(std_interval),
                    'risk_level': 'HIGH'
                })
    
    return suspicious_sources

openocd -f interface/jlink.cfg \
    -f target/stm32f4x.cfg \
    -c "init" \
    -c "reset init" \
    -c "dump_image firmware_dump.bin 0x08000000 0x100000" \
    -c "shutdown"

docker exec edge_ai_container cat /proc/self/cgroup | grep -v docker
cat /proc/1/cgroup 2>/dev/null | head -5
ls -la /proc/1/ns/
readlink /proc/1/ns/*

模型文件恶意构造（T1203）
    → 推理引擎内存破坏（T1203）
        → 沙箱内代码执行（T1055）
            → 容器逃逸（T1611）
                → 内核权限提升（T1068）
                    → 系统完全控制（T1078）

import numpy as np
import onnxruntime as ort

def verify_backdoor_watermark(model_path, trigger_samples, expected_labels, input_name):
    session = ort.InferenceSession(model_path)
    
    results = {
        'total_triggers': len(trigger_samples),
        'correct_predictions': 0,
        'watermark_verified': False
    }
    
    for trigger, expected in zip(trigger_samples, expected_labels):
        output = session.run(None, {input_name: trigger})[0]
        predicted = np.argmax(output, axis=1)[0]
        
        if predicted == expected:
            results['correct_predictions'] += 1
    
    success_rate = results['correct_predictions'] / results['total_triggers']
    results['success_rate'] = float(success_rate)
    results['watermark_verified'] = success_rate > 0.95
    
    return results

import json
import numpy as np
from datetime import datetime, timedelta

def analyze_inference_logs(log_path):
    with open(log_path, 'r') as f:
        entries = [json.loads(line) for line in f]
    
    timestamps = [datetime.fromisoformat(e['timestamp']) for e in entries]
    latencies = [e.get('latency_ms', 0) for e in entries]
    confidences = [e.get('confidence', 0) for e in entries]
    model_versions = [e.get('model_version', 'unknown') for e in entries]
    
    unique_versions = set(model_versions)
    
    latency_stats = {
        'mean': float(np.mean(latencies)),
        'std': float(np.std(latencies)),
        'p99': float(np.percentile(latencies, 99)),
        'max': float(np.max(latencies)),
        'outliers': sum(1 for l in latencies if l > np.mean(latencies) + 3 * np.std(latencies))
    }
    
    confidence_stats = {
        'mean': float(np.mean(confidences)),
        'min': float(np.min(confidences)),
        'below_threshold': sum(1 for c in confidences if c < 0.5),
        'distribution_shift': float(np.std(confidences)) > 0.3
    }
    
    version_changes = []
    for i in range(1, len(model_versions)):
        if model_versions[i] != model_versions[i-1]:
            version_changes.append({
                'timestamp': timestamps[i].isoformat(),
                'from': model_versions[i-1],
                'to': model_versions[i]
            })
    
    return {
        'total_entries': len(entries),
        'time_range': f"{timestamps[0]} to {timestamps[-1]}",
        'unique_versions': list(unique_versions),
        'latency_analysis': latency_stats,
        'confidence_analysis': confidence_stats,
        'version_changes': version_changes
    }

cat /var/log/device_health.log | \
    awk -F',' '{if($5 > 85 || $6 > 0.8) print $0}' | \
    head -20

journalctl -u edge-ai-service --since "2026-07-01" --until "2026-07-20" | \
    grep -E "(ERROR|FATAL|model.*load|inference.*fail)" | \
    tail -30

import json

def correlate_telemetry_sources(system_log, inference_log, network_log, metrics_log):
    timeline = []
    
    with open(system_log) as f:
        for line in f:
            entry = json.loads(line)
            entry['source'] = 'system'
            timeline.append(entry)
    
    with open(inference_log) as f:
        for line in f:
            entry = json.loads(line)
            entry['source'] = 'inference'
            timeline.append(entry)
    
    with open(network_log) as f:
        for line in f:
            entry = json.loads(line)
            entry['source'] = 'network'
            timeline.append(entry)
    
    with open(metrics_log) as f:
        for line in f:
            entry = json.loads(line)
            entry['source'] = 'metrics'
            timeline.append(entry)
    
    timeline.sort(key=lambda x: x.get('timestamp', ''))
    
    anomalies = []
    for i in range(1, len(timeline)):
        prev, curr = timeline[i-1], timeline[i]
        if prev['source'] != curr['source']:
            time_diff = 0
            try:
                t1 = datetime.fromisoformat(prev.get('timestamp', ''))
                t2 = datetime.fromisoformat(curr.get('timestamp', ''))
                time_diff = (t2 - t1).total_seconds()
            except:
                pass
            
            if time_diff < 1.0 and curr.get('type') in ['error', 'anomaly']:
                anomalies.append({
                    'timestamp': curr.get('timestamp'),
                    'cross_source_event': True,
                    'prev_source': prev['source'],
                    'curr_source': curr['source'],
                    'time_gap_seconds': time_diff
                })
    
    return anomalies

def calculate_evidence_confidence(evidence_list):
    score = 0
    for evidence in evidence_list:
        tier = evidence.get('tier', '')
        if tier == 'confirmed':
            score += 40
        elif tier == 'suspicious':
            score += 20
        elif tier == 'attention':
            score += 5
    
    sources = set(e.get('source', '') for e in evidence_list)
    score += len(sources) * 5
    
    attack_techniques = set()
    for e in evidence_list:
        for t in e.get('mitre_techniques', []):
            attack_techniques.add(t)
    score += len(attack_techniques) * 3
    
    time_correlated = sum(1 for i in range(len(evidence_list)-1) 
                         if evidence_list[i+1].get('timestamp', 0) - 
                            evidence_list[i].get('timestamp', 0) < 300)
    score += time_correlated * 5
    
    return min(score, 100)

title: 边缘AI设备高频模型查询检测
id: 8f3a2d1c-4b5e-4a7f-9c8d-1e2f3a4b5c6d
status: experimental
description: 检测边缘AI推理设备短时间内大量多样化查询，可能为模型提取攻击
author: x7peeps-forensics
date: 2026/07/20
tags:
  - attack.credential_access
  - attack.t1552
  - edge_ai
  - model_extraction
logsource:
  category: application
  product: edge_ai_inference
detection:
  selection_api_query:
    EventChannel: 'EdgeAI-Inference'
    EventType: 'API_QUERY'
    QueryCount|ge: 500
  selection_unique_inputs:
    EventChannel: 'EdgeAI-Inference'
    EventType: 'API_QUERY'
    UniqueInputHashes|ge: 450
  selection_query_diversity:
    EventChannel: 'EdgeAI-Inference'
    EventType: 'API_QUERY'
    InputDiversityScore|ge: 0.95
    QueryIntervalMean|le: 1.0
  condition: selection_api_query or selection_unique_inputs or selection_query_diversity
  timeframe: 5m
falsepositives:
  - 合法的负载测试
  - 自动化模型验证流程
level: high

#!/bin/bash
SCAN_DIR="${1:-/opt/edge-ai/models}"
REPORT_FILE="/tmp/model_integrity_$(date +%Y%m%d_%H%M%S).txt"
KNOWN_HASH_DB="/etc/edge-ai/model_hashes.db"

echo "==========================================" > "$REPORT_FILE"
echo "Edge AI Model Integrity Scan Report" >> "$REPORT_FILE"
echo "Scan Time: $(date -u '+%Y-%m-%dT%H:%M:%SZ')" >> "$REPORT_FILE"
echo "Scan Directory: $SCAN_DIR" >> "$REPORT_FILE"
echo "==========================================" >> "$REPORT_FILE"

find "$SCAN_DIR" -type f \( -name "*.onnx" -o -name "*.engine" -o -name "*.tflite" -o -name "*.xml" -o -name "*.bin" \) 2>/dev/null | while read -r MODEL_FILE; do
    CURRENT_HASH=$(sha256sum "$MODEL_FILE" | awk '{print $1}')
    FILE_SIZE=$(stat -f%z "$MODEL_FILE" 2>/dev/null || stat -c%s "$MODEL_FILE" 2>/dev/null)
    FILE_MTIME=$(stat -f"%m" "$MODEL_FILE" 2>/dev/null || stat -c"%Y" "$MODEL_FILE" 2>/dev/null)
    
    if [ -f "$KNOWN_HASH_DB" ]; then
        EXPECTED_HASH=$(grep "^$MODEL_FILE " "$KNOWN_HASH_DB" | awk '{print $2}')
        if [ -n "$EXPECTED_HASH" ] && [ "$CURRENT_HASH" != "$EXPECTED_HASH" ]; then
            echo "[CRITICAL] HASH_MISMATCH: $MODEL_FILE" >> "$REPORT_FILE"
            echo "  Expected: $EXPECTED_HASH" >> "$REPORT_FILE"
            echo "  Current:  $CURRENT_HASH" >> "$REPORT_FILE"
        elif [ -z "$EXPECTED_HASH" ]; then
            echo "[WARNING] UNKNOWN_MODEL: $MODEL_FILE (not in hash database)" >> "$REPORT_FILE"
        else
            echo "[OK] VERIFIED: $MODEL_FILE" >> "$REPORT_FILE"
        fi
    else
        echo "[INFO] NO_HASH_DB: $MODEL_FILE -> $CURRENT_HASH" >> "$REPORT_FILE"
    fi
    
    FILE_KB=$((FILE_SIZE / 1024))
    if [ "$FILE_KB" -gt 500000 ]; then
        echo "[WARNING] LARGE_MODEL: $MODEL_FILE ($FILE_KB KB)" >> "$REPORT_FILE"
    fi
    
    NOW=$(date +%s)
    AGE_DAYS=$(( (NOW - FILE_MTIME) / 86400 ))
    if [ "$AGE_DAYS" -lt 1 ]; then
        echo "[INFO] RECENTLY_MODIFIED: $MODEL_FILE (${AGE_DAYS}d ago)" >> "$REPORT_FILE"
    fi
done

if [ -d "/opt/edge-ai/logs" ]; then
    echo "" >> "$REPORT_FILE"
    echo "--- Inference Log Anomaly Scan ---" >> "$REPORT_FILE"
    find /opt/edge-ai/logs -name "*.log" -mtime -7 | while read -r LOG_FILE; do
        ERROR_COUNT=$(grep -c "ERROR\|FATAL\|panic" "$LOG_FILE" 2>/dev/null || echo 0)
        LOAD_COUNT=$(grep -c "model.*load" "$LOG_FILE" 2>/dev/null || echo 0)
        echo "File: $LOG_FILE" >> "$REPORT_FILE"
        echo "  Errors: $ERROR_COUNT, Model Loads: $LOAD_COUNT" >> "$REPORT_FILE"
    done
fi

echo "" >> "$REPORT_FILE"
echo "Scan Complete: $(date -u '+%Y-%m-%dT%H:%M:%SZ')" >> "$REPORT_FILE"
cat "$REPORT_FILE"

import os
import sys
import json
import hashlib
import numpy as np
from pathlib import Path

def scan_quantization_anomalies(model_directory):
    results = {
        'scan_time': __import__('datetime').datetime.utcnow().isoformat(),
        'directory': str(model_directory),
        'models_scanned': 0,
        'anomalies_found': 0,
        'findings': []
    }
    
    model_extensions = {'.onnx', '.tflite', '.xml', '.bin', '.engine'}
    
    for root, dirs, files in os.walk(model_directory):
        for filename in sorted(files):
            filepath = Path(root) / filename
            if filepath.suffix not in model_extensions:
                continue
            
            results['models_scanned'] += 1
            finding = {
                'file': str(filepath),
                'size_bytes': filepath.stat().st_size,
                'sha256': '',
                'checks': []
            }
            
            with open(filepath, 'rb') as f:
                file_data = f.read()
                finding['sha256'] = hashlib.sha256(file_data).hexdigest()
            
            if filepath.suffix == '.onnx':
                try:
                    import onnx
                    model = onnx.load(str(filepath))
                    
                    for init in model.graph.initializer:
                        if init.data_type in [10, 11, 12]:
                            data = np.array(init.float_data or init.int32_data or init.int64_data)
                            if len(data) > 100:
                                mean_val = float(np.mean(np.abs(data)))
                                std_val = float(np.std(data))
                                entropy = float(-np.sum(
                                    (np.histogram(data, bins=50)[0] / len(data) + 1e-10) *
                                    np.log2(np.histogram(data, bins=50)[0] / len(data) + 1e-10)
                                ))
                                
                                if entropy < 2.0 and len(data) > 1000:
                                    finding['checks'].append({
                                        'type': 'low_entropy_weights',
                                        'tensor': init.name,
                                        'entropy': round(entropy, 4),
                                        'severity': 'high'
                                    })
                                    results['anomalies_found'] += 1
                except Exception as e:
                    finding['checks'].append({
                        'type': 'parse_error',
                        'error': str(e)[:200],
                        'severity': 'info'
                    })
            
            if len(file_data) > 1024:
                byte_freq = np.zeros(256)
                for b in file_data[:min(len(file_data), 1048576)]:
                    byte_freq[b] += 1
                byte_freq = byte_freq / byte_freq.sum()
                file_entropy = float(-np.sum(byte_freq[byte_freq > 0] * np.log2(byte_freq[byte_freq > 0])))
                
                if file_entropy < 4.0:
                    finding['checks'].append({
                        'type': 'low_file_entropy',
                        'entropy': round(file_entropy, 4),
                        'severity': 'medium'
                    })
            
            if finding['checks']:
                results['findings'].append(finding)
    
    return results

if __name__ == '__main__':
    target = sys.argv[1] if len(sys.argv) > 1 else '/opt/edge-ai/models'
    report = scan_quantization_anomalies(target)
    print(json.dumps(report, indent=2, ensure_ascii=False))

rule EdgeAI_Suspicious_ONNX_Model {
    meta:
        description = "Detects suspicious patterns in ONNX model files"
        author = "x7peeps-forensics"
        date = "2026-07-20"
        severity = "high"
        attack_technique = "T1195.002"
    
    strings:
        $onnx_magic = { 08 07 }
        $onnx_header = "onnx" nocase
        $suspicious_domain = "http://" ascii
        $suspicious_url = "https://" ascii
        $base64_prefix = "TVqQ" ascii
        $shell_cmd = "sh -c" ascii
        $shell_cmd2 = "/bin/sh" ascii
        $python_import = "exec" ascii
        $eval_call = "eval(" ascii
        $pickle_header = { 80 4B 03 04 }
        $marshal_header = { 33 0D 0D 0A }
    
    condition:
        ($onnx_magic at 0 or $onnx_header at 0) and
        (
            ($suspicious_domain or $suspicious_url) or
            ($base64_prefix and ($shell_cmd or $shell_cmd2)) or
            ($python_import and $eval_call) or
            ($pickle_header or $marshal_header)
        )
}

rule EdgeAI_Quantized_Model_Anomaly {
    meta:
        description = "Detects anomalies in quantized AI model files"
        author = "x7peeps-forensics"
        date = "2026-07-20"
        severity = "medium"
    
    strings:
        $tflite_magic = { 20 00 00 00 54 46 4C 33 }
        $onnx_magic = { 08 07 }
        $ir_xml_header = "<?xml" ascii
        $ir_bin_header = { 49 52 }
        $encrypted_section = { 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 }
        $null_heavy_block = { 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 }
    
    condition:
        ($tflite_magic at 0 or $onnx_magic at 0 or $ir_xml_header at 0) and
        (#null_heavy_block > 50)
}

1. 环境侦察（T1592）→ 了解目标车辆型号及感知模型版本
2. 对抗样本制作（T1200）→ 生成针对特定模型的对抗性补丁
3. 物理投放（T1200）→ 在测试道路关键位置布置对抗样本
4. 触发误判（T1200）→ 车辆驶入触发区域，模型输出异常
5. 潜在危害（T1200）→ 物体检测失效，可能导致安全事故

对抗样本SHA-256: a1b2c3d4e5f6...（物理打印件）
触发坐标范围: (39.9042°N, 116.4074°E) 100m半径
受影响模型版本: PerceptionNet-v3.2.1
误判类别: pedestrian -> traffic_sign (置信度 0.87)

1. 供应链渗透（T1195.002）→ 入侵模型训练流程
2. 后门植入（T1195.002）→ 在QAT过程中植入触发后门
3. OTA投毒（T1195.001）→ 通过被篡改的OTA服务器分发
4. 设备更新（T1195.001）→ 边缘设备自动拉取恶意更新
5. 后门激活（T1200）→ 特定触发条件下绕过检测
6. 持续监控（T1041）→ 通过隐蔽通道回传监控数据

恶意OTA服务器IP: 203.0.113.42
恶意OTA服务器域名: ota-edge-update.example[.]com
恶意模型文件SHA-256: f7e8d9c0b1a2...（植入后门的权重文件）
触发样本特征: 特定面部关键点距离比 = [0.32, 0.45, 0.67, 0.28]
C2通信域名: cam-monitoring.example[.]com
C2通信端口: TCP/4433
恶意固件版本号: FW-v2.4.8-patched

1. 物理接入（T1200）→ 获得边缘设备物理访问权限
2. 调试接口利用（T1212）→ 通过JTAG接口读取设备内存
3. 模型提取（T1005）→ 导出设备上的ONNX模型文件
4. 脱敏处理（T1074）→ 清除设备上的操作痕迹
5. 离线分析（T1041）→ 在本地环境逆向分析模型结构
6. 知识窃取（T1005）→ 通过模型蒸馏获取核心算法

JTAG会话记录: /var/log/jtag_sessions.log
提取的模型文件: model_detector.onnx (SHA-256: b3c4d5e6f7a8...)
USB设备序列号: 0x12345678 (SanDisk Ultra)
操作时段: 2023-11-15 02:15:00 UTC 至 03:45:00 UTC
操作终端MAC地址: AA:BB:CC:DD:EE:FF

#!/bin/bash
echo "=== Edge AI Device Hardening Checklist ==="

echo "[1/10] Disable unused debug interfaces"
if command -v openocd &> /dev/null; then
    echo "  WARNING: OpenOCD available, consider removing in production"
fi

echo "[2/10] Verify model file permissions"
find /opt/edge-ai/models -type f -exec ls -la {} \; | \
    awk '$1 !~ /^-r--------/ {print "  INSECURE: " $NF " (" $1 ")"}'

echo "[3/10] Check for unauthorized services"
systemctl list-units --type=service --state=running | \
    grep -v -E "(edge-ai|systemd|ssh|docker)" | \
    awk '{print "  UNKNOWN SERVICE: " $1}'

echo "[4/10] Verify network firewall rules"
iptables -L -n 2>/dev/null | head -20

echo "[5/10] Check disk encryption status"
lsblk -o NAME,FSTYPE,SIZE,MOUNTPOINT,CRYPT 2>/dev/null

echo "[6/10] Verify secure boot status"
mokutil --sb-state 2>/dev/null || echo "  Secure Boot status unknown"

echo "[7/10] Check NTP synchronization"
timedatectl status 2>/dev/null | grep -i "synchronized"

echo "[8/10] Verify log integrity"
find /var/log -name "*.log" -mtime -1 | wc -l | \
    xargs -I {} echo "  Recent log files: {}"

echo "[9/10] Check GPU driver integrity"
nvidia-smi 2>/dev/null | head -5 || echo "  NVIDIA GPU not detected"

echo "[10/10] Verify OTA update signatures"
find /opt/edge-ai/updates -name "*.sig" 2>/dev/null | wc -l | \
    xargs -I {} echo "  Signed updates available: {}"

echo "=== Checklist Complete ==="