Week 1 - kernel pwn 常見操作與保護機制

Posted on Edited on In

本文章涵蓋 kernel pwn 常用於 exploit 的操作，背後實作架構，及常見的保護機制。

分配記憶體

  • kmalloc
    申請的 memory 在物理上連續，大小不超過 4MB，效能較快。
  • vmalloc
    申請的 memory 在物理上不連續，申請的單位為 page。
    映射位置在 vmalloc/ioremap space，大小任意，可能被 block。
    由於 kernel 需要將多個 physical address 映射到一塊 virtual address，因此效能較慢。
  • kvmalloc
    大於 1 page 使用 vmalloc，反之 kmalloc。
  • kzmalloc
    同 kmalloc，附加 GFP_ZERO flag 清空資料。
  • kmem_cache_alloc
    從特定的 slab allocator 分配。
  • alloc_pages
    向 buddy system 要一塊記憶體，大小不超過 4MB。

setxattr

setxattr 用於編輯某個 inode attribute，由於裡面先 kvmalloc 一塊記憶體，copy_from_user 後 free 掉，常搭配 userfaultfd, FUSE 做 race condition 利用。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
static long
setxattr(struct user_namespace *mnt_userns, struct dentry *d,
     const char __user *name, const void __user *value, size_t size,
     int flags)
{
    if (size) {
        kvalue = kvmalloc(size, GFP_KERNEL);
        if (copy_from_user(kvalue, value, size)) {
            error = -EFAULT;
            goto out;
        }
    }
    kvfree(kvalue);

    return error;
}

pipe

預設 pipefd[0] 讀取，pipefd[1] 寫入。
pipe 緩衝區是有限的，write 時可能會 block 住。

  • O_CLOEXEC 在 execve 時關閉 fd
  • O_NONBLOCK 所有 IO 操作變為 non-blocking

linux 本身就有叫 pipeline 的機制，而 pipe() 用來創建一個匿名的 pipeline。
kernel 裡面由 do_pipe2 處理 pipe syscall，連結 fd 和 file struct。其中 __do_pipe_flags 負責創建 fd，create_pipe_files 創建匿名檔案。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
int create_pipe_files(struct file res, int flags)
{
    struct inode *inode = get_pipe_inode();
    struct file *f;
    int error;

    f = alloc_file_pseudo(inode, pipe_mnt, "",
                O_WRONLY | (flags & (O_NONBLOCK | O_DIRECT)),
                &pipefifo_fops);

    f->private_data = inode->i_pipe;
    f->f_pipe = 0;

    res[0] = alloc_file_clone(f, O_RDONLY | (flags & O_NONBLOCK),
                  &pipefifo_fops);
                  
    res[0]->private_data = inode->i_pipe;
    res[0]->f_pipe = 0;
    res[1] = f;
    stream_open(inode, res[0]);
    stream_open(inode, res[1]);
    file_set_fsnotify_mode(res[0], FMODE_NONOTIFY_PERM);
    file_set_fsnotify_mode(res[1], FMODE_NONOTIFY_PERM);
    return 0;
}

複製資料

圖片來自 jserv

  1. read+write
    需要四次 copy。
    1RoFRKx.png
  2. mmap
    可通過 shared memory 減少一次 copy。然而，兩個程式對同一 file 寫入會觸發 SIGBUS。
    況且，記憶體管理需要代價。用 read 依序讀資料，可增加 cache hit 的機率，可能速度更快。
    9madsOS.png
  3. sendfile
    在 kernel space 裡面做 copy。若 out_fd 是 socket，且網卡支援 zero-copy，則減少為兩次 copy。
    Xco4OR0.png
    檢查是否支援 zero-copy： 
    1
    ethtool -k eth0 | grep scatter-gather

splice

在 kernel 達成 zero-copy，不需硬體支援，out_fd 也可以是 file。
upload_0ac05c0576a78f075c900f77605b5dc3.jpg

splice 背後用 pipe 達成，最關鍵在 *obuf = *ibuf;。
一個 pipe_inode_info 包含多個 buf 儲存資料，而一個 buf 包含一個 page，splice 只是將 pipe_buffer 的 pointer 複製而已。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
static int splice_pipe_to_pipe(struct pipe_inode_info *ipipe,
                   struct pipe_inode_info *opipe,
                   size_t len, unsigned int flags)
{
    // init, check, lock ...

    i_tail = ipipe->tail;
    i_mask = ipipe->ring_size - 1;
    o_head = opipe->head;
    o_mask = opipe->ring_size - 1;

    do {
        // some checks ...

        ibuf = &ipipe->bufs[i_tail & i_mask];
        obuf = &opipe->bufs[o_head & o_mask];

        if (len >= ibuf->len) {
            /*
             * Simply move the whole buffer from ipipe to opipe
             */
            *obuf = *ibuf;
            ibuf->ops = NULL;
            i_tail++;
            ipipe->tail = i_tail;
            input_wakeup = true;
            o_len = obuf->len;
            o_head++;
            opipe->head = o_head;
        } else {
            if (!pipe_buf_get(ipipe, ibuf)) {
                if (ret == 0)
                    ret = -EFAULT;
                break;
            }
            *obuf = *ibuf;

            obuf->flags &= ~PIPE_BUF_FLAG_GIFT;
            obuf->flags &= ~PIPE_BUF_FLAG_CAN_MERGE;

            obuf->len = len;
            ibuf->offset += len;
            ibuf->len -= len;
            o_len = len;
            o_head++;
            opipe->head = o_head;
        }
        ret += o_len;
        len -= o_len;
    } while (len);

    pipe_unlock(ipipe);
    pipe_unlock(opipe);

    if (ret > 0)
        wakeup_pipe_readers(opipe);

    if (input_wakeup)
        wakeup_pipe_writers(ipipe);

    return ret;
}

tee

splice 能高效搬移資料，若 fd_in 是 pipe, socket 或 stdin，裡面的東西會搬到 fd_out，不能再從 fd_in 讀。
如果是檔案，它只移動 offset 位置，lseek 恢復即可。
tee 就像 splice，能通過 pipe 複製資料，tee 背後調用 link_pipe 行為非常像 splice_pipe_to_pipe，只是少了 ibuf->offset += len; ibuf->len -= len; 的行為。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
static ssize_t link_pipe(struct pipe_inode_info *ipipe,
             struct pipe_inode_info *opipe,
             size_t len, unsigned int flags)
{
    i_tail = ipipe->tail;
    i_mask = ipipe->ring_size - 1;
    o_head = opipe->head;
    o_mask = opipe->ring_size - 1;

    do {
        // check ...

        ibuf = &ipipe->bufs[i_tail & i_mask];
        obuf = &opipe->bufs[o_head & o_mask];

        if (!pipe_buf_get(ipipe, ibuf)) {
            if (ret == 0)
                ret = -EFAULT;
            break;
        }

        *obuf = *ibuf;
        obuf->flags &= ~PIPE_BUF_FLAG_GIFT;
        obuf->flags &= ~PIPE_BUF_FLAG_CAN_MERGE;

        if (obuf->len > len)
            obuf->len = len;
        ret += obuf->len;
        len -= obuf->len;

        o_head++;
        opipe->head = o_head;
        i_tail++;
    } while (len);

    pipe_unlock(ipipe);
    pipe_unlock(opipe);

    if (ret > 0)
        wakeup_pipe_readers(opipe);

    return ret;
}

dup2 和 tee 有點相像，但 dup2 只是創建新的 fd，指向相同的已開啟 file。
vmsplice 可將 pipe buffer 映射到 user space，除此之外沒什麼用。

madvice

建議 kernel 怎麼用這塊記憶體，幫助 kernel 採用不同做法提升效能。
平常用 mmap 僅是創造一個 logical address 映射關係，實際取用資料時，仍以 demand paging 處理。搭配 madvice，可告知 kernel 對記憶體的預處理操作。

  • MADV_RANDOM
    未來會隨機訪問任一 offset，所以 prefetch 沒什麼用，不建議 prefetch。
  • MADV_SEQUNTIAL
    照順序讀取資料，且每個 addr 最多讀一次，可 prefetch 提升效能。
  • MADV_WILLNEED
    很快就訪問到，可先 prefetch。
  • MADV_DONTNEED
    不再被訪問到，可被 swap。
  • MADV_DONTFORK
    child process 不繼承 parent 的記憶體，防止 copy-on-write。
    mmap 相關的 function 還有 mremap, munmap，僅單純重新 allocate 或 de-allocate 記憶體。

tty device

TTY 用於溝通程式與設備的 input/output。
假設執行一個 bash，它需要得到鍵盤輸入，並將結果輸出於螢幕，背後就是 tty driver 在支援。另外，也可將資料送給 bluetooth, usb port, ssh console 等。
假設要監聽鍵盤和滑鼠輸入，尋找相應的 device。
截圖 2025-02-26 下午1.58.32.png

這些 device 會送資料過來，user space 的程式就可開啟他，來做一些操作。
截圖 2025-02-26 下午1.59.15.png

截圖 2025-02-26 下午1.59.04.png

不過 /dev/input 顯示的是掃描碼，真實資料要看經 tty 處理過的資訊。
此實驗右側 console 使用 /dev/pts/1 處理輸入輸出。嘗試在左側監聽它，右側鍵盤輸入有機會被左邊搶走。
截圖 2025-02-26 下午2.37.14.png

也可以在左側輸入字元到右側。
截圖 2025-02-26 下午2.41.06.png

打開 ssh，電腦也創建一個 tty 處理遠端 input/output。
截圖 2025-02-26 下午2.31.42.png

運作

在 user space 使用某個 tty driver，背後先經過 tty core 定義的處理程序，才將訊息丟給開發者撰寫的 driver operations。
輸出會自動存在 buffer，經過 line discipline 轉換給 tty core，傳至 user space。其中 line discipline 行為、buffer 行為皆可設定。
tty读写过程中的函数调用流程-1598176659467.png

tty driver 共有 console, serial port, pty 三種類型。新的 tty driver 通常針對 serial port，console 和 pty 經過長時間開發，可滿足多數應用場景。
/proc/tty/drivers 可顯示 driver 資訊，包括 name, path, major number, minor number, type。
截圖 2025-02-25 下午4.50.06.png

開發的 tty driver 會在 /proc/tty/driver 創建 file，tty device 在 /sys/class/tty 皆有子目錄，包含 dev 檔案紀錄 major, minor number。

結構體

  • tty_driver
    管理整個 tty driver。 
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    struct tty_driver {
        struct kref kref;
        struct cdev cdevs;
        
        // 由哪個 kernel module 擁有，其值在 tty_alloc_driver() 自動設定
        struct module   *owner;
        
        // 用來識別 driver，driver 路徑在 /proc/tty/[driver_name]
        const char      *driver_name;
        // 用來產生 device name，device 路徑在 /dev/[name][index]
        const char      *name;
     
        int name_base;
        
        // device 的 major number，以及 minor number 從多少開始
        int major;
        int minor_start;
        
        unsigned int    num;
        short type;
        short subtype;
        
        struct ktermios init_termios;
        unsigned long   flags;
        struct proc_dir_entry *proc_entry;
        
        // 只用在 pty driver
        struct tty_driver *other;
        
        // user 互動時用到的 tty_struct
        struct tty_struct ttys;
        
        struct tty_port ports;
        
        struct ktermios termios;
        
        void *driver_state;
        
        // 定義對 tty 的操作，如 open, close, write
        const struct tty_operations *ops;
        
        // 所有 tty driver 被一個 list 串起來，tty_drivers 指向 list head
        struct list_head tty_drivers;
    };
  • tty_struct
    tty device 在 tty core 的內部表示。
    以 driver 角度，其結構會傳入 open, write 等函數中，表示一個 device 的 handle，它也用於存 tty 動態資訊。
    此結構暫時存在，open 時創建，close 時釋放。
  • tty_port
    tty device 某個 port 的資訊，如 buffer, lock 管理、對 port 的 operations、關閉時是否需要 delay。
  • tty line discipline
    用於對數據進行轉換，一般由 kernel 提供，例如 N_TTY 負責標準的終端行為，N_SLIP 用於網路介面。
  • termios
    對 input/output 的設定和轉換，例如 bitrate、將 \n 轉換為 \r\n、允許 Ctrl-C 產生 SIGINT。
    這些設定以 ktermios 結構儲存，driver 初始化也會設定 init_termios。
    在 user 程式，會調用 termios.h 來進行相關設定，driver 無需實作這部分。

創建一個 tty

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
static struct tty_operations tiny_serial_ops = {
    .open = tiny_open,
    .close = tiny_close,
    .write = tiny_write,
    .write_room = tiny_write_room,
    .set_termios = tiny_set_termios,
};

static int tiny_init(void)
{
    struct tty_driver *tiny_tty_driver;
    unsigned int i;

    tiny_tty_driver = alloc_tty_driver(TINY_TTY_MINORS);
    if (!tiny_tty_driver)
        return -ENOMEM;

    tiny_tty_driver->driver_name = "tiny_tty"; // /proc/tty/tiny_tty
    tiny_tty_driver->name        = "ttty";     // /dev/ttty[index]
    tiny_tty_driver->major       = TINY_MAJOR;
    tiny_tty_driver->minor_start = TINY_MINOR;
    tiny_tty_driver->type        = TTY_DRIVER_TYPE_SERIAL;
    tiny_tty_driver->subtype     = SERIAL_TYPE_NORMAL;
    tiny_tty_driver->init_termios    = tty_std_termios;
    tiny_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL;
    tiny_tty_driver->init_termios.c_ispeed = 9600;
    tiny_tty_driver->flags       = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
    tty_set_operations(tiny_tty_driver, &tty_serial_ops);

    // 設定好 driver 參數後註冊
    retval = tty_register_driver(tiny_tty_driver);
      if (retval) {
        put_tty_driver(tiny_tty_driver);
            return retval;        
    }
    
    // 註冊 device，無關聯實體設備
    for (i = 0; i < TINY_TTY_MINORS; i++) {
        tty_register_device(tiny_tty_driver, i, NULL);
    }
    // ...
}

void tiny_exit(void)
{
    struct tty_driver *tiny_tty_driver = get_tty_driver();
    unsigned int i;
    
    for (i = 0; i < TINY_TTY_MINORS; i++) {
        tty_unregister_device(tiny_tty_driver, i);
    }
    
    tty_unregister_driver(tiny_tty_driver);
}

tty->driver_data 存放和 user 溝通的 context，可自定義。
此範例放名為 tiny_serial 的結構。index 表示第幾個 device，若 tiny_table[index] == NULL，代表此 device 沒在用。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
static int tiny_open(struct tty_struct *tty, struct file *filp)
{
       struct tiny_serial *tiny;
    struct timer_list *timer;
    
    tty->driver_data = NULL;
    index = tty->index;
    tiny = tiny_table[index];
    if (tiny == NULL) {
        tiny = kmalloc(sizeof(*tiny), GFP_KERNEL);
        if (!tiny) {
            return -ENOMEM;
        }
        init_MUTEX(&tiny->sem);
        tiny->open_count = 0;
        tiny->timer = NULL;
        
        tiny_table[index] = tiny;
    }
    down(&tiny->sem);
    
    tty->driver_data = tiny;
    tiny->tty = tty;
    // ......    
}

struct tiny_serial {
    struct tty_struct *tty;
    int open_count;
    struct semaphore sem;
    struct timer_list *timer;
};

static void tiny_close(struct tty_struct *tty, struct file *filp)
{
    struct tiny_serial *tiny;
    
    tiny = tty->driver_data;
    if (!tiny) {
        return;        
    }
    down(&tiny->sem);
    if (!tiny->open_count) {
        goto exit;
    }
    tiny->open_count--;
    if (tiny->open_count <= 0) {
        del_timer(tiny->timer);
    }
exit:
    up(&tiny->sem);
    return;
}

tty driver 沒有實作 read()，因為 user 接收 tty core, discipline 的數據。

CTF 應用

基本上打開 /dev/ptmx 就能創建一個 tty_struct，用於洩漏 text, heap，或用 tty_struct->ops 劫持 rip。

shm

SysV

SysV 是 Unix System V 的簡稱，其 IPC 機制也被 Linux 相容，但不屬於 POSIX 標準。
key 是 SysV 中描述檔案的符號，有點像全局的 file descriptor，使 shmget 等函數基於此檔案操作。

  • shmget 在 key 所在的路徑創建 size 大小的 shared memory object
  • shmat attach 上某個 address，回傳 pointer 可供操作，shm 映射是這裡才建立的
  • shmdt 將 pointer 取消啟用，也就是對這個 pointer 操作不再影響 shm
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include <sys/shm.h>
#include <unistd.h>
#include <string.h>

int main(int argc, char argv)
{
    key_t key = ftok("/dev/shm/myshm", 0);
    int shm_id = shmget(key, 0x400000, IPC_CREAT | 0666);
    char *p = (char *) shmat(shm_id, NULL, 0);
    
    memset(p, 'A', 0x400000);
    shmdt(p);
    
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include <sys/shm.h>
#include <unistd.h>
#include <stdio.h>

int main(int argc, char argv)
{
    key_t key = ftok("/dev/shm/myshm", 0);
    int shm_id = shmget(key, 0x400000, 0666);
    char *p = (char *) shmat(shm_id, NULL, 0);
    
    printf("%c %c %c %c\n", p[0], p[1], p[2], p[3]);
    shmdt(p);
    
    return 0;
}

執行以上程式，發現多了一塊 shm 的區域，Mem shared 大小也增加。
截圖 2025-02-25 上午10.46.49.png

POSIX

ftruncate 可將檔案裁剪為指定大小。
shm_open 創建一個檔案在 /dev/shm 和 /run/shm，之後用 mmap 讓兩個 process 共享資料。
由於 /dev/shm 是一種 tmpfs，其內容可自動消失。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include <sys/mman.h>
#include <unistd.h>
#include <fcntl.h>       /* For O_* constants */
#include <string.h>

int main(int argc, char argv)
{
    int fd = shm_open("posixsm", O_CREAT | O_RDWR, 0666);
    ftruncate(fd, 0x400000);
    
    char *p = mmap(NULL, 0x400000,
                   PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
    memset(p, 'A', 0x400000);
    munmap(p, 0x400000);
    
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include <sys/mman.h>
#include <unistd.h>
#include <fcntl.h>       /* For O_* constants */
#include <stdlib.h>
#include <stdio.h>

int main(int argc, char argv)
{
    int fd = shm_open("posixsm", O_RDONLY, 0666);
    ftruncate(fd, 0x400000);
    
    char *p = mmap(NULL, 0x400000,
                   PROT_READ, MAP_SHARED, fd, 0);  
    printf("%c %c %c %c\n", p[0], p[1], p[2], p[3]);
    
    munmap(p, 0x400000);
    
    return 0;
}

CTF 應用

使用 shm 時，kernel 維護 shm_file_data 結構，其包含 ns, vm_ops 可洩漏 .text，file 可洩漏 direct mapping area。

1
2
3
4
5
6
struct shm_file_data {
    int id;
    struct ipc_namespace *ns;
    struct file *file;
    const struct vm_operations_struct *vm_ops;
};

shmat 創建此結構。

1
2
3
4
5
6
7
long do_shmat(int shmid, char __user *shmaddr, int shmflg,
          ulong *raddr, unsigned long shmlba)
{
    struct shm_file_data *sfd;

    sfd = kzalloc(sizeof(*sfd), GFP_KERNEL);
    file->private_data = sfd;

shmdt 呼叫時關閉相應文件，

1
2
3
4
5
6
7
8
9
10
static int shm_release(struct inode *ino, struct file *file)
{
    struct shm_file_data *sfd = shm_file_data(file);

    put_ipc_ns(sfd->ns);
    fput(sfd->file);
    shm_file_data(file) = NULL;
    kfree(sfd);
    return 0;
}

目前追不到呼叫 shm_release 的地方，尚未明白為何不能用 vm_ops 劫持 RIP。

保護機制

https://github.com/nccgroup/exploit_mitigations/blob/main/linux_mitigations.md

SMEP

禁止 kernel mode 執行 user memory 上面的 instruction。
此設定存在 cr4 register 第 21 位。

  • 檢查方式：cat /proc/cpuinfo | grep smep
  • qemu 設置：-cpu +smep
  • 繞過：修改 cr4, ROP

SMAP

禁止 kernel mode 不透過 copy_from_user, copy_to_user，就能存取 user memory 的內容。
若無 SMAP，可能造成以下攻擊方式：

  1. user 先 mmap 一塊記憶體存放 ROP gadget，利用 kernel 漏洞跳至 mov esp, 0xbbefffc3 ; ret 等類似指令，造成更方便的 ROP。
  2. 若 driver 直接使用 memcpy 複製 user memory 至內部，user 可傳入 kernel address，進一步洩漏 kernel 資訊。
  • 檢查方式：cat /proc/cpuinfo | grep smap
  • qemu 設置：-cpu +smap
  • 繞過：修改 cr4, ROP

KPTI

限制 user page table，使其缺少大部分 kernel address 的映射，用於防止 meltdown。
並且在 kernel mode 時 user memory 都標記 NX，避免 ret2usr。

  • 檢查方式：cat /sys/devices/system/cpu/vulnerabilities/meltdown
  • qemu 設置：-append pti=on
  • 繞過：
    • 跳至 swapgs_restore_regs_and_return_to_usermode 以回到 user mode 執行後續程式
    • 註冊 signal handler。
      當程式返回 user space 且 page table NX 尚未恢復，會觸發 SIGSEGV 跳至 signal handler，此時 signal handler 是可執行的。

KADR

限制 printk 打印的 kernel address。
設定由 /proc/sys/kernel/kptr_restrict 控制，1 代表擁有 CAP_SYSLOG 才能看 kernel address，2 代表全部不可見。
KADR 只限制 %p, %pK 打印的資訊，其他洩漏方式仍是可行的。

  • 檢查方式：cat /proc/sys/kernel/kptr_restrict
  • qemu 設置：echo 2 > /proc/sys/kernel/kptr_restrict
  • 繞過：需 leak kernel 上的位址，本地可關閉 KADR 方便 debug

KASLR

隨機決定 segment 起始位置，包括 text, data, stack 等。

  • 檢查方式：cat /proc/kallsyms 查看 codebase 是否有變
  • qemu 設置：-append kaslr
  • 繞過：透過 kernel 漏洞洩漏

FG-KASLR

在 KASLR 基礎上，隨機化各 function 的起始位置。也就是說，就算洩漏 text 段也不曉得 function 的確切位址。

  • 檢查方式：確認 boot config 開啟 CONFIG_FG_KASLR
  • 設置：編譯時開啟 -ffunction-sections 和 CONFIG_FG_KASLR=y
  • 繞過：
    • 部分函數仍存在 text 段，如 swapgs_restore_regs_and_return_to_usermode，且 data, heap 位址不受影響，照樣可利用。
    • function 內部相對位置固定，不受影響。

CONFIG_MEMCG_KMEM

在 slab allocator 中，許多 kernel 相關結構依照大小，由 kmalloc-x 的 cache 來分配，其中 x 與結構大小有關。
開啟 CONFIG_MEMCG_KMEM，且 malloc 時傳入 GFP_KERNEL_ACCOUNT，便會新增另一組 cache kmalloc-cg-x 以隔離重要內容。

  • 檢查方式：確認 boot config 開啟 CONFIG_MEMCG_KMEM
  • 設置：CONFIG_MEMCG_KMEM=y
  • 繞過：
    • 漏洞使用的原 cache 仍有可利用的結構，例如 msg_msg, pipe_buffer, sk_buff
    • 利用跨 cache 攻擊

SLAB_ACCOUNT

若 kmem_cache_create 傳入此 flag，就會創建獨立的 cache，像 cred, task_struct, mm_struct 就是用此方式分配。

  • 繞過：跨 cache 攻擊

CONFIG_SLAB_FREELIST_RANDOM

slab allocator 向 buddy system 申請記憶體時，打亂 object 在 freelist 的順序，然而，運行中仍遵循 LIFO。

  • 檢查方式：確認 boot config 開啟 CONFIG_SLAB_FREELIST_RANDOM
  • qemu 設置：CONFIG_SLAB_FREELIST_RANDOM=y
  • 繞過：利用分配過程的順序攻擊，也可跨 cache 攻擊
    freelist_random.png

CONFIG_SLAB_FREELIST_HARDENED

類似 glibc 2.32 引入的 safe-linking。
object->next 會指向當前 object、下一 object、kmem_cache 指定的 random 值做 xor。

  • 檢查方式：確認 boot config 開啟 CONFIG_SLAB_FREELIST_HARDENED
  • 設置：CONFIG_SLAB_FREELIST_HARDENED=y
  • 繞過：或許可參考 how2heap 針對 safe-linking 的處理

CONFIG_HARDENED_USERCOPY

copy_from_user, copy_to_user 時，檢查長度是否超過 kernel object 的範圍。

  • 繞過：或許可參考 how2heap 針對 safe-linking 的處理

CONFIG_INIT_ON_ALLOC_DEFAULT_ON

buddy system 和 slab 分配時，皆清空 object 內容。

CONFIG_LIST_HARDENED

從 list 移除 entry 時，檢查 entry->next->prev == entry == entry->prev->next。

  • 繞過：控制更多 entry，修改目標的 prev, next entry 資料

CONFIG_STATIC_USERMODEHELPER

關閉一些讓攻擊變得更方便的目標，如 modprobe, coredump。

CONFIG_RANDOM_KMALLOC_CACHES

對每個 size 創建 16 個 slab cache，使得 heap spray 成功率下降。

  • 繞過：spray 更多 object 提升成功率

參考資料