关于课程计划

 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

#![no_std]
#![no_main]

use core::arch::asm;
use core::panic::PanicInfo;

#[allow(unused)]
#[allow(unused_mut)]
#[allow(unreachable_code)]
#[no_mangle]
pub extern "C" fn main() {
    let brk_start: usize;

    unsafe {
        // brk 是指向用户堆的指针。我们使用brk是扩大堆的大小，也就是分配内存。
        // 但是我们需要知道堆的起始位置，所以我们需要先获取当前的brk值。
        asm!(
            "mov rax, 12",  // sys_brk system call number on x86_64
            "mov rdi, 0",   // brk(0) to get the current brk value
            "syscall",
            out("rax") brk_start,
            options(nostack)
        );

        let mut new_brk: usize = brk_start + 1024; // 分配 1024 字节内存

        let brk_ret: isize; // 系统调用返回值

        // 调用 brk 系统调用进行内存分配
        asm!(
            "mov rax, 12",  // sys_brk system call number on x86_64
            "syscall",
            in("rdi") new_brk,
            out("rax") brk_ret,
            options(nostack)
        );

        if brk_ret == -1 {
            new_brk = brk_start; // 分配失败，恢复原来的 brk
            panic!("brk failed");
        }

        let mut ptr = brk_start as *mut u8;
        ptr.write_volatile(42); // 访问 brk 的第一个字节

        print("brk success\n");

        for i in 0..4099 {
            unsafe {
                ptr.add(i).write_volatile(42); // 访问超出分配的内存
                // 你应该一定会看到4096行的write success。一行不多，一行不少。
                print("write success\n");
            }
        }
    }
}

#[no_mangle]
pub extern "C" fn __libc_start_main() -> ! {
    main();

    print("main returned\n");

    exit(0);
}

pub fn print(s: &str) {
    let ptr = s.as_ptr();
    let count = s.len();
    unsafe {
        asm!("syscall",
            in("rax") 1, // sys_write system call number on x86_64
            in("rdi") 1, // file descriptor 1 is stdout
            in("rsi") ptr, // pointer to the buffer
            in("rdx") count, // buffer size
        )
    }
}

fn exit(code: i32) -> ! {
    unsafe {
        // 退出程序
        asm!("syscall",
            in("rax") 60, // sys_exit system call number on x86_64
            in("rdi") code, // exit code;
            options(noreturn, nostack)
        )
    }
}

#[panic_handler]
fn panic(_info: &PanicInfo) -> ! {
    print("panicked!\n");
    exit(1);
}

1

cargo +nightly run -Z build-std=core --target x86_64-unknown-linux-gnu

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

int main() {
    foo();
}

int foo() {
    // 在这里修改栈，使得代码不回到 main，而是回到 bar
}

int bar() {
    // Some dangerous code that can be exploited
}

1
2

push <ADDRESS_OF_NEXT_INSTRUCTION> ' 需要注意的是<ADDRESS_OF_NEXT_INSTRUCTION>由编译器硬编码嵌入到指令中，所以我们无法直接获取到这个地址
jmp <TARGET_ADDRESS>

1
2

pop t0 ' 将<ADDRESS_OF_NEXT_INSTRUCTION>弹出到t0
jmp t0 ' 跳转到t0

1
2
3
4
5
6
7

+-------------------+  --+ <- rbp
|                   |    |
|                   |    |
|                   |    +--- main 的栈帧
|                   |    |
|                   |    |
+-------------------+  --+ <- rsp

1
2
3
4
5
6
7
8
9

+-------------------+  --+ <- rbp, BASE POINTER，也就是序幕代码中的 rsp 或者 riscv 中的 sp
|                   |    |
|                   |    |
|                   |    +--- main 的栈帧
|                   |    |
|                   |    |
+-------------------+  --+  <- rsp
|   RETURN ADDRESS  |  
+-------------------+

1
2

push rbp
mov rbp, rsp

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

+-------------------+  --+
|                   |    |
|                   |    |
|                   |    +--- main 的栈帧
|                   |    |
|                   |    |
+-------------------+  --+
|   RETURN ADDRESS  |  
+-------------------+
|     SAVED RBP     |
+-------------------+  <- 新的 rbp, 这里我们不关注 rsp，因为 rsp 是动态的
|                   |
|                   |  <--- foo 的栈帧
|                   |
|                   | 

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

+-------------------+  --+
|                   |    |
|                   |    |
|                   |    +--- main 的栈帧
|                   |    |
|                   |    |
+-------------------+  --+
|   RETURN ADDRESS  |  
+-------------------+
|     SAVED RBP     |
+-------------------+  <- 新的 rbp, 这里我们不关注 rsp，因为 rsp 是动态的
|                   |
|                   |  <--- foo 的栈帧
|                   |
|                   | 

 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

foo:
; 函数序幕
PUSH BP                ; 保存基指针
MOV BP, SP             ; 初始化基指针

PUSH t0
PUSH t1
PUSH t2
PUSH t3
PUSH t4

; int a = 42;
MOV t0, 42             ; 将值 42 存入 t0 寄存器
PUSH t0                ; 将 t0 的值压入栈，栈顶即为变量 a 的地址

; int* ptrA = &a;
LEA t1, [BP-8]         ; 获取变量 a 的地址，存入 t1
PUSH t1                ; 将 t1 的值压入栈，栈顶即为变量 ptrA 的地址

; Object* obj = new Object();
HEAP_ALLOC t3, 32      ; 分配 32 字节的堆空间，存入 t3
MOV [t3], <Program.exe+Object::GetHashCode> ; 初始化 vtable 的第一个函数地址
MOV [t3+8], <Program.exe+Object::ToString>  ; 初始化 vtable 的第二个函数地址
MOV [t3+16], <Program.exe+Object::Equals>   ; 初始化 vtable 的第三个函数地址
PUSH t3                ; 将堆地址压入栈，栈顶即为变量 obj 的地址

; char* str = "Hello";
MOV_STR t0, <Program.exe+offset_of_Hello> ; 假设字符串 "Hello" 的偏移地址
PUSH t0                                   ; 将 t0 的值压入栈，栈顶即为变量 str 的地址

; StructType value = StructType {1, 2, 3};
MOV t0, 1              ; 将值 1 存入 t0 寄存器
PUSH t0                ; 将 t0 的值压入栈，初始化 field1
MOV t0, 2              ; 将值 2 存入 t0 寄存器
PUSH t0                ; 将 t0 的值压入栈，初始化 field2
MOV t0, 3              ; 将值 3 存入 t0 寄存器
PUSH t0                ; 将 t0 的值压入栈，初始化 field3

; 你也可以使用静态SP的方式
; SUB SP, 12            ; 为结构体 value 分配 12 字节的栈空间
; MOV [SP-4], 1
; MOV [SP-8], 2
; MOV [SP-12], 3

; StructType* pValue = (StructType*)malloc(sizeof(StructType));
HEAP_ALLOC t3, 12      ; 分配 12 字节的堆空间，存入 t3
MOV [t3], 1            ; 初始化堆上的 field1
MOV [t3+4], 2          ; 初始化堆上的 field2
MOV [t3+8], 3          ; 初始化堆上的 field3
PUSH t3                ; 将堆地址压入栈，栈顶即为变量 pValue 的地址

; std::vector<int> vec = {1, 2, 3};
PUSH 3                 ; 将 3 压入栈，初始化 vector 的大小
PUSH 3                 ; 将 3 压入栈，初始化 vector 的容量
HEAP_ALLOC t3, 12      ; 分配 12 字节的堆空间，存入 t3
MOV [t3], 1            ; 初始化堆上的第一个元素
MOV [t3+4], 2          ; 初始化堆上的第二个元素
MOV [t3+8], 3          ; 初始化堆上的第三个元素
PUSH t3                ; 将堆地址压入栈，栈顶即为变量 vec 的地址

; std::vector<int>* pVec = new std::vector<int>({1, 2, 3});
HEAP_ALLOC t3, 12      ; 分配 12 字节的堆空间，存入 t3
MOV [t3], 1            ; 初始化堆上的第一个元素
MOV [t3+4], 2          ; 初始化堆上的第二个元素
MOV [t3+8], 3          ; 初始化堆上的第三个元素
HEAP_ALLOC t4, 24      ; 分配 24 字节的堆空间，存入 t4
MOV [t4], 3            ; 初始化堆上的大小
MOV [t4+4], 3          ; 初始化堆上的容量
MOV [t4+8], t3         ; 初始化堆上的指针
PUSH t4                ; 将堆地址压入栈，栈顶即为变量 pVec 的地址

; int array[512];
SUB SP, 2048           ; 为数组 array 分配 512 * 4 字节的栈空间
LEA t2, [BP-2056]      ; 获取数组 array 的基址，存入 t2
; 我决定将这个数组放在最后，因为这样其他局部变量的偏移就会比较小

; 清理局部变量
ADD SP, 2048           ; 清理数组 array 的栈空间
POP                    ; 清理 pVec
ADD SP, 12             ; 清理 vec
ADD SP, 8              ; 清理 pValue
ADD SP, 12             ; 清理 value
ADD SP, 8              ; 清理 str
ADD SP, 8              ; 清理 obj
ADD SP, 8              ; 清理 ptrA
ADD SP, 4              ; 清理 a

; 恢复临时寄存器
POP t4
POP t3
POP t2
POP t1
POP t0

; 函数尾声
POP BP                 ; 恢复基指针

RET