一、顶级架构一句话总结
输入验证 → 边界检查 → 权限控制 → 安全API → 漏洞防护
驱动安全是系统安全的第一道防线，内核驱动漏洞可能导致整个系统被攻陷。
二、驱动安全威胁模型
常见攻击面
三、输入验证与边界检查
用户空间指针验证
#include <linux/uaccess.h>
// ❌ 不安全：直接访问用户空间指针
static ssize_t unsafe_read(struct file *filp, char __user *buf,
size_t count, loff_t *pos)
{
char *kbuf = kmalloc(count, GFP_KERNEL);
// 直接复制，没有验证！
copy_to_user(buf, kbuf, count);
kfree(kbuf);
return count;
}
// ✅ 安全：验证用户空间指针
static ssize_t safe_read(struct file *filp, char __user *buf,
size_t count, loff_t *pos)
{
if (!access_ok(buf, count))
return -EFAULT;
char *kbuf = kmalloc(count, GFP_KERNEL);
if (!kbuf)
return -ENOMEM;
if (copy_to_user(buf, kbuf, count)) {
kfree(kbuf);
return -EFAULT;
}
kfree(kbuf);
return count;
}
数组边界检查
#define MAX_ENTRIES 16
struct entry {
int data;
};
static struct entry entries[MAX_ENTRIES];
// ❌ 不安全：没有边界检查
static int unsafe_entry_access(int index, int value)
{
entries[index].data = value;
return 0;
}
// ✅ 安全：边界检查
static int safe_entry_access(int index, int value)
{
if (index < 0 || index >= MAX_ENTRIES)
return -EINVAL;
entries[index].data = value;
return 0;
}
整数溢出检查
#include <linux/overflow.h>
// ❌ 不安全：可能整数溢出
static void *unsafe_alloc(int count, int size)
{
int total = count * size;
return kmalloc(total, GFP_KERNEL);
}
// ✅ 安全：使用check_mul_overflow
static void *safe_alloc(int count, int size)
{
size_t total;
if (check_mul_overflow(count, size, &total))
return NULL;
return kmalloc(total, GFP_KERNEL);
}
// 其他检查宏
check_add_overflow(a, b, &result) // 加法溢出检查
check_sub_overflow(a, b, &result) // 减法溢出检查
check_mul_overflow(a, b, &result) // 乘法溢出检查
格式化字符串漏洞防护
// ❌ 不安全：格式化字符串漏洞
static void unsafe_log(const char *fmt, ...)
{
char buf[256];
va_list args;
va_start(args, fmt);
vsprintf(buf, fmt, args); // 危险！
va_end(args);
pr_info("%s", buf);
}
// ✅ 安全：使用scnprintf或vsnprintf
static void safe_log(const char *fmt, ...)
{
char buf[256];
va_list args;
va_start(args, fmt);
vsnprintf(buf, sizeof(buf), fmt, args); // 安全
va_end(args);
pr_info("%s", buf);
}
四、权限控制
设备文件权限
#include <linux/fs.h>
#include <linux/cred.h>
// 检查CAP_SYS_ADMIN权限
#include <linux/capability.h>
static int ioctl_with_cap_check(struct file *filp, unsigned int cmd,
unsigned long arg)
{
if (!capable(CAP_SYS_ADMIN))
return -EPERM;
// 执行需要管理员权限的操作
return 0;
}
// 检查文件系统权限
static int open_with_perm_check(struct inode *inode, struct file *filp)
{
if ((filp->f_flags & O_ACCMODE) != O_RDONLY) {
// 写操作需要检查
if (!capable(CAP_SYS_ADMIN))
return -EPERM;
}
return 0;
}
Sysfs权限控制
#include <linux/sysfs.h>
// 只读属性
static ssize_t status_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
return sprintf(buf, "0x%x\n", status);
}
static DEVICE_ATTR_RO(status); // 只读权限
// 只写属性（需要root）
static ssize_t control_store(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t count)
{
if (!capable(CAP_SYS_ADMIN))
return -EPERM;
// 处理控制命令
return count;
}
static DEVICE_ATTR_WO(control); // 只写权限
// 读写属性（可配置权限）
static DEVICE_ATTR_RW(config); // 读写权限
五、安全API使用
内存安全
#include <linux/slab.h>
#include <linux/string.h>
// ✅ 安全：使用kzalloc初始化
void *safe_alloc(size_t size)
{
return kzalloc(size, GFP_KERNEL); // 自动清零
}
// ✅ 安全：使用strscpy代替strcpy
void safe_string_copy(char *dst, const char *src, size_t dst_size)
{
strscpy(dst, src, dst_size); // 保证安全
}
// ✅ 安全：使用kfree_sensitive
void free_sensitive_data(void *ptr, size_t size)
{
kzfree(ptr); // 清零后释放
}
// 或者手动清零
void clear_and_free(void *ptr, size_t size)
{
if (ptr) {
memzero_explicit(ptr, size); // 不被优化掉
kfree(ptr);
}
}
随机数生成
#include <linux/random.h>
// 生成加密安全的随机数
void generate_secure_random(void *buf, size_t len)
{
get_random_bytes(buf, len);
}
// 生成随机整数
u32 get_random_u32(void)
{
return get_random_u32();
}
// 生成随机长整数
unsigned long get_random_long(void)
{
return get_random_long();
}
时间相关安全
#include <linux/timekeeping.h>
// 使用单调时间，不受系统时间修改影响
u64 get_safe_timestamp(void)
{
return ktime_get_mono_fast_ns();
}
// 计算时间差
u64 calculate_elapsed(u64 start)
{
u64 now = ktime_get_mono_fast_ns();
return now - start;
}
六、竞态条件防护
正确使用锁
#include <linux/spinlock.h>
#include <linux/mutex.h>
// 自旋锁：短时间临界区
static DEFINE_SPINLOCK(lock);
static unsigned long flags;
void spinlock_example(void)
{
spin_lock_irqsave(&lock, flags);
// 临界区：不可睡眠，短时间
spin_unlock_irqrestore(&lock, flags);
}
// 互斥锁：可能睡眠的临界区
static DEFINE_MUTEX(mutex);
void mutex_example(void)
{
mutex_lock(&mutex);
// 临界区：可以睡眠
mutex_unlock(&mutex);
}
// 读写锁：读多写少场景
static DEFINE_RWLOCK(rwlock);
void read_example(void)
{
read_lock(&rwlock);
// 读操作
read_unlock(&rwlock);
}
void write_example(void)
{
write_lock(&rwlock);
// 写操作
write_unlock(&rwlock);
}
RCU使用
#include <linux/rcupdate.h>
struct config {
int param1;
int param2;
struct rcu_head rcu;
};
static struct config *global_config;
// 读端
int read_config(void)
{
int val;
rcu_read_lock();
val = rcu_dereference(global_config)->param1;
rcu_read_unlock();
return val;
}
// 写端
void update_config(int new_val)
{
struct config *old, *new;
new = kmalloc(sizeof(*new), GFP_KERNEL);
if (!new)
return;
rcu_read_lock();
old = rcu_dereference(global_config);
*new = *old;
new->param1 = new_val;
rcu_read_unlock();
rcu_assign_pointer(global_config, new);
synchronize_rcu();
kfree(old);
}
七、DMA安全
IOMMU/SMMU使用
#include <linux/iommu.h>
#include <linux/dma-mapping.h>
// 检查IOMMU是否启用
bool is_iommu_enabled(struct device *dev)
{
return device_iommu_mapped(dev);
}
// 使用IOMMU的DMA映射
dma_addr_t safe_dma_map(struct device *dev, void *cpu_addr,
size_t size, enum dma_data_direction dir)
{
dma_addr_t dma_addr;
dma_addr = dma_map_single(dev, cpu_addr, size, dir);
if (dma_mapping_error(dev, dma_addr))
return DMA_MAPPING_ERROR;
return dma_addr;
}
// 限制DMA访问范围
int limit_dma_mask(struct device *dev, u64 mask)
{
return dma_set_mask_and_coherent(dev, mask);
}
DMA缓冲区安全
// 使用DMA池
#include <linux/dmapool.h>
static struct dma_pool *dma_pool;
int init_dma_pool(struct device *dev)
{
dma_pool = dma_pool_create("safe_dma", dev, 256, 64, 0);
if (!dma_pool)
return -ENOMEM;
return 0;
}
void *alloc_safe_dma(size_t size, dma_addr_t *dma_handle)
{
return dma_pool_alloc(dma_pool, GFP_KERNEL, dma_handle);
}
void free_safe_dma(void *cpu_addr, dma_addr_t dma_handle)
{
dma_pool_free(dma_pool, cpu_addr, dma_handle);
}
八、漏洞防护最佳实践
内核硬化配置
// 在驱动中使用编译时检查
#ifdef CONFIG_CC_STACKPROTECTOR
#pragma message "Stack protector enabled - good!"
#endif
#ifdef CONFIG_CC_STACKPROTECTOR_STRONG
#pragma message "Strong stack protector enabled - great!"
#endif
// 使用静态分析注解
#include <linux/compiler.h>
__must_check int critical_function(void)
{
// 必须检查返回值
return 0;
}
调试与加固
#include <linux/bug.h>
// 使用BUG_ON/WARN_ON进行防御性编程
void validate_input(int value)
{
// 致命错误
BUG_ON(value < 0);
// 警告但继续
WARN_ON(value > 100);
}
// 使用BUILD_BUG_ON进行编译时检查
#define MAX_SIZE 1024
BUILD_BUG_ON(MAX_SIZE > PAGE_SIZE);
九、安全审计清单
驱动安全检查清单
- ⬜
- ⬜
十、终极总结
驱动安全 = 深度防御 + 持续审计
- 权限控制：capable、文件权限、SELinux
- 安全API：strscpy、kzalloc、get_random_bytes
- 漏洞防护：stack protector、static keys、硬化配置
安全驱动是系统安全的基石！
