【操作系统入门】设备管理与系统安全_触摸屏safetymap-优快云博客

【操作系统入门】第十章：设备管理与系统安全——硬件交互与安全防线

本系列共10篇，这是第10/10篇。在前九章中，我们系统性地探讨了操作系统的核心机制。今天，我们将完成这个系列，深入设备管理与系统安全这两个关键领域。

开篇：从硬件交互到安全边界

想象一个现代化的城市：道路系统（设备管理）确保车辆（数据）高效流动，而警察和安保系统（安全机制）保护城市免受威胁。操作系统正是这样一个数字城市的管理者，既要确保硬件资源的高效利用，又要构建坚固的安全防线。

第一部分：设备管理基础

1.1 设备分类与特性

// 设备分类枚举
typedef enum {
    DEV_CHARACTER = 0,      // 字符设备（键盘、鼠标）
    DEV_BLOCK = 1,          // 块设备（磁盘、SSD）
    DEV_NETWORK = 2,        // 网络设备（网卡）
    DEV_GRAPHICS = 3,       // 图形设备（GPU）
    DEV_STORAGE = 4,        // 存储设备（USB、SATA）
    DEV_INPUT = 5,          // 输入设备（触摸屏）
    DEV_OUTPUT = 6,         // 输出设备（打印机）
    DEV_OTHER = 7           // 其他设备
} device_type_t;

// 设备特性位掩码
#define DEV_FEATURE_POLLING     (1 << 0)    // 支持轮询
#define DEV_FEATURE_INTERRUPT   (1 << 1)    // 支持中断
#define DEV_FEATURE_DMA         (1 << 2)    // 支持DMA
#define DEV_FEATURE_HOTPLUG     (1 << 3)    // 支持热插拔
#define DEV_FEATURE_POWERMGMT   (1 << 4)    // 支持电源管理

1.2 设备控制器与寄存器

// 设备控制器寄存器映射
typedef struct device_registers {
    // 控制和状态寄存器
    volatile uint32_t control;          // 控制寄存器
    volatile uint32_t status;           // 状态寄存器
    volatile uint32_t command;          // 命令寄存器
    
    // 数据寄存器
    volatile uint32_t data_in;          // 数据输入寄存器
    volatile uint32_t data_out;         // 数据输出寄存器
    
    // 中断相关寄存器
    volatile uint32_t interrupt_mask;   // 中断掩码
    volatile uint32_t interrupt_status; // 中断状态
    
    // DMA相关寄存器
    volatile uint32_t dma_address;      // DMA地址
    volatile uint32_t dma_count;        // DMA计数
    
    // 设备特定寄存器
    volatile uint32_t device_specific[8];
} device_regs_t;

// 内存映射I/O访问宏
#define MMIO_READ(addr) (*(volatile uint32_t *)(addr))
#define MMIO_WRITE(addr, val) (*(volatile uint32_t *)(addr) = (val))

// 端口映射I/O函数
static inline uint8_t inb(uint16_t port) {
    uint8_t data;
    asm volatile ("inb %1, %0" : "=a"(data) : "Nd"(port));
    return data;
}

static inline void outb(uint16_t port, uint8_t data) {
    asm volatile ("outb %0, %1" : : "a"(data), "Nd"(port));
}

第二部分：I/O控制方式

2.1 程序控制I/O（轮询）

// 轮询式串口发送
int serial_polling_send(device_regs_t *uart, const char *data, size_t len) {
    for (size_t i = 0; i < len; i++) {
        // 等待发送缓冲区为空
        while (!(MMIO_READ(&uart->status) & UART_STATUS_TX_EMPTY)) {
            cpu_relax();  // 避免过度占用CPU
        }
        
        // 发送字符
        MMIO_WRITE(&uart->data_out, data[i]);
    }
    return 0;
}

// 轮询式设备状态检查
typedef struct polling_device {
    device_regs_t *regs;
    uint32_t timeout_ms;
    uint32_t check_interval_us;
} polling_device_t;

int device_poll_ready(polling_device_t *dev) {
    uint64_t start_time = get_current_time_us();
    
    while (get_current_time_us() - start_time < dev->timeout_ms * 1000) {
        if (MMIO_READ(&dev->regs->status) & DEVICE_READY_MASK) {
            return 0;  // 设备就绪
        }
        udelay(dev->check_interval_us);
    }
    
    return -ETIMEDOUT;  // 超时
}

2.2 中断驱动I/O

// 中断处理程序框架
typedef struct interrupt_handler {
    void (*handler)(int irq, void *dev_id);  // 中断处理函数
    void *dev_id;                            // 设备标识
    unsigned long flags;                     // 标志位
    const char *name;                        // 处理程序名称
    struct interrupt_handler *next;          // 下一个处理程序
} interrupt_handler_t;

// 中断描述符表条目
typedef struct idt_entry {
    uint16_t offset_low;     // 偏移低16位
    uint16_t selector;       // 代码段选择子
    uint8_t zero;            // 保留
    uint8_t type_attr;       // 类型和属性
    uint16_t offset_high;    // 偏移高16位
} __attribute__((packed)) idt_entry_t;

// 中断请求管理
typedef struct interrupt_controller {
    uint32_t base_irq;           // 起始IRQ号
    uint32_t irq_count;          // IRQ数量
    interrupt_handler_t *handlers[32];  // 处理程序链表
    spinlock_t lock;             // 保护锁
    
    // 控制器操作函数
    void (*enable_irq)(struct interrupt_controller *, uint32_t irq);
    void (*disable_irq)(struct interrupt_controller *, uint32_t irq);
    void (*ack_irq)(struct interrupt_controller *, uint32_t irq);
} interrupt_controller_t;

// 中断处理程序注册
int request_irq(uint32_t irq, interrupt_handler_t *handler) {
    interrupt_controller_t *ctrl = get_irq_controller(irq);
    uint32_t local_irq = irq - ctrl->base_irq;
    
    if (local_irq >= ctrl->irq_count) {
        return -EINVAL;
    }
    
    spin_lock(&ctrl->lock);
    
    // 添加到处理程序链表
    handler->next = ctrl->handlers[local_irq];
    ctrl->handlers[local_irq] = handler;
    
    // 启用中断
    ctrl->enable_irq(ctrl, local_irq);
    
    spin_unlock(&ctrl->lock);
    return 0;
}

// 通用中断处理入口
__attribute__((interrupt)) void isr_handler(struct interrupt_frame *frame) {
    uint32_t irq = get_current_irq();
    interrupt_controller_t *ctrl = get_irq_controller(irq);
    uint32_t local_irq = irq - ctrl->base_irq;
    
    // 调用所有注册的处理程序
    interrupt_handler_t *handler = ctrl->handlers[local_irq];
    while (handler != NULL) {
        handler->handler(irq, handler->dev_id);
        handler = handler->next;
    }
    
    // 确认中断处理完成
    ctrl->ack_irq(ctrl, local_irq);
}

2.3 直接内存访问（DMA）

// DMA描述符结构
typedef struct dma_descriptor {
    uint32_t source_addr;        // 源地址
    uint32_t dest_addr;          // 目标地址
    uint32_t transfer_size;      // 传输大小
    uint32_t control_flags;      // 控制标志
    struct dma_descriptor *next; // 下一个描述符
} dma_desc_t;

// DMA控制器管理
typedef struct dma_controller {
    volatile dma_desc_t *descriptors;    // 描述符数组
    uint32_t num_channels;               // 通道数量
    uint32_t max_transfer_size;          // 最大传输大小
    dma_desc_t *free_list;               // 空闲描述符链表
    
    // 硬件寄存器
    volatile uint32_t *channel_regs;     // 通道寄存器基址
    volatile uint32_t *global_regs;      // 全局寄存器
    
    spinlock_t lock;                     // 保护锁
} dma_controller_t;

// DMA缓冲区分配（保证物理连续）
void *dma_alloc_coherent(size_t size, dma_addr_t *dma_handle) {
    // 获取物理连续的页面
    struct page *page = alloc_pages(GFP_DMA, get_order(size));
    if (!page) {
        return NULL;
    }
    
    // 映射到内核虚拟地址空间
    void *vaddr = page_address(page);
    
    // 获取物理地址
    *dma_handle = virt_to_phys(vaddr);
    
    // 保证缓存一致性
    dma_sync_single_for_device(*dma_handle, size, DMA_BIDIRECTIONAL);
    
    return vaddr;
}

// DMA传输启动
int dma_start_transfer(dma_controller_t *dma, int channel, 
                       dma_addr_t src, dma_addr_t dst, size_t size) {
    if (channel >= dma->num_channels || size > dma->max_transfer_size) {
        return -EINVAL;
    }
    
    spin_lock(&dma->lock);
    
    // 获取空闲描述符
    dma_desc_t *desc = dma->free_list;
    if (!desc) {
        spin_unlock(&dma->lock);
        return -ENOMEM;
    }
    dma->free_list = desc->next;
    
    // 配置描述符
    desc->source_addr = src;
    desc->dest_addr = dst;
    desc->transfer_size = size;
    desc->control_flags = DMA_CTRL_COMPLETE_INT | DMA_CTRL_ERROR_INT;
    desc->next = NULL;
    
    // 编程DMA控制器
    volatile uint32_t *chan_reg = &dma->channel_regs[channel * 8];
    MMIO_WRITE(chan_reg + DMA_SRC_REG, src);
    MMIO_WRITE(chan_reg + DMA_DST_REG, dst);
    MMIO_WRITE(chan_reg + DMA_SIZE_REG, size);
    MMIO_WRITE(chan_reg + DMA_CTRL_REG, DMA_CTRL_START | DMA_CTRL_COMPLETE_INT);
    
    spin_unlock(&dma->lock);
    return 0;
}

第三部分：设备驱动程序架构

3.1 驱动程序模型

// 设备结构体
typedef struct device {
    char name[32];                  // 设备名称
    device_type_t type;             // 设备类型
    uint16_t vendor_id;             // 厂商ID
    uint16_t device_id;             // 设备ID
    void *driver_data;              // 驱动私有数据
    
    // 设备操作
    const struct device_operations *ops;
    
    // 电源管理
    struct power_management_info *power;
    
    // 设备树节点（用于动态发现）
    struct device_node *node;
    
    struct list_head list;          // 设备链表
} device_t;

// 设备操作函数表
typedef struct device_operations {
    int (*probe)(device_t *dev);            // 设备探测
    int (*remove)(device_t *dev);           // 设备移除
    int (*suspend)(device_t *dev);          // 挂起设备
    int (*resume)(device_t *dev);           // 恢复设备
    int (*shutdown)(device_t *dev);         // 关闭设备
    
    // 字符设备操作
    const struct file_operations *fops;
    
    // 电源管理操作
    const struct dev_pm_ops *pm_ops;
} device_ops_t;

// 驱动结构体
typedef struct device_driver {
    char name[32];                  // 驱动名称
    const struct device_ops *ops;   // 驱动操作
    
    // 设备ID表（用于自动匹配）
    const struct device_id *id_table;
    
    // 总线特定信息
    struct bus_type *bus;
    
    struct module *owner;           // 模块所有者
    struct list_head devices;       // 管理的设备列表
} device_driver_t;

3.2 总线、设备、驱动模型

// 总线类型
typedef struct bus_type {
    char name[32];                          // 总线名称
    
    // 匹配函数（设备与驱动）
    int (*match)(device_t *dev, device_driver_t *drv);
    
    // 探测函数
    int (*probe)(device_t *dev);
    
    // 设备列表和驱动列表
    struct list_head devices;
    struct list_head drivers;
    
    struct kobject kobj;                    // kobject
    struct subsystem subsys;                // 子系统
} bus_type_t;

// PCI设备驱动示例
static const struct pci_device_id pci_eth_driver_ids[] = {
    { PCI_DEVICE(0x8086, 0x100E) },  // Intel PRO/1000
    { PCI_DEVICE(0x10EC, 0x8168) },  // Realtek RTL8168
    { 0, }  // 结束标记
};

static int pci_eth_probe(struct pci_dev *pdev, const struct pci_device_id *id) {
    struct net_device *netdev;
    struct eth_private *priv;
    int err;
    
    // 启用PCI设备
    err = pci_enable_device(pdev);
    if (err) {
        return err;
    }
    
    // 分配网络设备结构
    netdev = alloc_etherdev(sizeof(struct eth_private));
    if (!netdev) {
        err = -ENOMEM;
        goto err_disable;
    }
    
    // 设置私有数据
    priv = netdev_priv(netdev);
    priv->pdev = pdev;
    priv->netdev = netdev;
    
    // 映射BAR空间
    priv->mmio = pci_iomap(pdev, 0, 0);
    if (!priv->mmio) {
        err = -EIO;
        goto err_free_netdev;
    }
    
    // 设置网络设备操作
    netdev->netdev_ops = &eth_netdev_ops;
    
    // 注册网络设备
    err = register_netdev(netdev);
    if (err) {
        goto err_iounmap;
    }
    
    pci_set_drvdata(pdev, netdev);
    return 0;
    
err_iounmap:
    pci_iounmap(pdev, priv->mmio);
err_free_netdev:
    free_netdev(netdev);
err_disable:
    pci_disable_device(pdev);
    return err;
}

3.3 用户空间设备接口

// 字符设备操作
static const struct file_operations chardev_fops = {
    .owner = THIS_MODULE,
    .open = chardev_open,
    .release = chardev_release,
    .read = chardev_read,
    .write = chardev_write,
    .unlocked_ioctl = chardev_ioctl,
    .mmap = chardev_mmap,
    .poll = chardev_poll,
};

// 设备文件创建
static int __init chardev_init(void) {
    dev_t dev;
    int ret;
    
    // 动态分配设备号
    ret = alloc_chrdev_region(&dev, 0, 1, "example_chardev");
    if (ret < 0) {
        return ret;
    }
    
    // 创建设备类
    g_chardev_class = class_create(THIS_MODULE, "example_class");
    if (IS_ERR(g_chardev_class)) {
        unregister_chrdev_region(dev, 1);
        return PTR_ERR(g_chardev_class);
    }
    
    // 初始化cdev结构
    cdev_init(&g_chardev_cdev, &chardev_fops);
    g_chardev_cdev.owner = THIS_MODULE;
    
    // 添加cdev到系统
    ret = cdev_add(&g_chardev_cdev, dev, 1);
    if (ret) {
        class_destroy(g_chardev_class);
        unregister_chrdev_region(dev, 1);
        return ret;
    }
    
    // 创建设备节点
    device_create(g_chardev_class, NULL, dev, NULL, "example%d", 0);
    
    return 0;
}

第四部分：系统安全基础

4.1 安全威胁分类

// 安全威胁类型枚举
typedef enum {
    THREAT_PRIVILEGE_ESCALATION = 0,    // 权限提升
    THREAT_BUFFER_OVERFLOW = 1,         // 缓冲区溢出
    THREAT_CODE_INJECTION = 2,          // 代码注入
    THREAT_ROGUESOFTWARE = 3,           // 恶意软件
    THREAT_DENIAL_OF_SERVICE = 4,       // 拒绝服务
    THREAT_INFORMATION_LEAKAGE = 5,     // 信息泄露
    THREAT_SIDE_CHANNEL = 6,            // 旁路攻击
    THREAT_MAN_IN_THE_MIDDLE = 7        // 中间人攻击
} security_threat_t;

// 安全事件结构
typedef struct security_event {
    uint64_t timestamp;                 // 时间戳
    security_threat_t threat_type;      // 威胁类型
    uint32_t severity;                  // 严重程度
    pid_t process_id;                   // 相关进程
    uid_t user_id;                      // 用户ID
    char description[256];              // 事件描述
    struct list_head list;              // 链表
} security_event_t;

4.2 访问控制机制

// 访问控制列表（ACL）条目
typedef struct acl_entry {
    uid_t subject;                      // 主体（用户/组）
    uint32_t permissions;               // 权限位掩码
    uint8_t type;                       // 条目类型（用户/组/其他）
    struct acl_entry *next;             // 下一个条目
} acl_entry_t;

// 能力（Capability）系统
typedef struct capability_set {
    uint64_t effective;                 // 有效能力集
    uint64_t permitted;                 // 允许能力集
    uint64_t inheritable;               // 可继承能力集
    uint64_t bounding;                  // 边界能力集
} capability_set_t;

// Linux能力位定义
#define CAP_CHOWN            0  // 改变文件所有者
#define CAP_DAC_OVERRIDE     1  // 忽略DAC访问限制
#define CAP_DAC_READ_SEARCH  2  // 忽略DAC读/搜索限制
#define CAP_FOWNER           3  // 忽略文件属主检查
#define CAP_KILL             5  // 允许对不属于自己的进程发送信号
#define CAP_NET_RAW         13  // 允许使用原始套接字
#define CAP_SYS_ADMIN       21  // 系统管理权限
#define CAP_SYS_MODULE      16  // 插入和删除内核模块

// 能力检查函数
int capable(int cap) {
    // 检查当前进程是否具有指定能力
    if (current->cred->cap_effective & (1ULL << cap)) {
        return 1;
    }
    
    audit_capability(cap, 0);  // 记录能力检查失败
    return 0;
}

// 强制访问控制（MAC）标签
typedef struct mac_label {
    uint32_t sensitivity;               // 敏感度级别
    uint32_t categories;                // 类别位图
    uint8_t integrity;                  // 完整性级别
} mac_label_t;

// SELinux安全上下文
typedef struct security_context {
    char user[32];                      // 用户身份
    char role[32];                      // 角色
    char type[32];                      // 类型/域
    char range[64];                     // 多级安全范围
} security_context_t;

第五部分：内存保护机制

5.1 地址空间布局随机化（ASLR）

// ASLR熵池管理
typedef struct aslr_entropy {
    uint64_t stack_base;                // 栈基址熵
    uint64_t mmap_base;                 // 内存映射熵
    uint64_t heap_base;                 // 堆基址熵
    uint64_t vdso_base;                 // VDSO基址熵
    uint64_t exec_base;                 // 可执行文件基址熵
} aslr_entropy_t;

// ASLR随机化实现
uint64_t randomize_address(uint64_t base, uint64_t entropy_bits) {
    uint64_t mask = (1ULL << entropy_bits) - 1;
    uint64_t random_offset = get_random_long() & mask;
    
    // 确保对齐
    random_offset &= PAGE_MASK;
    
    return base + random_offset;
}

// 进程地址空间随机化
void randomize_process_layout(struct mm_struct *mm) {
    unsigned long entropy = calculate_aslr_entropy();
    
    // 随机化栈位置
    mm->mmap_base = randomize_address(DEFAULT_MMAP_BASE, entropy);
    
    // 随机化堆位置
    mm->brk = randomize_address(DEFAULT_BRK_BASE, entropy);
    
    // 随机化其他内存区域
    mm->start_stack = randomize_address(DEFAULT_STACK_BASE, entropy);
    mm->arg_start = mm->start_stack;
}

5.2 数据执行保护（DEP/NX）

// 页表项中的NX位设置
#define PAGE_PRESENT    (1ULL << 0)
#define PAGE_WRITABLE   (1ULL << 1)
#define PAGE_USER       (1ULL << 2)
#define PAGE_NX         (1ULL << 63)  // 不执行位

// 内存区域保护标志
typedef enum {
    VM_READ = 0x00000001,      // 可读
    VM_WRITE = 0x00000002,     // 可写
    VM_EXEC = 0x00000004,      // 可执行
    VM_SHARED = 0x00000008,    // 共享映射
    VM_MAYREAD = 0x00000010,   // 可能可读
    VM_MAYWRITE = 0x00000020,  // 可能可写
    VM_MAYEXEC = 0x00000040,   // 可能可执行
    VM_MAYSHARE = 0x00000080,  // 可能共享
    VM_NX = 0x80000000         // 不执行（自定义标志）
} vm_flags_t;

// 内存映射保护检查
int mprotect_fixup(struct vm_area_struct *vma, unsigned long start, 
                   unsigned long end, unsigned long newflags) {
    // 检查W^X（写或执行，但不能同时具备）
    if ((newflags & (VM_WRITE | VM_EXEC)) == (VM_WRITE | VM_EXEC)) {
        if (!(current->personality & READ_IMPLIES_EXEC)) {
            return -EACCES;  // 拒绝同时具备写和执行权限
        }
    }
    
    // 如果请求执行权限，但区域标记为NX
    if ((newflags & VM_EXEC) && (vma->vm_flags & VM_NX)) {
        return -EACCES;  // 拒绝在NX区域添加执行权限
    }
    
    return 0;
}

5.3 控制流完整性（CFI）

// 间接调用保护
typedef struct cfi_policy {
    uint32_t mode;                      // CFI模式
    uint32_t error_action;              // 错误处理动作
    uintptr_t *valid_targets;           // 有效目标表
    size_t num_targets;                 // 目标数量
} cfi_policy_t;

// CFI检查函数
__attribute__((noinline)) 
void cfi_check_call(uintptr_t target, uintptr_t expected_type) {
    // 检查目标地址是否在有效范围内
    if (!is_valid_call_target(target, expected_type)) {
        cfi_violation_detected(target, expected_type);
    }
}

// 编译器插桩的CFI检查
#define CFI_CALL(func) \
    do { \
        cfi_check_call((uintptr_t)func, CFI_TYPE_FUNCTION); \
        func; \
    } while(0)

// 影子栈实现（用于保护返回地址）
typedef struct shadow_stack {
    uintptr_t *stack;                   // 影子栈数组
    size_t size;                        // 栈大小
    size_t top;                         // 栈顶指针
    uint64_t canary;                    // 栈保护金丝雀值
} shadow_stack_t;

// 函数入口时压入返回地址到影子栈
void shadow_stack_push(uintptr_t return_addr) {
    current_shadow_stack()->stack[current_shadow_stack()->top++] = return_addr;
    
    // 检查栈溢出
    if (current_shadow_stack()->top >= current_shadow_stack()->size) {
        handle_shadow_stack_overflow();
    }
}

// 函数返回时检查影子栈
uintptr_t shadow_stack_pop(uintptr_t expected_ret) {
    if (current_shadow_stack()->top == 0) {
        handle_shadow_stack_underflow();
    }
    
    uintptr_t actual_ret = current_shadow_stack()->stack[--current_shadow_stack()->top];
    
    if (actual_ret != expected_ret) {
        handle_return_address_corruption(actual_ret, expected_ret);
    }
    
    return actual_ret;
}

第六部分：内核安全机制

6.1 内核模块安全

// 模块签名验证
typedef struct module_signature {
    uint8_t algo;           // 签名算法
    uint8_t hash;           // 哈希算法
    uint8_t id_type;        // 密钥标识类型
    uint8_t signer_len;     // 签名者长度
    uint8_t key_id_len;     // 密钥ID长度
    uint8_t __pad[3];
    uint32_t sig_len;       // 签名长度
    // 可变长度字段跟随...
} module_signature_t;

// 模块加载安全检查
int module_safety_check(struct module *mod) {
    // 1. 验证模块签名
    if (!verify_module_signature(mod)) {
        printk(KERN_ERR "Module %s has invalid signature\n", mod->name);
        return -EKEYREJECTED;
    }
    
    // 2. 检查模块黑名单
    if (is_module_blacklisted(mod->name)) {
        printk(KERN_ERR "Module %s is blacklisted\n", mod->name);
        return -EPERM;
    }
    
    // 3. 验证模块权限
    if (!check_module_permissions(mod)) {
        printk(KERN_ERR "Module %s requires excessive permissions\n", mod->name);
        return -EPERM;
    }
    
    // 4. 检查代码完整性
    if (!validate_module_code(mod)) {
        printk(KERN_ERR "Module %s failed code validation\n", mod->name);
        return -EINVAL;
    }
    
    return 0;
}

// 内核地址空间布局随机化（KASLR）
void randomize_kernel_layout(void) {
    phys_addr_t phys_offset;
    
    // 随机化内核物理地址偏移
    phys_offset = get_random_long() & KERNEL_PHYS_MASK;
    memstart_addr += phys_offset;
    
    // 随机化内核虚拟地址
    va_pa_offset = PAGE_OFFSET - memstart_addr;
    
    // 随机化模块加载地址
    module_alloc_base = MODULES_VADDR + (get_random_long() & MODULES_RAND_MASK);
    
    // 随机化其他内核区域
    randomize_kernel_sections();
}

6.2 系统调用过滤

// seccomp BPF过滤器
struct sock_filter seccomp_filter[] = {
    // 加载系统调用号
    BPF_STMT(BPF_LD | BPF_W | BPF_ABS, offsetof(struct seccomp_data, nr)),
    
    // 检查系统调用号范围
    BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, __NR_read, 0, 5),
    BPF_JUMP(BPF_JMP | BPF_JGT | BPF_K, __NR_munmap, 3, 0),
    
    // 允许的系统调用
    BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, __NR_read, 4, 0),
    BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, __NR_write, 3, 0),
    BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, __NR_exit, 2, 0),
    
    // 拒绝其他系统调用
    BPF_STMT(BPF_RET | BPF_K, SECCOMP_RET_KILL),
    
    // 允许通过的系统调用
    BPF_STMT(BPF_RET | BPF_K, SECCOMP_RET_ALLOW),
};

// seccomp策略应用
int apply_seccomp_policy(int mode) {
    struct sock_fprog prog;
    
    prog.len = sizeof(seccomp_filter) / sizeof(seccomp_filter[0]);
    prog.filter = seccomp_filter;
    
    return prctl(PR_SET_SECCOMP, mode, &prog, 0, 0);
}

// 系统调用拦截
typedef struct syscall_hook {
    unsigned long nr;                   // 系统调用号
    void *original;                     // 原始系统调用
    void *hook;                         // 钩子函数
    struct list_head list;              // 链表
} syscall_hook_t;

// 系统调用表保护
void protect_syscall_table(void) {
    // 将系统调用表所在页面设为只读
    set_memory_ro((unsigned long)sys_call_table, 
                  DIV_ROUND_UP(NR_syscalls * sizeof(void *), PAGE_SIZE));
}

第七部分：硬件安全特性

7.1 可信执行环境（TEE）

// TEE会话管理
typedef struct tee_session {
    uuid_t session_uuid;                // 会话UUID
    uint32_t session_id;                // 会话ID
    tee_operation_t active_operation;   // 活动操作
    uint32_t return_code;               // 返回码
    struct list_head command_queue;     // 命令队列
    spinlock_t lock;                    // 会话锁
} tee_session_t;

// 安全世界调用（ARM TrustZone）
uint32_t smc_call(uint32_t arg0, uint32_t arg1, uint32_t arg2, uint32_t arg3) {
    register uint32_t r0 asm("r0") = arg0;
    register uint32_t r1 asm("r1") = arg1;
    register uint32_t r2 asm("r2") = arg2;
    register uint32_t r3 asm("r3") = arg3;
    
    asm volatile (
        ".arch_extension sec\n\t"
        "smc #0"
        : "=r"(r0)
        : "r"(r0), "r"(r1), "r"(r2), "r"(r3)
        : "memory"
    );
    
    return r0;
}

// Intel SGX enclave管理
typedef struct sgx_enclave {
    uint64_t base_addr;                 // enclave基地址
    uint64_t size;                      // enclave大小
    uint8_t *sealed_data;               // 密封数据
    size_t sealed_size;                 // 密封数据大小
    struct list_head pages;             // enclave页面列表
} sgx_enclave_t;

// enclave初始化
int sgx_enclave_init(sgx_enclave_t *enclave, void *source_code, size_t code_size) {
    // 创建enclave
    if (sgx_create_enclave(enclave) != SGX_SUCCESS) {
        return -ENOMEM;
    }
    
    // 加载代码到enclave
    if (sgx_load_data(enclave, source_code, code_size) != SGX_SUCCESS) {
        sgx_destroy_enclave(enclave);
        return -EIO;
    }
    
    // 初始化enclave
    if (sgx_initialize_enclave(enclave) != SGX_SUCCESS) {
        sgx_destroy_enclave(enclave);
        return -EINVAL;
    }
    
    return 0;
}

7.2 内存加密技术

// 内存加密引擎
typedef struct memory_encryption_engine {
    uint8_t *key;                       // 加密密钥
    size_t key_size;                    // 密钥大小
    uint64_t tweak_mask;                // 调整值掩码
    uint32_t sector_size;               // 加密扇区大小
    
    // 加密操作
    int (*encrypt)(struct memory_encryption_engine *, 
                   uint64_t phys_addr, void *data, size_t len);
    int (*decrypt)(struct memory_encryption_engine *, 
                   uint64_t phys_addr, void *data, size_t len);
} memory_encryption_engine_t;

// AMD SEV（安全加密虚拟化）支持
typedef struct sev_domain {
    uint32_t asid;                      // 地址空间ID
    uint8_t *launch_blob;               // 启动blob
    size_t launch_blob_size;            // blob大小
    uint64_t guests_visible;            // 客户机可见标志
} sev_domain_t;

// SEV虚拟机保护
int sev_guest_protect(struct kvm *kvm) {
    struct kvm_sev_cmd sev_cmd;
    int ret;
    
    // 初始化SEV
    sev_cmd.id = KVM_SEV_INIT;
    ret = kvm->arch.sev_ops->sev_guest_cmd(kvm, &sev_cmd);
    if (ret) {
        return ret;
    }
    
    // 启动SEV guest
    sev_cmd.id = KVM_SEV_LAUNCH_START;
    ret = kvm->arch.sev_ops->sev_guest_cmd(kvm, &sev_cmd);
    if (ret) {
        return ret;
    }
    
    // 加密guest内存
    sev_cmd.id = KVM_SEV_LAUNCH_UPDATE_DATA;
    ret = kvm->arch.sev_ops->sev_guest_cmd(kvm, &sev_cmd);
    
    return ret;
}

第八部分：安全监控与响应

8.1 安全审计系统

// 审计规则
typedef struct audit_rule {
    uint32_t rule_id;                   // 规则ID
    uint32_t action;                    // 动作（允许/拒绝/记录）
    uint32_t subject_type;              // 主体类型
    uint32_t object_type;               // 对象类型
    uint32_t permission_mask;           // 权限掩码
    struct list_head conditions;        // 条件列表
} audit_rule_t;

// 审计记录
typedef struct audit_record {
    uint64_t timestamp;                 // 时间戳
    uint32_t event_id;                  // 事件ID
    uid_t subject_uid;                  // 主体用户ID
    pid_t subject_pid;                  // 主体进程ID
    uint32_t object_type;               // 对象类型
    uint64_t object_id;                 // 对象ID
    uint32_t action;                    // 执行动作
    uint32_t result;                    // 结果（成功/失败）
    char details[512];                  // 详细信息
} audit_record_t;

// 审计系统初始化
int audit_system_init(void) {
    // 创建审计缓冲区
    g_audit_buffer = kmalloc(AUDIT_BUFFER_SIZE, GFP_KERNEL);
    if (!g_audit_buffer) {
        return -ENOMEM;
    }
    
    // 初始化审计规则表
    INIT_LIST_HEAD(&g_audit_rules);
    
    // 启动审计后台线程
    g_audit_thread = kthread_run(audit_worker_thread, NULL, "kauditd");
    if (IS_ERR(g_audit_thread)) {
        kfree(g_audit_buffer);
        return PTR_ERR(g_audit_thread);
    }
    
    // 注册审计钩子
    register_security_hooks();
    
    return 0;
}

// 审计事件记录
void audit_log_event(uint32_t event_id, void *subject, void *object, 
                     uint32_t action, uint32_t result, const char *details) {
    struct audit_record record;
    
    // 填充记录字段
    record.timestamp = ktime_get_real_ns();
    record.event_id = event_id;
    record.subject_uid = current_uid();
    record.subject_pid = current_pid();
    record.action = action;
    record.result = result;
    
    if (details) {
        strncpy(record.details, details, sizeof(record.details) - 1);
        record.details[sizeof(record.details) - 1] = '\0';
    } else {
        record.details[0] = '\0';
    }
    
    // 添加到审计缓冲区
    audit_buffer_add_record(&record);
}

8.2 入侵检测系统

// 入侵检测规则
typedef struct ids_rule {
    uint32_t rule_id;                   // 规则ID
    char *pattern;                      // 检测模式
    uint32_t pattern_len;               // 模式长度
    uint32_t severity;                  // 严重程度
    uint32_t action;                    // 响应动作
    struct list_head triggers;          // 触发条件
} ids_rule_t;

// 异常行为检测
typedef struct behavior_analysis {
    uint64_t normal_baseline[BEHAVIOR_METRICS];  // 正常行为基线
    uint64_t current_metrics[BEHAVIOR_METRICS];  // 当前行为指标
    uint32_t anomaly_score;                       // 异常分数
    uint32_t confidence;                          // 置信度
} behavior_analysis_t;

// 实时入侵检测
int ids_detect_intrusion(struct task_struct *task, const char *operation) {
    behavior_analysis_t *analysis = get_task_behavior(task);
    uint32_t anomaly_score = 0;
    
    // 更新行为指标
    update_behavior_metrics(analysis, operation);
    
    // 计算异常分数
    anomaly_score = calculate_anomaly_score(analysis);
    
    // 检查是否超过阈值
    if (anomaly_score > INTRUSION_THRESHOLD) {
        // 触发入侵警报
        trigger_intrusion_alert(task, anomaly_score, operation);
        
        // 执行响应动作
        execute_intrusion_response(task, anomaly_score);
        
        return 1;  // 检测到入侵
    }
    
    return 0;  // 正常行为
}

// 基于机器学习的异常检测
int ml_anomaly_detection(behavior_analysis_t *analysis) {
    float features[ML_FEATURE_COUNT];
    float anomaly_probability;
    
    // 提取特征向量
    extract_behavior_features(analysis, features);
    
    // 使用预训练模型进行推理
    anomaly_probability = ml_model_predict(features);
    
    // 返回检测结果
    return anomaly_probability > ML_ANOMALY_THRESHOLD;
}