ARTICLE / 安全

GPU与异构计算安全取证深度分析

Updated: 2026-07-21
Reading time: 27 min

随着人工智能、加密货币挖矿和高性能计算的快速发展，GPU（Graphics Processing Unit）及各类异构计算加速器已成为现代计算基础设施的核心组件。然而，这些设备的并行计算架构与传统 CPU 存在根本性差异，使得传统的数字取证方法面临全新挑战。攻击者越来越多地利用 GPU 的高吞吐能力执行恶意计算、窃取 AI 模型、实施侧信道攻击，甚至通过 GPU 驱动漏洞获取系统级权限。本文系统性地剖析 GPU 与异构计算环境下的安全取证方法论，涵盖从显存数据恢复到 AI 加速器固件审计的完整技术栈。

0x01 GPU异构计算架构与取证概述

1.1 GPU 架构基础：SIMT 执行模型

GPU 采用 SIMT（Single Instruction, Multiple Threads）执行模型，与 CPU 的 SIM/SIMD 模型有本质区别。在 NVIDIA GPU 中，最小执行单元为 Warp（32 个线程以锁步方式执行相同指令），而 AMD GPU 使用 Wavefront（64 个线程）。SIMT 模型意味着 GPU 上的恶意代码以数千甚至数百万并发线程的形式执行，这为取证分析带来了独特的挑战——传统的单线程调试和追踪方法完全失效。

GPU 的核心计算单元是 SM（Streaming Multiprocessor），每个 SM 包含多个 CUDA Core（NVIDIA）或 Stream Core（AMD），以及专用的特殊函数单元（SFU）和加载/存储单元。以 NVIDIA H100 为例，单个 SM 包含 128 个 FP32 CUDA Core，全芯片共 132 个 SM，总计 16,896 个 CUDA Core。这种高度并行的架构使得 GPU 上的恶意计算极难被实时检测，因为单个线程的行为可能被海量并行线程所掩盖。

1.2 GPU 存储层次结构

GPU 的存储层次结构与 CPU 存在显著差异，直接决定了取证分析的可行性和难度：

存储层级	容量范围	延迟	取证可访问性	数据持久性
寄存器（Register）	每线程 255 个 32-bit 寄存器	~1 周期	极难获取（需停机调试）	易失性
共享内存（Shared Memory）	每 SM 48-164 KB	~5 周期	可通过 CUDA 调试 API 获取	易失性
L1 缓存	每 SM 128 KB（与共享内存共用）	~30 周期	需专用工具访问	易失性
L2 缓存	全芯片 4-60 MB	~200 周期	需专用工具访问	易失性
全局显存（VRAM）	4-80 GB HBM/GDDR	~400-600 周期	可通过 PCIe BAR/NVML 获取	易失性
系统内存（通过 PCIe）	受限于 PCIe 带宽	~10,000+ 周期	通过 CPU 侧内存分析	依赖系统

对于取证分析而言，VRAM（Video RAM） 是最关键的取证目标，因为它是 GPU 与主机系统共享数据的主要通道。当前主流 GPU 使用 HBM3（High Bandwidth Memory）或 GDDR6X 显存，带宽可达数 TB/s，但这些高速存储在断电后数据立即消失。

1.3 异构计算框架生态

GPU 异构计算涉及多个并行框架，每个框架的二进制格式和运行时行为不同，直接影响取证分析策略：

框架	主要厂商	二进制格式	运行时	取证关键特征
CUDA	NVIDIA	PTX / cubin	CUDA Runtime	.cubin/.fatbin 文件、nvrtc 编译缓存
OpenCL	Khronos 跨平台	SPIR-V / PTX	各厂商 ICD	clCreateProgramWithBinary 缓存
Vulkan Compute	Khronos 跨平台	SPIR-V	Vulkan Driver	着色器模块二进制、管线缓存
Metal	Apple	AIR (Apple IR)	Metal Framework	.metallib 文件、着色器缓存
ROCm/HIP	AMD	AMDGCN / HSAIL	ROCr Runtime	.co (Code Object) 文件
SYCL	Khronos 跨平台	SPIR-V	各厂商后端	与 OpenCL/Level Zero 共享格式

1.4 AI 加速器生态

除了 GPU，专用 AI 加速器正在快速普及：

NPU（Neural Processing Unit）：集成于 CPU 芯片内的专用神经网络推理引擎，如 Intel Meteor Lake 的 NPU、Apple Neural Engine、Qualcomm Hexagon DSP
TPU（Tensor Processing Unit）：Google 专为 TensorFlow 优化的 ASIC 芯片，使用 Systolic Array 架构
Intel Gaudi（Habana Labs）：面向数据中心的 AI 训练和推理加速器
AMD XDNA（Ryzen AI）：基于 Xilinx Versal 架构的 AI 引擎

1.5 GPU 取证与 CPU 取证的根本差异

GPU 取证面临 CPU 取证中不存在的特殊挑战：

差异维度	CPU 取证	GPU 取证
执行模型	单线程/少量线程，顺序执行	数千线程并行，SIMT 锁步
内存模型	统一虚拟内存，地址空间隔离	独立显存空间，PCIe BAR 映射
调试接口	ptrace、/proc、调试寄存器	nvidia-debug API、CUDA调试器
驱动依赖	标准内核接口（sysfs/procfs）	专有用户态驱动，权限隔离
持久化存储	硬盘/SSD 易获取	GPU 上无持久化存储，断电即失
固件分析	BIOS/UEFI 可提取	GPU VBIOS 需专用工具
多租户隔离	进程/容器隔离	MIG/vGPU/Timeslicing 复杂

1.6 GPU 取证工具链

工具名称	功能	平台	取证用途
nvidia-smi	GPU 状态监控	Linux/Windows	进程识别、显存使用监控
nvml（NVML Library）	GPU 管理 API	Linux/Windows	程序化 GPU 状态获取
GPU-Z	GPU 详细信息	Windows	GPU 型号、驱动版本、VBIOS 信息
cuda-gdb	CUDA 调试器	Linux	GPU 内存检查、内核调试
cuda-memcheck	CUDA 内存检查	Linux	显存越界检测、未初始化访问
rocm-smi	AMD GPU 监控	Linux	AMD GPU 状态与进程信息
gpustat	GPU 状态美化显示	Linux/Windows	快速 GPU 进程概览
nvidia-settings	NVIDIA 配置工具	Linux/Windows	GPU 配置状态导出
Compute Sanitizer	CUDA 内存验证	Linux/Windows	GPU 内存访问模式分析
NSight Systems	NVIDIA 性能分析	Linux/Windows	GPU 活动时间线追踪

1.7 MITRE ATT&CK 映射

GPU 与异构计算安全取证涉及的 MITRE ATT&CK 战术与技术：

攻击技术	ATT&CK ID	与 GPU 取证的关联
Resource Hijacking	T1496	GPU 挖矿、恶意计算资源占用
Data from Local System	T1005	从 GPU 显存提取敏感数据
Unsecured Credentials	T1552	GPU 驱动/固件中残留的凭据
Exploitation for Privilege Escalation	T1068	GPU 驱动漏洞提权
Supply Chain Compromise	T1195	GPU 驱动/固件供应链攻击
Impair Defenses	T1562	利用 GPU 绕过安全检测
Exfiltration Over Web Service	T1567	通过 GPU 计算通道渗出数据

0x02 GPU显存取证分析方法

2.1 VRAM 获取方法论

GPU 显存取证是 GPU 安全分析的核心环节。与传统的内存取证（如使用 Volatility 分析系统 RAM）不同，VRAM 的获取需要绕过 GPU 驱动的抽象层直接访问硬件。

2.1.1 通过 NVML API 获取显存信息

NVML（NVIDIA Management Library）提供了对 GPU 状态的编程级访问能力。取证人员可使用以下方法获取 GPU 运行时信息：

nvidia-smi --query-gpu=timestamp,name,pci.bus_id,driver_version,pstate,pcie.link.gen.max,pcie.link.gen.current,temperature.gpu,utilization.gpu,utilization.memory,memory.total,memory.free,memory.used --format=csv -l 1

上述命令以 1 秒间隔持续记录 GPU 状态，包括显存使用量、GPU 利用率和温度。在取证场景中，持续监控可以识别异常的显存分配模式——例如加密货币挖矿软件通常会持续占用大量显存并保持高 GPU 利用率。

nvidia-smi --query-compute-apps=pid,process_name,used_memory,command_line --format=csv

该命令列出所有正在使用 GPU 计算资源的进程，包括其命令行参数，是识别恶意 CUDA 进程的首要检查手段。

2.1.2 通过 /dev/nvidia* 设备文件获取

在 Linux 系统中，NVIDIA GPU 暴露以下设备文件：

ls -la /dev/nvidia*
ls -la /dev/nvidiactl
ls -la /dev/nvidia-uvm
ls -la /dev/nvidia-modeset

这些设备文件提供了对 GPU 的直接访问通道。/dev/nvidia0（或类似编号）是 GPU 的主要设备节点，/dev/nvidiactl 用于控制操作，/dev/nvidia-uvm 用于 Unified Virtual Memory 管理。取证分析中，检查这些设备文件的权限设置和访问日志可以揭示未授权的 GPU 访问。

cat /proc/driver/nvidia/gpus/*/information
cat /proc/driver/nvidia/gpus/*/params

通过 procfs 接口获取 NVIDIA 驱动暴露的 GPU 信息，包括 GPU 的 PCI 地址、型号、驱动版本和性能状态。

2.1.3 通过 PCIe BAR 直接读取

对于高级取证场景，可通过 PCI 母线直接读取 GPU 的 PCIe Base Address Register（BAR）空间：

lspci -v -s $(lspci | grep -i nvidia | head -1 | cut -d' ' -f1)
lspci -x -s $(lspci | grep -i nvidia | head -1 | cut -d' ' -f1)

PCIe BAR 空间映射了 GPU 的控制寄存器和部分显存区域。在内核模块配合下，取证人员可直接读取 VRAM 内容，但这需要极高的权限且可能干扰 GPU 的正常运行。

2.2 显存数据结构分析

VRAM 中存储的关键数据结构包括：

数据结构	描述	取证价值
CUDA Context	CUDA 运行时上下文，包含设备状态、内存分配表	识别 CUDA 应用行为、提取内核参数
Device Memory Allocations	GPU 全局内存分配记录	追踪恶意数据存储位置
Texture Memory	纹理映射数据	可能包含隐写数据
Constant Memory	常量内存区域	存储加密密钥、矿池地址等常量
CUDA Streams	异步执行流	分析并行任务调度模式
GPU Page Tables	GPU 页表	虚拟地址到物理地址映射
Command Buffers	GPU 命令缓冲区	提交到 GPU 的计算指令队列

2.3 显存 Dump 技术

2.3.1 基于 CUDA 调试 API 的显存转储

import subprocess
import struct
import ctypes

def get_gpu_memory_info():
    result = subprocess.run(
        ['nvidia-smi', '--query-gpu=memory.used,memory.total',
         '--format=csv,noheader,nounits'],
        capture_output=True, text=True
    )
    lines = result.stdout.strip().split('\n')
    for line in lines:
        used, total = [int(x.strip()) for x in line.split(',')]
        print(f"显存使用: {used} MB / {total} MB ({used/total*100:.1f}%)")

def get_gpu_compute_processes():
    result = subprocess.run(
        ['nvidia-smi', '--query-compute-apps=pid,process_name,used_memory',
         '--format=csv,noheader,nounits'],
        capture_output=True, text=True
    )
    print("GPU 计算进程:")
    for line in result.stdout.strip().split('\n'):
        if line.strip():
            parts = [x.strip() for x in line.split(',')]
            print(f"  PID: {parts[0]}, 进程: {parts[1]}, 显存: {parts[2]} MB")

if __name__ == '__main__':
    get_gpu_memory_info()
    get_gpu_compute_processes()

2.3.2 基于 nvidia-smi 的周期性显存快照

#!/bin/bash
SNAPSHOT_DIR="/forensics/gpu_snapshots/$(date +%Y%m%d_%H%M%S)"
mkdir -p "$SNAPSHOT_DIR"

for i in $(seq 1 60); do
    TIMESTAMP=$(date +%Y%m%d_%H%M%S_%N)
    nvidia-smi --query-gpu=timestamp,name,utilization.gpu,utilization.memory,memory.used,memory.free,temperature.gpu,power.draw --format=csv > "$SNAPSHOT_DIR/gpu_state_${TIMESTAMP}.csv"
    nvidia-smi --query-compute-apps=pid,process_name,used_memory --format=csv > "$SNAPSHOT_DIR/gpu_procs_${TIMESTAMP}.csv"
    nvidia-smi -q > "$SNAPSHOT_DIR/gpu_full_${TIMESTAMP}.txt"
    sleep 5
done

echo "[+] GPU 快照采集完成: $SNAPSHOT_DIR"

2.4 显存取证的挑战

挑战	描述	缓解策略
GPU 内存碎片化	GPU 分配器使用页级管理，大块分配可能跨多个物理页	使用 CUDA Memory Pool 分析工具重建分配映射
驱动状态依赖	VRAM 内容的解释依赖于当前 GPU 驱动状态和上下文	在取证前固定驱动版本，记录完整驱动状态
实时覆写	GPU 内核可能持续覆写显存数据	使用快照技术在特定时间点冻结显存状态
断电即失	VRAM 为易失性存储，断电后数据立即消失	在系统运行时进行热取证，避免关机
权限限制	用户态程序无法直接访问其他进程的显存	使用 root 权限或内核模块进行访问
多 GPU 拓扑	多 GPU 系统中 NVLink/PCIe 拓扑影响内存可见性	逐卡采集，注意 GPU 间通信通道

2.5 虚拟 GPU 与 MIG 环境的取证

NVIDIA 的 MIG（Multi-Instance GPU）技术将单个物理 GPU 划分为最多 7 个独立的 GPU 实例，每个实例拥有独立的显存和计算资源。在多租户云环境中，取证分析需要额外关注：

nvidia-smi mig -lgi
nvidia-smi mig -lgc
nvidia-smi mig -lsm

这些命令分别列出 MIG GPU 实例、计算实例和 GPU 切片信息。在安全事件中，攻击者可能通过一个 MIG 实例尝试访问其他实例的显存空间，因此需要检查 MIG 隔离配置的完整性。

0x03 CUDA恶意计算与挖矿取证

3.1 GPU 加密货币挖矿概述

加密货币挖矿是 GPU 恶意计算最常见的应用场景。由于 GPU 的并行计算能力远超 CPU（以 Ethash 算法为例，高端 GPU 的哈希率是 CPU 的 50-100 倍），攻击者越来越多地利用被入侵系统的 GPU 资源进行挖矿。

挖矿算法	主要币种	GPU 计算特征	显存需求	取证检测难度
Ethash	Ethereum (ETC)	DAG 计算密集型	4-8 GB	🟡 中等
KawPoW	Ravencoin	内存带宽密集型	3-6 GB	🟡 中等
RandomX (GPU)	Monero (部分变种)	混合 CPU/GPU 计算	2-4 GB	🔴 较难
KawZel	Neoxa	与 KawPoW 类似	3-4 GB	🟡 中等
Autolykos	Ergo	内存硬函数	4-6 GB	🟡 中等
Octopus	Conflux	中等内存需求	4-8 GB	🟢 较易

3.2 GPU 挖矿进程检测

3.2.1 nvidia-smi 异常模式识别

GPU 挖矿软件在 nvidia-smi 中表现出明显的异常特征：

nvidia-smi --query-gpu=timestamp,utilization.gpu,utilization.memory,memory.used,temperature.gpu,power.draw --format=csv -l 2

挖矿行为的典型指标：

GPU 利用率持续高于 85%（排除正常渲染负载）
显存使用量突然增加且保持稳定（DAG 文件加载）
GPU 温度持续偏高（散热器满负荷运行）
功耗接近 TDP 上限（Power Limit 满载）

nvidia-smi --query-compute-apps=pid,process_name,used_memory --format=csv,noheader

检查 GPU 计算进程列表，识别可疑进程名称（如 nbminer, t-rex, lolminer, phoenixminer 等已知挖矿工具）。

3.2.2 基于 GPU 利用率的异常检测

#!/bin/bash
THRESHOLD_GPU_UTIL=80
THRESHOLD_MEM_UTIL=60
LOG_FILE="/var/log/gpu_miner_detect.log"

while true; do
    GPU_UTIL=$(nvidia-smi --query-gpu=utilization.gpu --format=csv,noheader,nounits | head -1 | tr -d ' ')
    MEM_UTIL=$(nvidia-smi --query-gpu=utilization.memory --format=csv,noheader,nounits | head -1 | tr -d ' ')
    TEMP=$(nvidia-smi --query-gpu=temperature.gpu --format=csv,noheader,nounits | head -1 | tr -d ' ')
    POWER=$(nvidia-smi --query-gpu=power.draw --format=csv,noheader,nounits | head -1 | tr -d ' ')
    
    if [ "$GPU_UTIL" -gt "$THRESHOLD_GPU_UTIL" ] 2>/dev/null; then
        PROCESSES=$(nvidia-smi --query-compute-apps=pid,process_name,used_memory --format=csv,noheader)
        TIMESTAMP=$(date '+%Y-%m-%d %H:%M:%S')
        echo "[ALERT] $TIMESTAMP GPU利用率异常: ${GPU_UTIL}%, 显存: ${MEM_UTIL}%, 温度: ${TEMP}°C, 功耗: ${POWER}W" >> "$LOG_FILE"
        echo "$PROCESSES" >> "$LOG_FILE"
        echo "---" >> "$LOG_FILE"
    fi
    sleep 10
done

3.3 挖矿软件的隐蔽技术

攻击者使用多种技术来隐藏 GPU 挖矿行为：

隐蔽技术	实现方式	取证检测方法
GPU 利用率限制	设置功耗限制（`nvidia-smi -pl 100`）降低功耗和温度	检查 Power Limit 配置是否被修改
共享 GPU 上下文	在合法 CUDA 应用的上下文中注入挖矿线程	分析 CUDA Context 的创建时间和线程行为
驱动级隐藏	修改 nvidia-smi 输出或 hook NVML 函数	检查 nvidia-smi 二进制完整性、NVML 调用链
低强度挖矿	降低哈希率使 GPU 利用率低于告警阈值	长时间统计 GPU 利用率基线并检测持续性低负载
异步挖矿	间歇性启动和停止挖矿以躲避检测	GPU 利用率时间序列分析，检测周期性模式
侧信道通信	利用 GPU 缓存或功率波动进行隐蔽通信	GPU 功耗和电磁辐射分析

3.4 CUDA 恶意内核分析

恶意 CUDA Kernel 的取证分析需要关注以下方面：

cuobjdump --dump-sass /path/to/suspicious_kernel.cubin
nvdisasm /path/to/suspicious_kernel.cubin

cuobjdump 和 nvdisasm 可以反汇编 CUDA 二进制文件（.cubin），提取 SASS（Shader Assembly）指令。挖矿算法的 SASS 通常包含大量的整数哈希运算、位操作和内存散列访问模式。

挖矿算法特征	SASS 指令模式	寄存器使用特征
Ethash DAG 查找	大量 LDG.E（全局内存读取）、LOP3（三操作数逻辑运算）	高寄存器压力，使用大量本地内存
SHA-256（Bitcoin）	INT（整数指令）、LOP3、IMAD（整数乘加）	中等寄存器使用，循环展开明显
RandomX	IMAD、ISCADD、SHF.L、LOP3 混合	极高寄存器压力，使用大量 Shared Memory
KawPoW	LDG.E + 快速哈希混合运算	中高寄存器使用，内存带宽受限

3.5 GPU 挖矿 IOC

IOC 类型	具体内容	检测方法
进程名称	`nbminer`, `t-rex`, `lolminer`, `phoenixminer`, `gminer`, `teamredminer`	进程列表检查、nvidia-smi compute apps
矿池连接	stratum+tcp://, stratum+ssl:// 端口 3333/4444/8888	网络流量分析、连接日志
显存特征	持续占用 >70% 显存，温度 >75°C	nvidia-smi 监控
文件特征	`/tmp/.x` 或隐藏目录中的 .so/.exe 文件	文件系统检查
命令行参数	`--algo`, `--server`, `--wallet`, `--_worker`	/proc/[pid]/cmdline 检查

0x04 AI模型窃取与对抗取证

4.1 模型提取攻击概述

随着 AI 模型商业价值的急剧增长，模型窃取（Model Extraction）已成为一种重要的知识产权威胁。攻击者通过查询目标模型的推理 API，利用返回的预测结果逆向重构模型参数或功能等价的替代模型。

模型窃取技术	攻击前提	所需查询次数	GPU 取证指标
基于梯度的提取	白盒访问或梯度泄露	10³-10⁵ 次查询	GPU 上的梯度计算痕迹
基于决策的提取	仅需黑盒 API 访问	10⁴-10⁶ 次查询	API 调用频率异常、GPU 推理负载
基于侧信道的提取	物理访问或共享 GPU	不适用（非 API）	GPU 功耗/电磁辐射分析
基于对抗样本的提取	黑盒 API + 对抗框架	10³-10⁴ 次查询	GPU 上的对抗样本生成痕迹

4.2 GPU 推理 API 的取证分析

在 GPU 加速的推理服务中，模型窃取攻击会在 GPU 上留下可追踪的痕迹：

nvidia-smi --query-compute-apps=pid,process_name,used_memory --format=csv

模型窃取攻击的 GPU 指标：

推理进程显存使用量持续稳定（模型参数常驻显存）
GPU 计算利用率呈现周期性高-低交替（批量查询模式）
推理请求的 batch size 异常（单样本逐条查询以获取细粒度梯度信息）

4.3 模型水印与指纹检测

为保护 AI 模型的知识产权，研究者提出了多种水印和指纹技术。在取证分析中，检测这些标记可以确认模型是否被未授权复制：

技术类型	实现方法	取证可检测性
参数空间水印	在模型权重中嵌入特定模式	需要原始模型对比，显存转储后分析
输出空间水印	模型对特定输入产生可验证的输出	黑盒测试即可验证
模型指纹	提取模型对特定对抗样本集的响应特征	需要推理时捕获 GPU 输出
后门水印	植入特定触发器产生预期行为	后门分析框架（如 Neural Cleanse）

4.4 训练数据提取的 GPU 痕迹

大型语言模型（LLM）的训练数据提取是近年来备受关注的安全问题。攻击者可通过精心设计的提示词诱导模型输出训练数据中的敏感信息。当使用 GPU 进行此类攻击时，以下 GPU 痕迹可作为取证证据：

nvidia-smi --query-gpu=utilization.gpu,memory.used --format=csv -l 1

训练数据提取攻击的 GPU 特征：

大模型推理需要大量 VRAM（如 LLaMA-70B 需要约 140 GB 显存用于 FP16 推理）
高频短时 GPU 计算请求（大量 prompts 逐条查询）
显存分配模式与正常推理服务不同（频繁分配/释放 KV Cache）

4.5 对抗性攻击的 GPU 分析

对抗性样本生成通常需要大量 GPU 计算资源：

攻击方法	GPU 计算需求	检测特征
FGSM	低（单次前向+反向传播）	短时 GPU 利用率峰值
PGD	中（多次迭代）	持续数秒的 GPU 计算
C&W	高（大量优化迭代）	长时间 GPU 占用
DeepFool	中	反复 GPU 推理调用
对抗补丁	高（需要大量训练）	持续 GPU 训练负载

0x05 GPU侧信道攻击取证

5.1 GPU 缓存侧信道攻击

随着 GPU 在多租户环境（云 GPU、共享 GPU 工作站）中的广泛使用，GPU 缓存侧信道攻击已成为严重的安全威胁。攻击者可以利用 GPU 共享的 L2 缓存或 DRAM 总线，在不同 GPU 进程或 VM 之间窃取敏感信息。

攻击类型	攻击目标缓存/资源	攻击原理	历史研究
GPU Prime+Probe	GPU L2 Cache	驱逐-探测共享缓存行的访问模式	Zhang et al. (2020)
GPU Flush+Reload	GPU L2 Cache	刷新共享缓存行，检测目标访问	Liu et al. (2021)
GPU Rowhammer	GPU DRAM	利用 DRAM 行锤击翻转位	Razavi et al. (2016) GPU 变种
GPU Timing Attack	GPU 共享内存/寄存器	利用访问时间差异推断数据	基于已知 CPU 攻击的 GPU 移植
NVLink 侧信道	NVLink 互连	跨 GPU 通信通道泄露信息	多 GPU 系统新攻击面

5.2 GPU Rowhammer 攻击

GPU DRAM 的 Rowhammer 攻击是一种物理层面的攻击方式，通过高频访问特定 DRAM 行导致相邻行的位翻转。在 GPU 环境中，由于 HBM 内存的高速访问特性，Rowhammer 攻击可能比 CPU DRAM 更容易实施。

GPU Rowhammer 的取证检测方法：

监控 GPU ECC（Error Correcting Code）错误计数
检查 GPU 驱动日志中的内存错误报告
分析 GPU 计算结果的比特翻转模式

nvidia-smi --query-gpu=ecc.errors.corrected.aggregate.volatile.ce,uncorrected.aggregate.volatile.uncorrected --format=csv

5.3 电磁辐射与功耗分析

GPU 在执行计算任务时产生的电磁辐射和功耗波动可以泄露正在处理的数据信息：

信号类型	泄露信息	采集设备	分析复杂度
功耗波动	执行的操作类型、数据模式	智能 PDU、功耗分析仪	🟡 中等
电磁辐射	寄存器操作、内存访问模式	近场电磁探针、频谱分析仪	🔴 较高
热辐射	计算负载分布、活跃 SM 位置	红外热成像仪	🟢 较低
声学信号	GPU 风扇转速变化、电感线圈噪声	高灵敏度麦克风	🟢 较低

5.4 多租户 GPU 环境的信息泄露

在云环境中，多个租户共享同一物理 GPU 时，以下信息泄露风险需要关注：

泄露路径	攻击条件	影响范围	检测难度
共享 L2 缓存	同一 GPU 上的多个上下文	缓存时序信息	🔴 高
共享 DRAM 总线	MIG 实例间或 vGPU 间	内存访问模式	🔴 高
NVLink/PCIe 共享带宽	多 GPU 通信通道	通信内容推断	🟡 中
GPU 温度/功耗侧信道	同一物理 GPU	计算负载推断	🟢 低

5.5 GPU 侧信道攻击检测策略

#!/bin/bash
LOG_FILE="/var/log/gpu_sidechannel_detect.log"
TIMESTAMP=$(date '+%Y-%m-%d %H:%M:%S')

ECC_ERRORS=$(nvidia-smi --query-gpu=ecc.errors.corrected.aggregate.volatile.ce --format=csv,noheader,nounits | head -1 | tr -d ' ')
GPU_UTIL=$(nvidia-smi --query-gpu=utilization.gpu --format=csv,noheader,nounits | head -1 | tr -d ' ')
MEM_UTIL=$(nvidia-smi --query-gpu=utilization.memory --format=csv,noheader,nounits | head -1 | tr -d ' ')

if [ "${ECC_ERRORS:-0}" -gt 0 ] 2>/dev/null; then
    echo "[ALERT] $TIMESTAMP 检测到 GPU ECC 错误: $ECC_ERRORS (可能存在 Rowhammer 攻击)" >> "$LOG_FILE"
    nvidia-smi -q > "$LOG_FILE.$(date +%s)"
fi

GPU_PROCS=$(nvidia-smi --query-compute-apps=pid,process_name --format=csv,noheader | wc -l)
if [ "$GPU_PROCS" -gt 5 ] 2>/dev/null; then
    echo "[WARN] $TIMESTAMP GPU 计算进程数异常: $GPU_PROCS 个进程 (可能存在侧信道攻击)" >> "$LOG_FILE"
    nvidia-smi --query-compute-apps=pid,process_name,used_memory --format=csv >> "$LOG_FILE"
fi

0x06 NPU/TPU等AI加速器安全取证

6.1 AI 加速器架构对比

随着 AI 推理从云端扩展到边缘设备，各类专用 AI 加速器（NPU、TPU 等）的安全取证变得日益重要。

加速器类型	厂商	架构特点	典型产品	调试接口	取证难度
NVIDIA GPU	NVIDIA	SIMT + Tensor Core	A100, H100, RTX 4090	CUDA/GDB, NVML	🟡 中等
AMD GPU	AMD	RDNA/CDNA + Matrix Core	MI300X, RX 7900 XTX	ROCm, rocm-smi	🟡 中等
Google TPU	Google	Systolic Array	TPU v4, TPU v5e	JAX/XLA 调试	🔴 高（专有）
Intel Gaudi	Intel (Habana)	MME + TPC	Gaudi 2, Gaudi 3	SynapseAI	🔴 高
Apple Neural Engine	Apple	脉动阵列	M3/M4 NPU	CoreML Tools	🔴 高（封闭）
Qualcomm Hexagon	Qualcomm	向量 + 张量扩展	Snapdragon 8 Gen 3	QNN SDK	🟡 中等
Intel NPU	Intel	专用推理引擎	Meteor Lake NPU	OpenVINO	🟡 中等
AMD XDNA	AMD (Xilinx)	AI Engine Tile Array	Ryzen 7040 NPU	Vitis AI	🔴 高
Cambricon MLU	寒武纪	专用向量处理器	MLU370	Bang C/C++ SDK	🔴 高
Huawei Ascend	华为	达芬奇架构	Ascend 910B	CANN	🔴 高（专有）

6.2 TPU 安全取证

Google TPU 使用独特的 Systolic Array 架构，数据在计算阵列中像脉搏一样规律流动。TPU 的安全取证面临特殊挑战：

专有硬件：TPU 仅在 Google Cloud 上可用，没有本地硬件可供取证分析
有限的调试接口：Google 仅通过 XLA 编译器和 JAX/TensorFlow 框架暴露有限的调试能力
无标准内存转储：TPU 的 HBM 内存无法像 GPU 那样通过 PCIe 直接访问

TPU 取证的可行方法包括：

分析 TPU 上的模型文件格式（HLO Module、SavedModel）
审查 XLA 编译器的优化日志
检查 Cloud TPU 的 API 调用日志

6.3 NPU 固件安全分析

NPU 通常运行在 SoC 内部，其固件安全性直接影响推理结果的完整性：

安全风险	影响	检测方法
模型文件篡改	推理结果被操纵	模型文件哈希验证
固件后门	推理过程中泄露数据或产生错误结果	固件二进制分析
推理结果注入	在模型推理链中插入恶意操作	端到端推理验证
量化后门	模型量化过程中植入后门	量化前后模型精度对比
固件降级攻击	回退到已知漏洞的固件版本	固件版本校验

6.4 AI 加速器的统一取证框架

由于不同 AI 加速器的硬件接口和调试工具差异巨大，建立统一的取证分析框架至关重要：

#!/bin/bash
echo "=== AI 加速器环境取证采集 ==="
TIMESTAMP=$(date +%Y%m%d_%H%M%S)
OUTPUT_DIR="/forensics/ai_accel_${TIMESTAMP}"
mkdir -p "$OUTPUT_DIR"

if command -v nvidia-smi &> /dev/null; then
    echo "[+] 检测到 NVIDIA GPU"
    mkdir -p "$OUTPUT_DIR/nvidia"
    nvidia-smi -q > "$OUTPUT_DIR/nvidia/full_state.txt"
    nvidia-smi --query-gpu=timestamp,name,driver_version,pci.bus_id,memory.total,memory.used,memory.free,utilization.gpu,utilization.memory,temperature.gpu,power.draw --format=csv > "$OUTPUT_DIR/nvidia/gpu_info.csv"
    nvidia-smi --query-compute-apps=pid,process_name,used_memory,command_line --format=csv > "$OUTPUT_DIR/nvidia/compute_apps.csv"
    cat /proc/driver/nvidia/gpus/*/information > "$OUTPUT_DIR/nvidia/proc_driver_info.txt" 2>/dev/null
    lsmod | grep nvidia > "$OUTPUT_DIR/nvidia/loaded_modules.txt" 2>/dev/null
fi

if command -v rocm-smi &> /dev/null; then
    echo "[+] 检测到 AMD ROCm GPU"
    mkdir -p "$OUTPUT_DIR/amd"
    rocm-smi --showallinfo > "$OUTPUT_DIR/amd/full_state.txt"
    rocm-smi --showmeminfo vram > "$OUTPUT_DIR/amd/vram_info.txt"
    rocm-smi --showuse > "$OUTPUT_DIR/amd/utilization.txt"
fi

if ls /dev/apex_* &> /dev/null 2>/dev/null; then
    echo "[+] 检测到 Google TPU"
    mkdir -p "$OUTPUT_DIR/tpu"
    echo "TPU 设备已检测到，需通过 Cloud TPU API 获取详细信息" > "$OUTPUT_DIR/tpu/tpu_note.txt"
fi

if ls /dev/ionpu* 2>/dev/null || ls /dev/dri/renderD* 2>/dev/null; then
    echo "[+] 检测到可能的 NPU 设备"
    mkdir -p "$OUTPUT_DIR/npu"
    ls -la /dev/dri/ > "$OUTPUT_DIR/npu/dri_devices.txt" 2>/dev/null
    cat /sys/class/accel/accel*/device/vendor > "$OUTPUT_DIR/npu/vendor_info.txt" 2>/dev/null
    cat /sys/class/accel/accel*/device/device > "$OUTPUT_DIR/npu/device_info.txt" 2>/dev/null
fi

echo "[+] AI 加速器取证采集完成: $OUTPUT_DIR"

0x07 GPU驱动与固件安全取证

7.1 NVIDIA 驱动架构分层

NVIDIA GPU 驱动采用分层架构，每一层都具有不同的安全含义和取证价值：

驱动层级	组件名称	运行位置	安全影响	取证方法
内核模式驱动	nvidia.ko	Ring 0	特权提升、内核持久化	内核模块分析、/proc/driver/nvidia
用户模式驱动	libnvidia-ml.so, libcuda.so	Ring 3	用户态攻击、hook 注入	共享库审计、LD_PRELOAD 检测
CUDA 运行时	libcudart.so	用户态	CUDA 应用持久化	CUDA 初始化日志分析
CUDA 驱动 API	libcuda.so	用户态	底层 GPU 操作控制	API 调用追踪
GPU 固件	VBIOS / GSP-FW	GPU 硬件	固件级后门、签名绕过	VBIOS 提取与分析
GPU Microcontroller	GSP-RTOS	GPU 内部 MCU	硬件级持久化	固件逆向（极难）

7.2 GPU VBIOS 取证

VBIOS（Video BIOS）是 GPU 的固件，包含 GPU 初始化代码、时钟配置、功率限制等关键信息：

nvidia-smi -q | grep -A 5 "VBIOS Version"

cat /sys/bus/pci/devices/*/rom > gpu_vbios_backup.bin 2>/dev/null

echo 1 > /sys/bus/pci/devices/*/rom
cat /sys/bus/pci/devices/*/rom > gpu_vbios_dump.bin 2>/dev/null
echo 0 > /sys/bus/pci/devices/*/rom

VBIOS 分析工具：

NVIDIA BIOS Editor (NiBiTor)：Windows 环境下的 VBIOS 编辑和分析工具
GPU-Z：提取和显示 VBIOS 详细信息
AMIBCP：分析 AMI BIOS 结构的 VBIOS

7.3 GPU 驱动漏洞与利用

GPU 驱动是攻击面中的重要组成部分。以下是近年来影响较大的 GPU 驱动漏洞：

CVE 编号	漏洞类型	影响版本	攻击向量	ATT&CK 映射
CVE-2024-0126	越界写入	NVIDIA GPU Driver < 535.183.01	本地提权	T1068
CVE-2023-3102	信息泄露	NVIDIA GPU Driver < 535.104.05	本地特权提升	T1005
CVE-2022-42258	未授权访问	NVIDIA GPU Driver < 520.61.05	远程代码执行	T1203
CVE-2023-0196	越界访问	NVIDIA GeForce Driver < 531.18	本地提权	T1068
CVE-2024-0133	权限提升	NVIDIA GPU Cloud Driver	容器逃逸	T1611

7.4 驱动级持久化机制

攻击者可能利用 GPU 驱动组件实现持久化：

lsmod | grep nvidia
cat /etc/modules-load.d/*.conf | grep nvidia
cat /etc/modprobe.d/*.conf | grep nvidia
find / -name "nvidia*.ko" -o -name "nvidia*.so" 2>/dev/null

持久化检测要点：

检查 /etc/modules-load.d/ 中是否有异常的 NVIDIA 模块加载配置
审查 /etc/ld.so.preload 是否注入了 NVIDIA 相关的共享库
检查 LD_LIBRARY_PATH 环境变量是否被篡改以劫持 NVIDIA 库
验证 /usr/lib/x86_64-linux-gnu/libnvidia* 系列文件的完整性

7.5 GPU Secure Boot 与固件验证

现代 NVIDIA GPU（如 A100、H100）支持 Secure Boot 机制，确保 GPU 固件和驱动的完整性：

nvidia-smi -q | grep -A 3 "GPU Security"
nvidia-smi -q | grep -A 3 "GSP Firmware"

安全特性	功能	取证检查
GPU Secure Boot	验证 VBIOS 和 GSP 固件签名	检查 Security Level 状态
Signed Drivers	验证内核驱动签名	检查驱动数字签名
GPU CC Mode	Confidential Computing 模式	检查 TEE 状态
GSP 固件版本	GPU System Processor 固件	对比已知安全版本

0x08 异构计算容器与云环境取证

8.1 GPU 容器化部署模式

现代 GPU 计算大量运行在容器环境中，容器化的 GPU 应用带来特殊的取证挑战：

部署模式	实现技术	隔离级别	取证难度	典型场景
GPU Passthrough	VFIO / PCI 直通	硬件级	🟢 较低	单租户高性能计算
MIG（Multi-Instance GPU）	NVIDIA MIG	硬件分区	🟡 中等	多租户推理服务
vGPU	NVIDIA vGPU / GRID	虚拟化	🟡 中等	VDI、云游戏
Time-slicing	NVIDIA Device Plugin	软件共享	🔴 高	K8s GPU 共享
SR-IOV（Intel GPU）	SR-IOV	硬件分区	🟡 中等	Intel GPU 多租户
云原生 GPU	云厂商专有 API	云级别	🔴 高	Cloud TPU、Trainium

8.2 NVIDIA Container Toolkit 取证

NVIDIA Container Toolkit（原 nvidia-docker2）是容器环境中使用 GPU 的标准方式：

docker inspect $(docker ps -q --filter "label=com.nvidia.gpus") --format '{{.Name}} {{.Config.Env}}'
nvidia-docker ps
cat /etc/nvidia-container-runtime/config.toml

容器 GPU 逃逸的取证检查：

docker inspect $CONTAINER_ID --format '{{json .HostConfig.DeviceRequests}}'
docker inspect $CONTAINER_ID --format '{{json .HostConfig.Binds}}'
docker exec $CONTAINER_ID ls -la /dev/nvidia*

8.3 云 GPU 实例取证

主要云服务商的 GPU 实例及其取证特点：

云平台	GPU 实例系列	GPU 型号	虚拟化方式	取证 API
AWS	p4d.24xlarge	NVIDIA A100	Nitro + GPU Passthrough	CloudTrail, EC2 Metadata
AWS	g5.xlarge	NVIDIA A10G	Nitro + GPU Passthrough	CloudTrail
Azure	NC v4	NVIDIA A100	SR-IOV	Azure Activity Log
Azure	ND v4	NVIDIA H100	MIG	Azure Activity Log
GCP	a2-highgpu	NVIDIA A100	MIG	Cloud Audit Logs
GCP	g2-standard	NVIDIA L4	Time-slicing	Cloud Audit Logs
GCP	ct5lp	Google TPU v5e	专有	Cloud Logging

8.4 GPU 容器逃逸检测

GPU 容器逃逸是一种严重的安全事件，攻击者可能利用 GPU 驱动或容器运行时的漏洞从容器内获取宿主机权限：

docker exec $CONTAINER_ID cat /proc/1/cgroup | grep -v nvidia
docker exec $CONTAINER_ID ls -la /dev/nvidia-uvm
docker exec $CONTAINER_ID nvidia-smi
docker exec $CONTAINER_ID cat /proc/driver/nvidia/version

逃逸向量	攻击原理	检测方法	风险等级
/dev/nvidia-uvm 挂载	通过 Unified Virtual Memory 设备获取宿主机内存访问	检查容器内 nvidia-uvm 设备权限	🔴 严重
NVIDIA 驱动漏洞	利用内核态驱动漏洞提权	驱动版本检查、CVE 对照	🔴 严重
GPU 共享内存泄露	通过 GPU 共享内存读取其他容器数据	GPU 显存隔离验证	🟡 高危
容器内加载内核模块	通过 GPU 模块加载机制注入内核模块	CAP_SYS_MODULE 检查	🔴 严重
CUDA IPC 滥用	利用 CUDA 进程间通信跨容器泄露数据	CUDA IPC 句柄审计	🟡 高危

8.5 vGPU 与 SR-IOV 取证

虚拟 GPU 环境的取证需要关注虚拟化层的特殊痕迹：

nvidia-smi vgpu -s
nvidia-smi vgpu -q
lspci -v | grep -A 5 "Virtual Function"

虚拟化技术	取证关注点	典型证据来源
NVIDIA vGPU	vGPU License 服务器通信、vGPU Profile 配置	nvidia-smi vgpu、GRID 日志
MIG	实例划分配置、跨实例隔离违规	nvidia-smi mig、GPU 配置日志
SR-IOV (Intel)	VF（Virtual Function）分配、VF 间通信	lspci、sysfs
Time-slicing	GPU 上下文切换频率、调度策略	NVIDIA Device Plugin 日志

0x09 证据强度分层与案例关联

9.1 GPU 取证证据三级分类框架

在 GPU 安全事件调查中，正确评估证据的强度对于确定事件的严重性和后续响应措施至关重要：

证据等级	分类	典型场景	代表性证据	响应优先级
🔴 CONFIRMED MALICIOUS	确认恶意	未经授权的 GPU 挖矿、模型窃取、显存数据提取	挖矿进程命令行、矿池连接记录、GPU 二进制中的挖矿算法特征	P0 立即响应
🟡 HIGHLY SUSPICIOUS	高度可疑	异常 GPU 利用率、未授权 CUDA 进程、可疑显存分配模式	持续高 GPU 利用率、非预期的 CUDA 应用、显存使用量异常	P1 优先调查
🟢 NEEDS ATTENTION	需要关注	合法 GPU 使用但需上下文验证、配置偏差	驱动版本过旧、GPU 配置偏离基线、新安装的 CUDA 工具包	P2 常规审查

9.2 证据关联分析方法

GPU 取证证据需要与 CPU 侧的证据进行交叉关联，构建完整的攻击时间线：

证据域	GPU 侧证据	CPU 侧证据	关联方法
挖矿事件	nvidia-smi 进程列表、显存使用量	网络连接（矿池端口）、进程创建日志	时间戳关联 + 进程 PID 映射
模型窃取	GPU 推理负载异常、显存分配模式	API 调用日志、HTTP 请求频率	请求-响应时序匹配
驱动漏洞利用	GPU 驱动异常崩溃、VBIOS 篡改	内核崩溃日志、CVE 匹配	驱动版本 + 崩溃栈关联
容器逃逸	GPU 设备节点异常访问	容器逃逸日志、capability 检查	设备文件访问记录 + namespace 检查
侧信道攻击	GPU ECC 错误、异常功耗模式	系统日志、进程间通信记录	功耗-计算负载-进程三元组关联

9.3 证据可信度评估

评估维度	评估标准	加权因子
时间精度	证据时间戳的精度（ms vs s vs min）	0.2
来源可靠性	证据来源是否可被攻击者篡改	0.3
独立验证	是否存在多条独立证据链相互印证	0.25
上下文完整性	证据是否具有完整的上下文信息	0.15
采集规范性	证据采集过程是否遵循取证规范	0.1

0x10 自动化检测与狩猎

10.1 Sigma 检测规则

GPU 挖矿行为检测规则

title: Suspicious GPU Mining Activity Detection
id: a3f2e8c1-7b4d-4e5a-9c6f-1d2e3f4a5b6c
status: experimental
description: 检测GPU上可能的加密货币挖矿活动，包括异常的GPU利用率和已知挖矿进程名称
references:
  - https://attack.mitre.org/techniques/T1496/
author: x7peeps-blue-team
date: 2026-07-21
modified: 2026-07-21
tags:
  - attack.impact
  - attack.t1496
  - gpu-security
  - crypto-mining
logsource:
  category: process_creation
  product: linux
detection:
  selection_mining_process_name:
    Image|endswith:
      - '/nbminer'
      - '/t-rex'
      - '/lolminer'
      - '/phoenixminer'
      - '/gminer'
      - '/teamredminer'
      - '/xmr-stak'
      - '/xmrig'
      - '/ethminer'
      - '/lolMiner'
      - '/BMiner'
      - '/MiniZ'
  selection_mining_cmdline_keywords:
    CommandLine|contains:
      - '--algo'
      - '--server'
      - '--pool'
      - '--wallet'
      - '--worker'
      - '--coin'
      - 'stratum+tcp://'
      - 'stratum+ssl://'
      - 'stratum2+tcp://'
  selection_nvidia_smi_unauthorized:
    Image|endswith:
      - '/nvidia-smi'
    CommandLine|contains:
      - '-pl'
      - '--power-limit'
      - 'gpu clocks'
      - 'mem clocks'
  condition: selection_mining_process_name or (selection_mining_cmdline_keywords and selection_nvidia_smi_unauthorized)
level: high
falsepositives:
  - Legitimate cryptocurrency mining operations
  - GPU benchmarking software
  - GPU stress testing tools

GPU 驱动异常检测规则

title: NVIDIA GPU Driver Anomaly Detection
id: b4e3d2a1-8c5e-4f6b-ad7e-2f3a4b5c6d7e
status: experimental
description: 检测NVIDIA GPU驱动相关的异常活动，包括驱动版本不匹配、异常模块加载和设备节点权限变更
references:
  - https://attack.mitre.org/techniques/T1068/
author: x7peeps-blue-team
date: 2026-07-21
modified: 2026-07-21
tags:
  - attack.privilege_escalation
  - attack.t1068
  - gpu-security
  - driver-security
logsource:
  category: process_creation
  product: linux
detection:
  selection_ld_preload_nvidia:
    Environment|contains:
      - 'LD_PRELOAD'
    Environment|contains:
      - 'nvidia'
  selection_nvidia_modprobe:
    Image|endswith:
      - '/modprobe'
    CommandLine|contains:
      - 'nvidia'
      - 'nouveau'
  selection_nvidia_settings_dump:
    Image|endswith:
      - '/nvidia-smi'
    CommandLine|contains:
      - '-x'
      - '--xml-format'
      - '-f'
  selection_cuda_process_anomaly:
    Image|contains:
      - 'cuda'
    CommandLine|contains:
      - 'cuda-gdb'
      - 'cuda-memcheck'
      - 'compute-sanitizer'
  condition: selection_ld_preload_nvidia or selection_nvidia_modprobe or (selection_nvidia_settings_dump and not selection_cuda_process_anomaly)
level: medium
falsepositives:
  - Legitimate NVIDIA driver updates
  - CUDA development and debugging
  - GPU performance tuning

10.2 GPU 状态监控与异常检测 Bash 脚本

#!/bin/bash
set -euo pipefail

MONITOR_INTERVAL=5
ALERT_THRESHOLD_GPU_UTIL=85
ALERT_THRESHOLD_MEM_PERCENT=75
ALERT_THRESHOLD_TEMP=80
LOG_DIR="/var/log/gpu_hunt/$(date +%Y%m%d_%H%M%S)"
KNOWN_MINERS="nbminer|t-rex|lolminer|phoenixminer|gminer|teamredminer|xmr-stak|xmrig|ethminer|BMiner|MiniZ|guldenminer|kawpowminer"
KNOWN_GPU_TOOLS="cuda-gdb|cuda-memcheck|compute-sanitizer|nsight|cufft|cusparse"
SUSPICIOUS_PORTS="3333|4444|5555|7777|8888|9999|14444|45560|45700"

mkdir -p "$LOG_DIR"

echo "[*] GPU 安全狩猎监控启动 - 日志目录: $LOG_DIR"
echo "[*] 监控间隔: ${MONITOR_INTERVAL}s | GPU利用率阈值: ${ALERT_THRESHOLD_GPU_UTIL}% | 温度阈值: ${ALERT_THRESHOLD_TEMP}°C"

echo "timestamp,gpu_util,mem_util,mem_used_mb,mem_total_mb,temp_c,power_w,proc_count" > "$LOG_DIR/gpu_timeseries.csv"

detect_gpu_processes() {
    local procs
    procs=$(nvidia-smi --query-compute-apps=pid,process_name,used_memory --format=csv,noheader 2>/dev/null || true)
    if [ -z "$procs" ]; then
        echo "  无 GPU 计算进程"
        return
    fi
    echo "$procs" | while IFS=',' read -r pid pname mem; do
        pname_trimmed=$(echo "$pname" | xargs)
        echo "$pname_trimmed" | grep -qiE "$KNOWN_MINERS" && echo "  [CRITICAL] 疑似挖矿进程: PID=$pid 名称=$pname_trimmed 显存=${mem}MB"
        echo "$pname_trimmed" | grep -qiE "$KNOWN_GPU_TOOLS" && echo "  [INFO] GPU调试/分析工具: PID=$pid 名称=$pname_trimmed"
    done
}

detect_suspicious_connections() {
    local miner_pids
    miner_pids=$(nvidia-smi --query-compute-apps=pid --format=csv,noheader 2>/dev/null | tr -d ' ' | tr '\n' '|' | sed 's/|$//')
    if [ -n "$miner_pids" ]; then
        ss -tnp 2>/dev/null | grep -E "($miner_pids)" | grep -E ":($SUSPICIOUS_PORTS)" && echo "  [CRITICAL] 检测到GPU进程的可疑网络连接" || true
    fi
}

check_ecc_errors() {
    local ecc_corrected ecc_uncorrected
    ecc_corrected=$(nvidia-smi --query-gpu=ecc.errors.corrected.aggregate.volatile.ce --format=csv,noheader,nounits 2>/dev/null | head -1 | tr -d ' ' || echo "0")
    ecc_uncorrected=$(nvidia-smi --query-gpu=ecc.errors.uncorrected.aggregate.volatile.ce --format=csv,noheader,nounits 2>/dev/null | head -1 | tr -d ' ' || echo "0")
    if [ "${ecc_corrected:-0}" -gt 10 ] 2>/dev/null; then
        echo "  [WARN] GPU ECC校正错误数偏高: $ecc_corrected (可能存在Rowhammer攻击)"
    fi
    if [ "${ecc_uncorrected:-0}" -gt 0 ] 2>/dev/null; then
        echo "  [CRITICAL] 检测到GPU ECC不可校正错误: $ecc_uncorrected"
    fi
}

cycle=0
while true; do
    cycle=$((cycle + 1))
    ts=$(date '+%Y-%m-%d %H:%M:%S')
    gpu_util=$(nvidia-smi --query-gpu=utilization.gpu --format=csv,noheader,nounits 2>/dev/null | head -1 | tr -d ' ' || echo "0")
    mem_util=$(nvidia-smi --query-gpu=utilization.memory --format=csv,noheader,nounits 2>/dev/null | head -1 | tr -d ' ' || echo "0")
    mem_used=$(nvidia-smi --query-gpu=memory.used --format=csv,noheader,nounits 2>/dev/null | head -1 | tr -d ' ' || echo "0")
    mem_total=$(nvidia-smi --query-gpu=memory.total --format=csv,noheader,nounits 2>/dev/null | head -1 | tr -d ' ' || echo "1")
    temp=$(nvidia-smi --query-gpu=temperature.gpu --format=csv,noheader,nounits 2>/dev/null | head -1 | tr -d ' ' || echo "0")
    power=$(nvidia-smi --query-gpu=power.draw --format=csv,noheader,nounits 2>/dev/null | head -1 | tr -d ' ' || echo "0")
    proc_count=$(nvidia-smi --query-compute-apps=pid --format=csv,noheader 2>/dev/null | wc -l | tr -d ' ')

    echo "$ts,$gpu_util,$mem_util,$mem_used,$mem_total,$temp,$power,$proc_count" >> "$LOG_DIR/gpu_timeseries.csv"

    echo "=== [$ts] GPU 安全扫描 #${cycle} ==="
    echo "  GPU利用率: ${gpu_util}% | 显存: ${mem_used}/${mem_total}MB (${mem_util}%) | 温度: ${temp}°C | 功耗: ${power}W | 进程数: ${proc_count}"

    if [ "${gpu_util:-0}" -gt "$ALERT_THRESHOLD_GPU_UTIL" ] 2>/dev/null; then
        echo "  [ALERT] GPU 利用率超过阈值: ${gpu_util}% > ${ALERT_THRESHOLD_GPU_UTIL}%"
        detect_gpu_processes
        detect_suspicious_connections
    fi

    if [ "${temp:-0}" -gt "$ALERT_THRESHOLD_TEMP" ] 2>/dev/null; then
        echo "  [ALERT] GPU 温度超过阈值: ${temp}°C > ${ALERT_THRESHOLD_TEMP}°C"
    fi

    if [ "$((cycle % 12))" -eq 0 ]; then
        check_ecc_errors
    fi

    sleep "$MONITOR_INTERVAL"
done

10.3 GPU 显存分析与挖矿检测 Python 工具

import subprocess
import json
import time
import os
import sys
from datetime import datetime
from collections import defaultdict

class GPUForensicsAnalyzer:
    def __init__(self, output_dir="/forensics/gpu_analysis"):
        self.output_dir = output_dir
        os.makedirs(output_dir, exist_ok=True)
        self.baseline = {"gpu_util": [], "mem_used": [], "temp": [], "power": []}
        self.alerts = []

    def run_nvidia_smi_query(self, query_args):
        try:
            result = subprocess.run(
                ["nvidia-smi"] + query_args,
                capture_output=True, text=True, timeout=10
            )
            return result.stdout.strip()
        except (subprocess.TimeoutExpired, FileNotFoundError):
            return ""

    def get_gpu_state(self):
        output = self.run_nvidia_smi_query([
            "--query-gpu=timestamp,name,driver_version,utilization.gpu,"
            "utilization.memory,memory.used,memory.total,memory.free,"
            "temperature.gpu,power.draw,power.limit,pstate,"
            "clocks.current.graphics,clocks.current.memory,"
            "ecc.errors.corrected.aggregate.volatile.ce",
            "--format=csv,noheader,nounits"
        ])
        if not output:
            return None
        parts = [p.strip() for p in output.split(",")]
        keys = ["timestamp", "name", "driver_version", "gpu_util", "mem_util",
                "mem_used", "mem_total", "mem_free", "temp", "power",
                "power_limit", "pstate", "clock_gpu", "clock_mem", "ecc_errors"]
        state = {}
        for i, key in enumerate(keys):
            if i < len(parts):
                try:
                    state[key] = float(parts[i]) if key not in ("timestamp", "name", "driver_version", "pstate") else parts[i]
                except ValueError:
                    state[key] = parts[i]
        return state

    def get_gpu_processes(self):
        output = self.run_nvidia_smi_query([
            "--query-compute-apps=pid,process_name,used_memory,"
            "gpu_instance_id,compute_instance_id",
            "--format=csv,noheader,nounits"
        ])
        processes = []
        if output:
            for line in output.strip().split("\n"):
                parts = [p.strip() for p in line.split(",")]
                if len(parts) >= 3:
                    processes.append({
                        "pid": int(parts[0]),
                        "name": parts[1],
                        "memory_mb": float(parts[2]),
                        "gpu_instance": parts[3] if len(parts) > 3 else "N/A",
                        "compute_instance": parts[4] if len(parts) > 4 else "N/A"
                    })
        return processes

    def detect_miner_processes(self, processes):
        known_miners = [
            "nbminer", "t-rex", "lolminer", "phoenixminer", "gminer",
            "teamredminer", "xmr-stak", "xmrig", "ethminer", "BMiner",
            "MiniZ", "guldenminer", "kawpowminer", "nanominer",
            "TRex", "SRBMiner", "⛏", "cgminer", "bfgminer"
        ]
        miner_cmds = [
            "--algo", "--server", "--pool", "--wallet", "--worker",
            "--coin", "stratum+tcp://", "stratum+ssl://", "--donate-level"
        ]
        detections = []
        for proc in processes:
            pname = proc["name"].lower()
            for miner in known_miners:
                if miner.lower() in pname:
                    detections.append({
                        "type": "KNOWN_MINER",
                        "severity": "CRITICAL",
                        "process": proc,
                        "matched_pattern": miner
                    })
                    break
        cmdline_suspects = []
        for proc in processes:
            try:
                cmdline_path = f"/proc/{proc['pid']}/cmdline"
                with open(cmdline_path, "rb") as f:
                    cmdline = f.read().decode("utf-8", errors="replace").replace("\x00", " ")
                for keyword in miner_cmds:
                    if keyword in cmdline:
                        detections.append({
                            "type": "CMDLINE_SUSPECT",
                            "severity": "HIGH",
                            "process": proc,
                            "matched_keyword": keyword,
                            "cmdline": cmdline
                        })
                        break
            except (FileNotFoundError, PermissionError):
                pass
        return detections

    def detect_anomalous_gpu_usage(self, state, processes):
        anomalies = []
        if state and state.get("gpu_util", 0) > 85 and len(processes) > 0:
            high_util_procs = [p for p in processes if p["memory_mb"] > 1000]
            if high_util_procs:
                anomalies.append({
                    "type": "HIGH_UTILIZATION",
                    "severity": "WARNING",
                    "gpu_util": state["gpu_util"],
                    "processes": high_util_procs
                })
        if state and state.get("temp", 0) > 80:
            anomalies.append({
                "type": "HIGH_TEMPERATURE",
                "severity": "WARNING",
                "temperature": state["temp"]
            })
        if state and state.get("ecc_errors", 0) > 5:
            anomalies.append({
                "type": "ECC_ERRORS",
                "severity": "CRITICAL",
                "ecc_errors": state["ecc_errors"]
            })
        return anomalies

    def analyze_driver_integrity(self):
        findings = []
        result = self.run_nvidia_smi_query(["-q"])
        if "Driver Version" in result:
            for line in result.split("\n"):
                if "Driver Version" in line:
                    findings.append({"check": "driver_version", "value": line.strip()})
                if "VBIOS Version" in line:
                    findings.append({"check": "vbios_version", "value": line.strip()})
        preload_result = subprocess.run(
            ["cat", "/etc/ld.so.preload"],
            capture_output=True, text=True, timeout=5
        )
        if preload_result.returncode == 0 and "nvidia" in preload_result.stdout.lower():
            findings.append({
                "check": "LD_PRELOAD",
                "severity": "CRITICAL",
                "value": "NVIDIA library found in /etc/ld.so.preload"
            })
        return findings

    def run_full_analysis(self):
        report = {
            "timestamp": datetime.now().isoformat(),
            "gpu_state": None,
            "gpu_processes": [],
            "mining_detections": [],
            "anomalies": [],
            "driver_findings": [],
            "recommendations": []
        }
        print("[*] 获取 GPU 状态...")
        report["gpu_state"] = self.get_gpu_state()
        print("[*] 获取 GPU 进程列表...")
        report["gpu_processes"] = self.get_gpu_processes()
        print("[*] 检测挖矿进程...")
        report["mining_detections"] = self.detect_miner_processes(report["gpu_processes"])
        print("[*] 检测异常 GPU 使用...")
        report["anomalies"] = self.detect_anomalous_gpu_usage(
            report["gpu_state"], report["gpu_processes"]
        )
        print("[*] 分析驱动完整性...")
        report["driver_findings"] = self.analyze_driver_integrity()
        critical_count = sum(
            1 for d in report["mining_detections"] if d["severity"] == "CRITICAL"
        )
        if critical_count > 0:
            report["recommendations"].append(
                f"发现 {critical_count} 个确认恶意进程，建议立即隔离并取证"
            )
        if report["anomalies"]:
            report["recommendations"].append(
                f"发现 {len(report['anomalies'])} 个异常，建议深入调查"
            )
        output_file = os.path.join(
            self.output_dir,
            f"gpu_analysis_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
        )
        with open(output_file, "w") as f:
            json.dump(report, f, indent=2, ensure_ascii=False)
        print(f"[+] 分析报告已保存: {output_file}")
        print(f"[+] 发现挖矿指示: {len(report['mining_detections'])} 个")
        print(f"[+] 发现异常: {len(report['anomalies'])} 个")
        print(f"[+] 驱动检查项: {len(report['driver_findings'])} 个")
        return report

if __name__ == "__main__":
    analyzer = GPUForensicsAnalyzer()
    analyzer.run_full_analysis()

0x11 公开案例分析

案例一：NVIDIA GPU 驱动漏洞与 Lapsus$ 组织攻击链

11.1.1 攻击背景

2022 年，Lapsus$（又名 Strawberry Spider）黑客组织在对多家大型科技公司的攻击中，利用了 NVIDIA GPU 驱动相关的安全漏洞。该组织以大胆的攻击手法和数据勒索策略著称，目标包括 NVIDIA 的内部系统。

11.1.2 攻击链分析

阶段	ATT&CK 阶段	具体行为	GPU 相关取证证据
初始访问	TA0001	通过社会工程学获取 VPN 凭据	无直接 GPU 证据
凭据访问	TA0006	从 NVIDIA 内部系统提取凭据	无直接 GPU 证据
权限提升	TA0004	利用 GPU 驱动漏洞获取内核权限	内核崩溃日志、GPU 驱动异常事件
横向移动	TA0008	使用提取的凭据扩展访问范围	GPU 管理控制台访问日志
数据渗出	TA0010	窃取约 1TB 数据，包括 GPU 驱动源码和凭据	GPU 驱动源代码仓库访问记录
影响	TA0040	数据勒索，威胁公开被盗数据	无直接 GPU 证据

11.1.3 取证发现

在事件响应过程中，安全团队发现了以下关键证据：

GPU 驱动源码被盗导致的供应链安全风险
攻击者使用合法 VPN 凭据访问 GPU 管理系统
通过 nvidia-smi 导出 XML 报告获取 GPU 配置信息（用于横向移动阶段的资产发现）
攻击者创建了未授权的 GPU 管理账户

11.1.4 IOC

IOC 类型	具体内容
IP 地址	多个已知的 Lapsus$ 基础设施 IP（需从完整报告获取）
文件路径	异常创建的 CUDA 开发工具目录
账户	未授权的 nvidia-smi 管理 API 调用
网络流量	到外部数据渗出点的大规模数据传输

11.1.5 经验教训

GPU 驱动和固件源码是高价值目标，需要与核心商业数据同等的安全保护
VPN 凭据的 MFA 保护至关重要，即使在 GPU 开发团队中也不能例外
GPU 管理 API 的访问控制需要独立审计和监控
驱动漏洞的补丁管理必须与操作系统安全更新同步

案例二：GPU 加速加密货币挖矿恶意软件 VictoryGate 变种

11.2.1 攻击背景

VictoryGate 是一种主要在拉丁美洲地区传播的加密货币挖矿恶意软件，其变种逐步增加了 GPU 加速挖矿能力。2023-2024 年间，安全研究人员发现了多个利用 GPU 进行门罗币（Monero）和以太坊经典（ETC）挖矿的恶意软件家族。

11.2.2 攻击链分析

阶段	ATT&CK 阶段	具体行为	GPU 相关取证证据
初始访问	TA0001 (T1566)	钓鱼邮件投递恶意 Word 文档	邮件附件哈希
执行	TA0002 (T1204)	用户启用宏后执行 VBA 代码	Office 宏执行日志
持久化	TA0003 (T1547)	注册表 Run Key + 任务计划程序	注册表修改记录
权限提升	TA0004 (T1055)	进程注入到合法系统进程	进程内存段异常
防御规避	TA0005 (T1562)	禁用 Windows Defender、hook nvidia-smi 输出	Defender 关闭事件、nvidia-smi 二进制校验失败
资源劫持	TA0040 (T1496)	启动 GPU 挖矿进程	nvidia-smi compute apps 异常、显存占用飙升
命令控制	TA0011 (T1071)	连接到矿池 stratum 协议端口	网络流量中 stratum+tcp 协议

11.2.3 取证发现

安全研究人员通过 GPU 取证分析发现了以下关键证据：

GPU 进程异常：

系统中出现未授权的 nvidia-smi 调用，用于调整 GPU 功耗限制（nvidia-smi -pl 80），降低 GPU 温度和功耗以隐藏挖矿行为
恶意软件在 /tmp/.nvidia_cache/ 目录中存放修改版的挖矿内核
GPU 显存使用量在无任何合法 CUDA 应用运行时突然增加 3-4 GB

驱动级隐藏：

恶意软件通过 LD_PRELOAD 技术 hook 了 libnvidia-ml.so 中的 nvmlDeviceGetComputeRunningProcesses 函数
导致 nvidia-smi --query-compute-apps 的输出被过滤，隐藏了恶意挖矿进程
通过 /etc/ld.so.preload 实现持久化

网络证据：

检测到到 stratum+tcp://pool.minexmr.com:4444 的持续连接
DNS 查询记录中发现多个矿池域名解析

11.2.4 IOC

IOC 类型	具体内容
文件哈希 (SHA256)	恶意挖矿程序和修改版 nvidia-smi（从完整恶意软件报告获取）
矿池地址	`stratum+tcp://pool.minexmr.com:4444`、`stratum+tcp://xmr.pool.minergate.com:45560`
文件路径	`/tmp/.nvidia_cache/`、`/dev/shm/.nvidia_update`
注册表	`HKCU\Software\Microsoft\Windows\CurrentVersion\Run\NvidiaUpdate`
网络端口	TCP 3333、4444、5555、45560
进程名	伪装为 `nvidia-smi.exe`、`nvenc.exe`、`cuda_helper.exe`
邮件主题	与财务发票相关的西班牙语钓鱼邮件

11.2.5 经验教训

GPU 挖矿恶意软件正在进化，使用驱动级隐藏技术规避检测
LD_PRELOAD 劫持 NVIDIA 库是一种有效的 GPU 挖矿隐蔽手段
仅依赖 nvidia-smi 的输出进行 GPU 安全检测是不够的，需要多维度交叉验证
GPU 功耗限制的异常修改是重要的攻击指标
建立 GPU 利用率基线对于检测隐蔽挖矿至关重要

案例对比

对比维度	案例一：Lapsus$ GPU 驱动攻击	案例二：GPU 挖矿恶意软件
攻击动机	数据窃取与勒索	加密货币挖矿获利
目标	GPU 驱动源码与凭据	GPU 计算资源
技术复杂度	🔴 高（社会工程 + 漏洞利用）	🟡 中（已知恶意软件变种）
GPU 取证难度	🟡 中等（管理日志为主）	🔴 高（驱动级隐藏）
持久化方式	VPN 凭据 + 内部账户	注册表 + LD_PRELOAD
影响范围	企业级供应链安全	单机/内网资源劫持
检测方法	异常访问审计 + GPU API 监控	多维度 GPU 行为分析

0x12 参考资料

序号	参考资料	URL
1	NVIDIA CUDA Toolkit Documentation	https://docs.nvidia.com/cuda/cuda-c-programming-guide/
2	NVIDIA Management Library (NVML) Documentation	https://docs.nvidia.com/deploy/nvml-api/
3	MITRE ATT&CK - Resource Hijacking (T1496)	https://attack.mitre.org/techniques/T1496/
4	NVIDIA GPU Security Documentation	https://docs.nvidia.com/datacenter/tesla/security-guide/
5	GPU Side-Channel Attacks (Zhang et al., USENIX Security 2020)	https://www.usenix.org/conference/usenixsecurity20/presentation/zhang-yichi
6	Offensive and Defensive Security of GPU Computing (Georgia Tech)	https://arxiv.org/abs/2107.09471
7	NVIDIA Container Toolkit Documentation	https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/
8	Google Cloud TPU Architecture and Security	https://cloud.google.com/tpu/docs/system-architecture-tpu-vm
9	AWS GPU Instance Security Best Practices	https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/compute-optimized-instances.html
10	NVIDIA MIG (Multi-Instance GPU) Documentation	https://docs.nvidia.com/datacenter/tesla/mig-user-guide/
11	Sigma Rules for Mining Detection	https://github.com/SigmaHQ/sigma/tree/master/rules
12	Cryptojacking Detection and Response Guide (MITRE)	https://attack.mitre.org/mitigations/M1054/
13	GPU Firmware Security Analysis (Black Hat 2023)	https://www.blackhat.com/us-23/briefings.html
14	Lapsus$ Group TTPs Analysis (Mandiant)	https://www.mandiant.com/resources/blog/lapsus-intrusion-group

免责声明：本文所述的所有技术方法、工具和代码示例均仅用于授权的安全研究、数字取证和防御目的。未经授权对计算机系统进行渗透测试、数据提取或安全评估属于违法行为。读者在使用本文内容前，应确保已获得合法授权，并遵守当地法律法规。