Reverse Engineering - Assembly & Introduction

REVERSE-
ASSEMBLY &
INTRODUCTION
TA LESSON @ 108-1
INFORMATION SECURITY

WHO AM I
WHO AM I
▸ 陳靖汯 a.k.a Redhung
▸ 國立中正⼤大學資管系
▸ redhung@hung.red
▸ 興趣：CTF、逆向
▸ 配偶：橋本環奈

序⾔
序⾔
▸ 在開始前 ... 說說為何我們需要學習組合語⾔言？
▸ 組合語⾔言是最接近底層的語⾔言
▸ 藉由學習組合語⾔言可以更更了了解電腦核⼼心運作的⽅方式
▸ 學習組合語⾔言也是希望⾃自⼰己能看懂反組譯出來來的程式碼，
對於逆向⼯工程有興趣的同學是不可或缺的技能

指令集 CPU架構組合語⾔言 STACK FRAME 逆向⼯工程

指令集
RISC
▸ 精簡指令集（Reduced Instruction Set Computing）
▸ 指令系統簡單、精簡
▸ 指令數⽬目⼩小於100條
▸ ARM架構使⽤用RISC指令集

指令集
CISC
▸ 複雜指令集（Complex Instruction Set Computing）
▸ 指令系統複雜、龐⼤大
▸ 指令數⽬目⼤大於200條
▸ X86架構使⽤用CISC指令集

CPU架構
ARM
▸ 最早為Acorn公司所開始發展
▸ 功能相對X86較為簡單
▸ 耗電量量明顯更更低
▸ 因此設計路路線與X86為不同⽅方向
▸ ARM專注於低成本、低耗能的研發⽅方向

CPU架構
X86
▸ 最早為Intel公司發展出的「Intel8086」CPU
▸ 其後系列列CPU結尾皆為86，因此其架構被稱為X86
▸ 功能相較ARM較為強⼤大
▸ X86專注於效能、速度的開發
▸ 普遍PC都是使⽤用Intel的CPU
▸ 因此CTF與實戰上通常遇到的都是X86架構

X86架構－組合語⾔
組合語⾔
▸ Assembly language（Assembly code）為低階語⾔言
▸ Human readable，易易讀
▸ Machine code <——> Assembly code
▸ Assembler：ASM —> 01
▸ Disassembler：01 —> ASM
▸ CPU指令：mov, add, sub, push, pop, etc.
▸ X64 assembly、X86 assembly

記憶體
▸ 記憶體是可供 CPU 存取操作具有保存訊息功能的設備，CPU 要
和記憶體溝通必須透過三類的訊息交換
▸ 1. 地址訊息: 欲讀取或寫入的地址
▸ 2. 控制訊息: 對記憶體的操作(讀取或寫入)
▸ 3. 數據訊息: 讀取或寫入的資料
▸ CPU 想要將資料寫入記憶體，必需先知道記憶體的地址，接著告
訴記憶體要進⾏行行寫入的操作，最後把資料送過去，以上為 CPU
對記憶體操作的⼤大致流程

暫存器 REGISTER
▸ ⼀一般暫存器：
▸ RAX, RBX, RCX, RDX —> 64bits
▸ EAX, EBX, ECX, EDX —> 32bits
▸ AX, BX, CX, DX —> 16bits
▸ AX, BX, CX, DX 底下還有 H, L
▸ AX —> AH, AL —> 8bits
RAX EAX
AX
AH AL

暫存器 REGISTER
▸ 索引暫存器：
▸ RSI, RDI —> 64bits
▸ ESI, EDI —> 32bits
▸ SI, DI —> 16bits
▸ RSI：來來源索引暫存器
▸ RDI：⽬目的索引暫存器
RSI ESI SI

暫存器 REGISTER
▸ RSP, ESP
▸ 指向堆疊（Stack）的最頂端
▸ RBP, EBP
▸ 指向堆疊（Stack）的最尾端
▸ RSP, ESP
▸ 指向程式當前執⾏行行的位址
FUNCTION()
ARGUMENT
RETURN ADDRESS
SAVED RBP
RSP
RBP
High address
Low address

X64 ASSEMBLY
▸ mov
▸ add, sub
▸ and, or, xor
▸ push, pop
▸ call, jmp
▸ leave, ret

MOV
▸ mov ⽬目的, 來來源
▸ 將來來源資料複製到⽬目的
▸ mov rax, 5 —> rax = 5
▸ mov rax, rbx —> rax = rbx 的值
▸ mov [rax], 0x123 —> 將0x123儲存⾄至rax指向的內容地址

ADD, SUB
▸ add ⽬目的, 來來源
▸ add rax, rbx —> rax = rax + rbx
▸ sub ⽬目的, 來來源
▸ sub rax, rbx —> rax = rax - rbx

AND, OR, XOR
▸ and ⽬目的, 來來源
▸ and rax, rbx —> rax = rax & rbx
▸ or ⽬目的, 來來源
▸ or rax, rbx —> rax = rax | rbx
▸ xor ⽬目的, 來來源
▸ xor rax, rbx —> rax = rax ^ rbx

CALL, JMP
▸ jmp 地址
▸ 跳⾄至程式某⼀一地址執⾏行行
▸ call 地址
▸ 先儲存執⾏行行完function後要回來來的下⼀一⾏行行程式碼的地址
▸ 呼叫指定地址的function

LEAVE, RET
▸ leave
▸ 還原上⼀一層Stack frame
▸ mov rsp, rbp
▸ pop rbp
▸ ret
▸ funtion結束後返回
▸ ret = pop rip

堆疊 STACK
▸ Data structure
▸ Memory section
▸ LIFO（Last In First Out）
▸ Stack由⾼高地址往低地址⽣生長

PUSH, POP
▸ push 來來源
▸ 將來來源資料放入堆疊記憶體
▸ push rax = sub rsp, 8; mov [rsp], rax
▸ pop ⽬目的
▸ 從堆疊記憶體取出資料放入⽬目的
▸ pop rax = mov rax, [rsp]; add rsp, 8
High address
Low address

STACK FRAME
STACK FRAME
▸ stack 是由⼀一些邏輯的 stack frame 所組成，當呼叫⼀一個
function 就會 push stack frame，當執⾏行行結果回傳後就 pop
▸ ⼀一個 stack frame 包含了了：
▸ 1. ⼀一個 function 的參參數
▸ 2. 他的 local 的變數
▸ 3. 復原前⼀一個 stack frame 所需要的資料
▸ 4. 當 function call 的時候那些 instruction pointers 的值

STACK FRAME
STACK FRAME 運作⽅式 - PART 1
▸ Function parameters
▸ 假設今天呼叫了了⼀一個 foo( a, b, c )，會呈現為：
▸ Push a
▸ Push b
▸ Push c
▸ Call foo

STACK FRAME
▸ Stackframe back pointer
▸ 現在我們已經要開始執⾏行行foo了了，如果想存取變數的話：
▸ [esp + 0] - return address
▸ [esp + 4] - parameter 'a'
▸ [esp + 8] - parameter 'b'
▸ [esp + 12] - parameter 'c'
▸ 但我們現在的RBP, RSP還沒指向foo的stack frame，因此我們必須先儲存當前stack frame的
RBP，再將RBP指過去
▸ push rbp ; 儲存舊的RBP
▸ mov rbp, rsp ; rbp = rsp

STACK FRAME
▸ Carving space for local variables
▸ Local variable也存放在stack，由於stack是從⾼高地址往低地
址⽣生長，因此我們sub rsp來來決定需要多少空間
▸ sub rsp, n_bytes ; n_bytes = local variables需要的空間

STACK FRAME
▸ Stackframe cleanup
▸ 當我們執⾏行行完foo時，foo的stack frame必須正確清除
▸ mov rsp, rbp ; 將Local variables的空間還原
▸ pop rbp ; 將當前的stack frame pop掉
▸ ret ; 返回
▸ // 有時也會看到leave
▸ // leave = mov rsp, rbp ; pop rbp

int foo(int a, int b, int c)
{
int i, j;
…
return 1;
}
int main()
{
foo(1, 2, 3);
return 0;
}
Compiler
foo:
push rbp
mov rbp, rsp
sub rsp, 0xF
…
mov rsp, rbp
pop rbp
ret
main:
push rbp
mov rbp, rsp
mov rdi, 0x1
mov rsi, 0x2
mov rdx, 0x3
call foo
mov rax, 0
leave
ret

foo:
push rbp
mov rbp, rsp
sub rsp, 0xF
…
mov rsp, rbp
pop rbp
ret
main:
push rbp
mov rbp, rsp
mov rdi, 0x1
mov rsi, 0x2
mov rdx, 0x3
call foo
mov rax, 0 // address = 0x5321aa
leave
ret
STACK FRAME OF MAIN
High address
Low address
RSP
RBP

foo:
push rbp
mov rbp, rsp
sub rsp, 0xF
…
mov rsp, rbp
pop rbp
ret
main:
push rbp
mov rbp, rsp
mov rdi, 0x1
mov rsi, 0x2
mov rdx, 0x3
call foo
leave
ret
STACK FRAME OF MAIN
High address
Low address
RSP
RBP
RIP

foo:
push rbp
mov rbp, rsp
sub rsp, 0xF
…
mov rsp, rbp
pop rbp
ret
main:
push rbp
mov rbp, rsp
mov rdi, 0x1
mov rsi, 0x2
mov rdx, 0x3
call foo
leave
ret
STACK FRAME OF MAIN
High address
Low address
RSP
RBP
call foo = push next_rip
jmp foo

foo:
push rbp
mov rbp, rsp
sub rsp, 0xF
…
mov rsp, rbp
pop rbp
ret
main:
push rbp
mov rbp, rsp
mov rdi, 0x1
mov rsi, 0x2
mov rdx, 0x3
call foo
leave
ret
STACK FRAME OF MAIN
High address
Low address
RSP
RBP
jmp foo
RETURN ADDRESS

foo:
push rbp
mov rbp, rsp
sub rsp, 0xF
…
mov rsp, rbp
pop rbp
ret
main:
push rbp
mov rbp, rsp
mov rdi, 0x1
mov rsi, 0x2
mov rdx, 0x3
call foo
leave
ret
STACK FRAME OF MAIN
High address
Low address
RSP
RBP
jmp foo
0X5321AA

foo:
push rbp
mov rbp, rsp
sub rsp, 0xF
…
mov rsp, rbp
pop rbp
ret
main:
push rbp
mov rbp, rsp
mov rdi, 0x1
mov rsi, 0x2
mov rdx, 0x3
call foo
leave
ret
STACK FRAME OF MAIN
High address
Low address
RSP
RBP
0X5321AA
RIP

foo:
push rbp
mov rbp, rsp
sub rsp, 0xF
…
mov rsp, rbp
pop rbp
ret
main:
push rbp
mov rbp, rsp
mov rdi, 0x1
mov rsi, 0x2
mov rdx, 0x3
call foo
leave
ret
STACK FRAME OF MAIN
High address
Low address
RSP
RBP
0X5321AA
RIP
SAVED RBP

foo:
push rbp
mov rbp, rsp
sub rsp, 0xF
…
mov rsp, rbp
pop rbp
ret
main:
push rbp
mov rbp, rsp
mov rdi, 0x1
mov rsi, 0x2
mov rdx, 0x3
call foo
leave
ret
STACK FRAME OF MAIN
High address
Low address
RSPRBP
0X5321AA
RIP
SAVED RBP

foo:
push rbp
mov rbp, rsp
sub rsp, 0xF
…
mov rsp, rbp
pop rbp
ret
main:
push rbp
mov rbp, rsp
mov rdi, 0x1
mov rsi, 0x2
mov rdx, 0x3
call foo
leave
ret
STACK FRAME OF MAIN
High address
Low address
RSP
RBP
0X5321AA
RIP
SAVED RBP
LOCAL VARIABLES OF FOO
Stackframe
of
foo

foo:
push rbp
mov rbp, rsp
sub rsp, 0xF
…
mov rsp, rbp
pop rbp
ret
main:
push rbp
mov rbp, rsp
mov rdi, 0x1
mov rsi, 0x2
mov rdx, 0x3
call foo
leave
ret
STACK FRAME OF MAIN
High address
Low address
RSP RBP
0X5321AA
RIP
SAVED RBP

foo:
push rbp
mov rbp, rsp
sub rsp, 0xF
…
mov rsp, rbp
pop rbp
ret
main:
push rbp
mov rbp, rsp
mov rdi, 0x1
mov rsi, 0x2
mov rdx, 0x3
call foo
leave
ret
STACK FRAME OF MAIN
High address
Low address
RSP
RBP
0X5321AA
RIP
SAVED RBP

逆向⼯程
逆向⼯程
▸ Reverse Engineering
▸ 逆向分析程式、軟體、韌體
▸ 找出能夠利利⽤用的漏洞洞（Pwn）
▸ 程式碼加密保護
▸ 程式碼混淆

逆向⼯程
分析程式
▸ 靜態分析
▸ strings
▸ strace、ltrace
▸ objdump
▸ 動態分析
▸ 使⽤用debugger追蹤除錯
▸ e.g. gdb

逆向⼯程
靜態分析
▸ $ strings <file>
▸ 印出檔案中的可視字元
▸ $ objdump -d <file>
▸ 反組譯檔案，查看組合語⾔言
▸ $ grep <pattern>
▸ 尋找含有pattern的內容
▸ 通常可以和strings⼀一起使⽤用
▸ $ strings <file> | grep “flag”

逆向⼯程
靜態分析
▸ $ strace <ﬁle>
▸ 查看檔案的system call
▸ $ ltrace <ﬁle>
▸ 查看檔案呼叫的library

逆向⼯程
動態分析
▸ 使⽤用gdb動態追蹤程式脈絡
▸ b main
▸ 將中斷點設在main
▸ run
▸ 開始執⾏行行程式
▸ x/30wx $rsp
▸ 從rsp開始以hex形式往下dump出30個stack內存

逆向⼯程
練習時間
▸ ⾃自⾏行行撰寫出reverse.c，程式可讓使⽤用者輸入字串串內容
▸ 使⽤用靜態分析⼯工具來來分析程式
▸ 使⽤用gdb追蹤程式流程，學會觀察內存改變

Reverse Engineering - Assembly & Introduction

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Similar to Reverse Engineering - Assembly & Introduction

Similar to Reverse Engineering - Assembly & Introduction (13)

More from Redhung @ Nationtal Chung Cheng University, Chiayi, Taiwan.

More from Redhung @ Nationtal Chung Cheng University, Chiayi, Taiwan. (18)

Reverse Engineering - Assembly & Introduction