[Reversing] 3주차 어셈블리 → C 코드 example 1 ~ 5

* 기본 해석

 

.file "example1.c"

 : 디버거에서 사용하는 원본 파일 이름을 가리킴

 

□ Intel 문법이 아니기 때문에 오른쪽 값을 왼쪽으로 넣는다 !!

.section .rodata

 : ./rodata 섹션 정의, 이 섹션은 읽기 전용 데이터 변수

.text

 : text section → 코드들을 정한 섹션 / 프로그램 코드 실행할 때 사용

.global main

 : 전체 코드에 걸쳐 접근 가능한 함수

.type main, @function

: main 함수 정의 → 이걸 해야만 global main 코드를 얻을 수 있다

.LBF0

 : 함수의 시작을 의미하는 'local label'

.cfi_startproc

: 'call from information'

어셈블러에게 dwarf format 디버깅 information을 지시

.cfi_endproc

: 함수 끝

.size main, .-main

: size 인스트럭션은 메인 함수의 크기를 세팅함

* .-main 은 오브젝트 파일에 쓰여질 main함수의 정확한 크기를 가지고 있음

.ident "GCC: (Ubuntu 4.8.4-2ubuntu1~14.04.1)4.8.4"

 : indent 인스트럭션은 어떤 컴파일러를 사용해서 컴파일하고 실행하였는지에 대한 정보 문자열 "GCC: (Ubuntu 4.8.4-2ubuntu1~14.04.1)4.8.4"을 오브젝트 파일에 저장하기 위한 instruction

(ex) Hello World 프로그램 : 오브젝트 파일)

 

 

---

# example1.asm

# example1.asm
.file	"example1.c"
.section	.rodata
.LC0:
	.string	"Hello world"
	.text
	.globl	main
	.type	main, @function
main:
	.LFB0:
	.cfi_startproc
	pushq	%rbp
	.cfi_def_cfa_offset 16
	.cfi_offset 6, -16
	movq	%rsp, %rbp
	.cfi_def_cfa_register 6
	movl	$.LC0, %edi
	movl	$0, %eax
	call	printf
	movl	$0, %eax
	popq	%rbp
	.cfi_def_cfa 7, 8
	ret
	.cfi_endproc
.LFE0:
	.size	main, .-main
	.ident	"GCC: (Ubuntu 4.8.4-2ubuntu1~14.04.1) 4.8.4"
	.section	.note.GNU-stack,"",@progbits

 

 

 

해석할 main함수 부분은 다음과 같다.

main:
	pushq	%rbp
	movq	%rsp, %rbp
	movl	$.LC0, %edi
	movl	$0, %eax
	call	printf
	movl	$0, %eax
	popq	%rbp
	ret

push1 %rbp → rbp 스택에 새 피연산자를 저장하고, rsp의 값을 8 줄인다.

movq %rsp, %rbp → rbp의 값을 rsp에 넣는다.

movl $.LC0. %edi → printf의 첫 번째 인자로 LC0에 저장된 문자를 저장

movl $0, %eax → eax에 0저장

call printf → printf 함수 호출

movl $0, %eax → eax에 0저장

popq %rbp → rbp 꺼냄

ret → return address 주소로 리턴

 

 

이를 바탕으로 작성한 C코드는 다음과 같다.

#include <stdio.h>

int main() {
	printf("Hello World");
	return 0;
}

 

 

디스어셈블 코드이므로 오른쪽 값을 왼쪽으로 넣는다고 보면 된다.

디스어셈블 코드라는 걸 고려하면 앞에서 봤던 어셈블리 코드와 동일한 걸 확인할 수 있다.

 

*objdump -d를 써서 어셈블리 코드를 확인하고 싶었으나 자꾸 오류가 떴다...

 

 

 

---

 

# example2.asm

# example2.asm
.file	"example2.c"
.section	.rodata
.LC0:
	.string	"result : %d \n"
	.text
	.globl	main
	.type	main, @function
main:
	.LFB0:
	.cfi_startproc
	pushq	%rbp
	.cfi_def_cfa_offset 16
	.cfi_offset 6, -16
	movq	%rsp, %rbp
	.cfi_def_cfa_register 6
	subq	$16, %rsp 
	movl	$10, -12(%rbp)
	movl	$20, -8(%rbp)
	movl	-8(%rbp), %eax
	movl	-12(%rbp), %edx
	addl	%edx, %eax
	movl	%eax, -4(%rbp)
	movl	-8(%rbp), %eax
	movl	-12(%rbp), %edx
	addl	%edx, %eax  
	movl	%eax, %esi
	movl	$.LC0, %edi
	movl	$0, %eax
	call	printf
	movl	$0, %eax
	leave
	.cfi_def_cfa 7, 8
	ret
	.cfi_endproc
.LFE0:
	.size	main, .-main
	.ident	"GCC: (Ubuntu 4.8.4-2ubuntu1~14.04.1) 4.8.4"
	.section	.note.GNU-stack,"",@progbits

 

해석할 main함수 부분은 다음과 같다.

main:
	pushq	%rbp
	movq	%rsp, %rbp
	subq	$16, %rsp 
	movl	$10, -12(%rbp)
	movl	$20, -8(%rbp)
	movl	-8(%rbp), %eax
	movl	-12(%rbp), %edx
	addl	%edx, %eax
	movl	%eax, -4(%rbp)
	movl	-8(%rbp), %eax
	movl	-12(%rbp), %edx
	addl	%edx, %eax  
	movl	%eax, %esi
	movl	$.LC0, %edi
	movl	$0, %eax
	call	printf
	movl	$0, %eax
	leave
	ret

• push1 %rbp → 함수 프롤로그
• movq %rsp, %rbp → rsp의 값을 rbp에 넣는다
• subq $16, %rsp → 스택 포인터 rsp를 0x10(16byte)만큼 공간 확보
• movl $10, -12(%rbp) → 10을 rbp 레지스터의 -12만큼의 주소(offset)에 저장  
  •  12byte 만큼의 임시 공간을 할당해서 숫자 10을 스택에 넣는 것! (다음 연산 준비)
• movl $20, -8(%rbp) → 20을 rbp 레지스터의 rbp-0x8에 저장
• movl -8(%rbp), %eax → eax레지스터에 20 저장 
  •  rbp로부터 8byte 아래의 공간에 저장되어 있는 값(여기선 20)을 eax 레지스터에 저장
• movl -12(%rbp), %ed rbp로부터 12byte 아래의 공간에 저장되어 있는 값(10)을 edx에 저장
• addl %edx, %eax → edx 레지스터에 있는 값(10)과 eax 레지스터에 있는 값(20) 더해서 eax에 저장
• movl %eax, -4(%rbp) → eax(30)를 rbp-0x4에 저장
• movl -8(%rbp), %eax → eax레지스터에 20 저장
• movl -12(%rbp), %edx → edx에 10저장
• addl %edx, %eax  → 10 + 20(30)을 eax에 저장
• movl %eax, %esi → esi에 30 저장
• movl $.LC0, %edi → printf의 첫 번째 인자 값을 LC0주소의 스트링으로 가져와서 edi에 저장
• movl $0, %eax → eax를 0으로 초기화
• call printf → printf 함수 호출
• movl $0, %eax → eax(리턴값)를 0으로 초기화
• leave → 함수 에필로그
• ret → return address 주소로 리턴

 

이를 기반으로 작성한 c코드는 다음과 같다.

#include <stdio.h>

int main(){
	int a, b, c;
	a = 10;
	b = 20;
	c = a + b;
    
	printf("%d\n", a + b);
	return 0;
}

 

위의 코드를 디스어셈블하니 어셈블한 코드와 반대로 맞아떨어졌다.

 

 

 

---

 

 

# example3

# example3.asm
.file	"example3.c"
.section	.rodata
.LC0:
	.string	"a is 10"
.LC1:
	.string	"b is 10"
.LC2:
	.string	"b is 20"
.LC3:
	.string	"a=b"
.LC4:
	.string	"a!=b"
.text
.globl	main
.type	main, @function
main:
	.LFB0:
	.cfi_startproc
	pushq	%rbp
	.cfi_def_cfa_offset 16
	.cfi_offset 6, -16
	movq	%rsp, %rbp
	.cfi_def_cfa_register 6
	subq	$16, %rsp
	movl	$10, -8(%rbp)
	movl	$20, -4(%rbp)
	cmpl	$10, -8(%rbp)
	jne	.L2
	movl	$.LC0, %edi
	call	puts
	.L2:
	cmpl	$10, -4(%rbp)
	jne	.L3
	movl	$.LC1, %edi
	call	puts
	jmp	.L4
	.L3:
	cmpl	$20, -4(%rbp)
	jne	.L4
	movl	$.LC2, %edi
	call	puts
	.L4:
	movl	-8(%rbp), %eax
	cmpl	-4(%rbp), %eax
	jne	.L5
	movl	$.LC3, %edi
	call	puts
	jmp	.L6
	.L5:
	movl	$.LC4, %edi
	call	puts
	.L6:
	movl	$0, %eax
	leave
	.cfi_def_cfa 7, 8
	ret
	.cfi_endproc
.LFE0:
	.size	main, .-main
	.ident	"GCC: (Ubuntu 4.8.4-2ubuntu1~14.04.1) 4.8.4"
	.section	.note.GNU-stack,"",@progbits

 

main 이전을 먼저 살펴보자.

.LC0:
	.string	"a is 10"
.LC1:
	.string	"b is 10"
.LC2:
	.string	"b is 20"
.LC3:
	.string	"a=b"
.LC4:
	.string	"a!=b"

다음과 같이 LC0, LC1, LC2, LC3, LC4에 각각 문자열을 할당해주었다.

 

 

이제 main함수의 어셈블리 코드를 살펴보자.

main:
	pushq	%rbp
	movq	%rsp, %rbp
	subq	$16, %rsp
	movl	$10, -8(%rbp)
	movl	$20, -4(%rbp)
	cmpl	$10, -8(%rbp)
	jne	.L2
	movl	$.LC0, %edi
	call	puts
	.L2:
	cmpl	$10, -4(%rbp)
	jne	.L3
	movl	$.LC1, %edi
	call	puts
	jmp	.L4
	.L3:
	cmpl	$20, -4(%rbp)
	jne	.L4
	movl	$.LC2, %edi
	call	puts
	.L4:
	movl	-8(%rbp), %eax
	cmpl	-4(%rbp), %eax
	jne	.L5
	movl	$.LC3, %edi
	call	puts
	jmp	.L6
	.L5:
	movl	$.LC4, %edi
	call	puts
	.L6:
	movl	$0, %eax
	leave
	ret

• pushq %rbp → 함수 프롤로그
• movq %rsp, %rbp → rsp에 rbp값을 넣는다
• subq $16, %rsp → rsp를 0x10(16byte)으로 스택 공간 확보
• movl $10, -8(%rbp) → rbp-0x8에 10저장
• movl $20, -4(%rbp) →rbp-0x4에 20저장
• cmpl $10, -8(%rbp) → rbp-0x8값 (10)과 10비교  (a == 10?)
  • jne .L2 → 비교 결과가 다르다면 L2로 점프
• movl $.LC0, %edi → 같다면 "a is 10"을 인자로 가져옴
• call puts →  puts 함수 호출

.L2:

• cmpl $10, -4(%rbp) → rbp-0x4의 값(20)과 10 비교  (b == 10?)
  • jne .L3 → 비교해서 같지 않으면 L3으로 점프
• movl $.LC1, %edi → 맞다면 "b is 10"을 인자로 가져옴
• call puts → puts 함수 호출
• jmp .L4 → L4로 점프

.L3:

• cmpl   $20, -4(%rbp) → rbp-0x4의 값(20)과 20 비교   (b == 20?)
  •  jne .L4 → 비교해서 같지 않으면 L4로 점프
• movl $.LC2,%edi → 맞다면 "b is 20"을 인자로 가져옴
• call puts → puts 함수 호출

.L4:    

•  movl -8(%rbp), %eax → eax의 값 rbp-0x8에 저장    (c = a)
• cmpl -4(%rbp), %eax → eax의 값과 rbp-0x4의 값(20)을 비교   (c == b?)
  • jne .L5 → 비교해서 다르다면 L5로 점프
• movl $.LC3, %edi → 맞다면 "a=b"을 인자로 가져옴
• call puts → puts 함수 호출

.L5:       

• movl $.LC4, %edi → "a!=b"를 인자로 가져옴
• call puts → puts 함수 호출

.L6:       

• movl   $0, %eax → eax를 0으로 초기화
• leave → 함수 에필로그
• ret → return address 주소 반환

 

 

작성해준 C 코드는 다음과 같다.

#include <stdio.h> 
int main(){ 
	int a = 10; 
	int b = 20; 
	
	if (a == 10)
		puts("a is 10"); 
	if (b == 10) 
		puts("b is 10"); 
	else if (b == 20) 
		puts("b is 20"); 
	if (a == b) 
		puts("a=b"); 
	else 
		puts("a!=b"); 
	return 0; 
}

 

 

 

 

 

 

 

이를 다시 디스어셈블 해본 결과는 다음과 같다.

disassemble main

 

 

 

---

 

 

 

 

# example4.asm

# example4.asm
.file	"example4.c"
.section	.rodata
.LC0:
	.string	"result : %d\n"
	.text
	.globl	function
	.type	function, @function
function:
	.LFB0:
	.cfi_startproc
	pushq	%rbp
	.cfi_def_cfa_offset 16
	.cfi_offset 6, -16
	movq	%rsp, %rbp
	.cfi_def_cfa_register 6
	subq	$16, %rsp
	movl	%edi, -4(%rbp)
	movl	%esi, -8(%rbp)
	movl	-4(%rbp), %eax
	imull	-8(%rbp), %eax
	movl	%eax, %esi
	movl	$.LC0, %edi
	movl	$0, %eax
	call	printf
	leave
	.cfi_def_cfa 7, 8
	ret
	.cfi_endproc
.LFE0:
	.size	function, .-function
	.globl	main
	.type	main, @function
main:
	.LFB1:
	.cfi_startproc
	pushq	%rbp
	.cfi_def_cfa_offset 16
	.cfi_offset 6, -16
	movq	%rsp, %rbp
	.cfi_def_cfa_register 6
	subq	$16, %rsp
	movl	$50, -8(%rbp)
	movl	$60, -4(%rbp)
	movl	-4(%rbp), %edx
	movl	-8(%rbp), %eax
	movl	%edx, %esi
	movl	%eax, %edi
	call	function
	movl	$0, %eax
	leave
	.cfi_def_cfa 7, 8
	ret
	.cfi_endproc
.LFE1:
	.size	main, .-main
	.ident	"GCC: (Ubuntu 4.8.4-2ubuntu1~14.04.1) 4.8.4"
	.section	.note.GNU-stack,"",@progbits

전체 코드는 위와 같고,

 

이 중에서 다음 코드를 보면

.LC0:
	.string	"result : %d\n"

.LC0: 는 "result : %d\n"이라는 스트링으로 정의가 되어있음을 알 수 있다.

 

 

 

이번에는 main 함수 말고도 또 다른 함수 function이 등장한다.

function:
	pushq	%rbp
	movq	%rsp, %rbp
	subq	$16, %rsp
	movl	%edi, -4(%rbp)
	movl	%esi, -8(%rbp)
	movl	-4(%rbp), %eax
	imull	-8(%rbp), %eax
	movl	%eax, %esi
	movl	$.LC0, %edi
	movl	$0, %eax
	call	printf
	leave
	ret

• pushq %rbp → 함수 프롤로그
• movq %rsp, %rbp → rsp에 rbp의 값을 넣는다
• subq $16, %rsp → rsp를 0x10(16byte)으로 스택 확보
• movl %edi, -4(%rbp) → rbp-0x4에 매개변수로 가져온 edi저장
• movl %esi, -8(%rbp) → rbp-0x8에 두 번째 매개변수로 가져온 esi 저장
• movl -4(%rbp), %eax → eax에 rbp-0x4저장 
• imull -8(%rbp), %eax → eax와 rbp-0x8 값 곱해서 eax에 저장
• movl %eax, %esi → esi에 두 번째 인자로 eax를 넣음
• movl $.LC0, %edi → 첫 번째 인자로 "result : %d\n" 가져옴
• movl $0, %eax → eax 0으로 초기화
• call printf → printf 함수 호출
• leave → 함수 에필로그
• ret → return address 주소 반환

int function(int a, int b) {
	printf("result : %d\n", a*b);
	return 0;
}

function 함수를 C언어로 나타내면 위와 같다.

 

disassemble function

 

 

 

 

이제 main함수를 살펴보자.

main:
	pushq	%rbp
	movq	%rsp, %rbp
	subq	$16, %rsp
	movl	$50, -8(%rbp)
	movl	$60, -4(%rbp)
	movl	-4(%rbp), %edx
	movl	-8(%rbp), %eax
	movl	%edx, %esi
	movl	%eax, %edi
	call	function
	movl	$0, %eax
	leave
	ret

• pushq %rbp → 함수 프롤로그
• movq %rsp, %rbp → rsp에 rbp값을 넣는다.
• subq $16, %rsp → rsp를 0x10(16byte)으로 공간 확보
• movl $50, -8(%rbp) → rbp-0x8에 50 저장 
• movl $60, -4(%rbp) → rbp-0x4에 60 저장
• movl -4(%rbp), %edx → 두 번째 매개변수 edx에 rbp-0x4의 값(60) 저장
• movl -8(%rbp), %eax → 첫 번째 매개변수 eax에 rbp-0x8의 값(50) 저장
• movl %edx, %esi → esi 레지스터에 edx(function의 두 번째 인자) 저장
• movl %eax, %edi → edi 레지스터에 eax(function의 첫 번째 인자) 저장
• call function → function (함수)호출
• movl $0, %eax → eax를 0으로 초기화
• leave → 함수 에필로그
• ret → ret address 주소 반환

 

main함수와 function 함수를 모두 C언어 코드로 바꾸면 다음과 같다.

#include <stdio.h>

int function(int a, int b) {
	printf("result : %d\n", a*b);
	return 0;
}

int main() {
	int a = 50;
	int b = 60;
    
	function(a, b);
	return 0;
}

disassemble main

 

 

 

---

 

 

 

# example5.asm

# example5.asm 
.file	"example5.c"
.section	.rodata
.LC0:
	.string	"number %d \n"
.LC1:
	.string	"%d * %d = %d \n"
	.text
	.globl	main
	.type	main, @function
main:
	.LFB0:
	.cfi_startproc
	pushq	%rbp
	.cfi_def_cfa_offset 16
	.cfi_offset 6, -16
	movq	%rsp, %rbp
	.cfi_def_cfa_register 6
	subq	$16, %rsp
	movl	$0, -8(%rbp)
	jmp	.L2
	.L3:
	movl	-8(%rbp), %eax
	movl	%eax, %esi
	movl	$.LC0, %edi
	movl	$0, %eax
	call	printf
	addl	$1, -8(%rbp)
	.L2:
	cmpl	$9, -8(%rbp)
	jle	.L3
	movl	$0, -4(%rbp)
	jmp	.L4
	.L5:
	movl	-8(%rbp), %eax
	imull	-4(%rbp), %eax
	movl	%eax, %ecx
	movl	-4(%rbp), %edx
	movl	-8(%rbp), %eax
	movl	%eax, %esi
	movl	$.LC1, %edi
	movl	$0, %eax
	call	printf
	addl	$1, -4(%rbp)
	.L4:
	cmpl	$4, -4(%rbp)
	jle	.L5
	movl	$0, %eax
	leave
	.cfi_def_cfa 7, 8
	ret
	.cfi_endproc
.LFE0:
	.size	main, .-main
	.ident	"GCC: (Ubuntu 4.8.4-2ubuntu1~14.04.1) 4.8.4"
	.section	.note.GNU-stack,"",@progbits

 

 

.LC0:
	.string	"number %d \n"
.LC1:
	.string	"%d * %d = %d \n"

위 코드를 보면 .LC0과 .LC1을 각각의 문자열로 정의한 걸 확인할 수 있다.

 

 

 

 

 

main 함수를 살펴보면 다음과 같다.

main:
	pushq	%rbp
	movq	%rsp, %rbp
	subq	$16, %rsp
	movl	$0, -8(%rbp)
	jmp	.L2
	.L3:
	movl	-8(%rbp), %eax
	movl	%eax, %esi
	movl	$.LC0, %edi
	movl	$0, %eax
	call	printf
	addl	$1, -8(%rbp)
	.L2:
	cmpl	$9, -8(%rbp)
	jle	.L3
	movl	$0, -4(%rbp)
	jmp	.L4
	.L5:
	movl	-8(%rbp), %eax
	imull	-4(%rbp), %eax
	movl	%eax, %ecx
	movl	-4(%rbp), %edx
	movl	-8(%rbp), %eax
	movl	%eax, %esi
	movl	$.LC1, %edi
	movl	$0, %eax
	call	printf
	addl	$1, -4(%rbp)
	.L4:
	cmpl	$4, -4(%rbp)
	jle	.L5
	movl	$0, %eax
	leave
	ret

• pushq %rbp → 함수 프롤로그
• movq %rsp, %rbp → rsp에 rbp값을 넣는다.
• subq $16, %rsp → rsp를 0x10(16byte)만큼 스택 공간 확보
• movl $0, -8(%rbp) → rbp-0x8에 0 저장
• jmp .L2 → L2로 점프

.L3:

• movl -8(%rbp), %eax → eax 레지스터에 rbp-0x8 저장 
• movl %eax, %esi → esi 레지스터에 eax 값(rbp-0x8) 저장 
• movl $.LC0, %edi → edi 레지스터에 LC0 문자열 저장
• movl $0, %eax → eax 레지스터 0으로 초기화
• call printf → printf 함수 호출
• addl $1, -8(%rbp) → rbp-0x8에 1 더함 (i++)

.L2:

• cmpl $9, -8(%rbp) → rbp-0x8의 값과 9 비교
  • jle .L3 → 작거나 같으면 L3으로 이동
  • movl $0, -4(%rbp) → 크면 rbp-0x4에 저장
• jmp .L4 → L4로 이동 (루프에서 나오면)

.L5: 

• movl -8(%rbp), %eax → eax 레지스터에 rbp-0x8 값 저장
• imull -4(%rbp), %eax → eax = eax * [rbp-0x4]
• movl %eax, %ecx → ecx에 eax 값 저장
• movl -4(%rbp), %edx → edx에 rbp-0x4값 저장
• movl -8(%rbp), %eax → eax에 rbp-0x8값 저장
• movl %eax, %esi → 두 번째 인자 eax로 이동
• movl $.LC1, %edi → 첫 번째 인자 LC1 문자열로 이동
• movl $0, %eax → eax 0으로 초기화
• call printf → printf 함수 호출
• addl $1, -4(%rbp) → rbp-0x4 값에 1 증가

.L4:

• cmpl $4, -4(%rbp) → rbp-0x4값과 4 비교
  • jle .L5 → 4보다 같거나 작으면 L5로 이동
• movl $0, %eax → eax 0으로 초기화
• leave → 함수 에필로그
• ret → return address 반환

 

C언어로 바꿔준 코드는 다음과 같다.

#include <stdio.h>

int main() {
	int a = 0, b;
	
	for (int i = 0; i < 10; i++) {
		printf("number %d \n", a);
		a++;
	}
	for (int j = 0; j < 5; j++) {
		b = j;
		printf("%d * %d = %d \n", a, b, a*b);
	}
	return 0;
}