Code1018

특수 코드인 1018을 입력으로 넣으면 root 권한을 넘겨주는 rootkit을 만들것이다.

(Prototype)

여기서 write함수를 채워준다.

(write 함수)

Makefile을 만든다.

(Makefile)

그 이유는 루트 권한이 아닌 일반계정에서 실행할 수 있도록 하기 위해서이다.

(권한 설정)

실행하기 전 권한을 확인한 모습이다.

(권한)

이 디바이스에 1018이라고 입력을 넣는다.

(매직값 입력)

위에서 작성한 write에 의해서 사용자 권한을 0으로 만들어준다.

(root 권한 획득)

https://0x00sec.org/t/kernel-rootkits-getting-your-hands-dirty/1485

그러기 위해 필요한 것이 있다. 바로 linux 헤더이다.

(linux-headers)

알맞은 운영체제 버전을 선택해서 설치하면 된다.

(설치)

hello.c 파일을 작성하였다.

(hello.c)

이 파일을 컴파일 하기 위하여 Makefile을 만든다.

(Makefile)

make 를 입력하여 컴파일한다.

(컴파일 완료)

그러면 hello.ko 가 생기게 된다. 이 커널 오브젝트 파일은 모듈인데 이 모듈을 올려보도록 할 것이다.

(커널 모듈 올리기)

올라간 모듈은 lsmod를 통하여 확인 할 수 있다.

(올라간 모듈 확인)

올라간 모듈을 해제하는 법은 rmmod 이다.

(모듈 해제)

아까 우리가 init과 exit 에 printk를 넣었으니, 모듈이 올라갈 때 내려갈 때 로그가 찍혔을 것이다.

(로그 확인)

이번에는 아까 만든 변수에 값을 넘겨주며 올려보겠다.

(인자 넘기기)

(모듈 확인)

올라간 모듈 hello에 들어가본다.

(모듈 정보)

여기서 우리는 parameters를 확인해 볼 것이다.

(변수 확인)

이 값을 수정할 수 있을까 했더니

(파일 권한)

마지막으로 인자를 넘긴 모듈을 해제해보겠다.

(모듈 해제)

그렇다면 kern.log는?

(커널 로그)

두가지 brk와 mmap 시스템콜을 사용한다.

(malloc)

brk 를 확인해보기 위해 아래와 같이 코드를 작성한다.

(brk 테스트)

(brk 메뉴얼)

실행한 결과를 확인해보자.

(brk 되기 전)

실제 메모리 모습을 확인해보면

(메모리 모습(brk 전))

brk를 한 후 결과를 확인해본다.

(brk 후)

메모리 상황을 확인해보면

(메모리 (brk 후))

마지막으로 brk를 원래 위치로 되돌리는 것 까지 확인해보자.

(원위치)

(메모리 상황)

코드를 이용해 직접 확인해보자.

(테스트 코드)

mmap 되기 전 상황과 된 후 상황일 먼저 비교해볼 것이다.

(mmap 전)

(메모리 (mmap 전))

그 후 mmap을 진행한다.

(mmap 실행)

(메모리 ( mmap 후))

munmap 후까지 확인해본다.

(munmap)

(메모리 ( munmap 후 ))

munmap 후 다시 프로그램에게 메모리가 반환되는 것을 확인 할 수 있었다.

실습3
if( eax >0 && ebx < 10 || ecx >= 2){
 ebx =1;
} else{
 ebx = 0;
}

알고리즘
1. 비교 eax와 0 비교
: eax가 0보다 같거나작을경우 (eax <=0) ecx를 비교하러 가야함.
1-1. (eax <=0)
 ecx와 2 비교
: ecx가 2보다 같거나 크면 (ecx >=2) -> ebx = 1
아니면 ebx = 0
1-2. (eax >0)
-> ebx를 10과 비교
: ebx가 10보다 작으면 (ebx <10) -> ebx = 1
아니면 ecx 비교해야한다.
-> ecx 비교해서 2보다 크면 1
작으면 0

위의 C코드를 어셈블리 언어로 표현하면 아래와 같다.

(실습코드)

이 코드를 조금 더 간략하게 표현하자면 아래와 같이도 표현할 수 있다.

(실습 코드2)

그러면 우리가 만들었던 어셈블리 코드가 실제로 C코드를 컴파일한 코드와 비교해보자.

(C코드)

컴파일 후 어셈블리어 코드를 확인해보면

(어셈블리어 코드)

코드를 보면 우리가 만들었던 것과 조금 차이는 있지만 이 코드를 보고 우리가 어떤 식으로 동작하는지 이해할 수 있는 정도는 되었다.

이번에는 switch 문을 사용한 C코드를 컴파일한 어셈블리어를 if 코드와 비교해보겠다.

(switch문 사용)

컴파일 후 어셈블리어 코드 확인

(switch문)

코드를 보면 if문과 조금의 차이는 있지만 구조적으로 보면 jmp를 사용하기에
똑같다고 볼 수 있다.

이제 반복문을 알아보겠다.
반복문을 이용한 C코드를 컴파일해서 어떤식으로 이루어지는지 먼저 확인해보겠다.

(for문)

컴파일 후 실행해보면

(실행결과)

실행결과 우리가 생각하는 반복문 실행이 되는 것을 확인 할 수 있다.

이 코드를 어셈블리어를 확인해보면

(어셈블리어 코드)

반복문 또한 우리가 공부했던 jmp 분기문을 이용해 이루어지는 것을 볼 수 있다.

그렇다면 같은 내용을 while로 구현해보겠다.

(while 사용)

(어셈블리어코드)

어셈블리어 코드에서 보면 for문과 while 문의 차이는 없었다.
반복문은 jmp 분기문을 이용해 똑같이 만들어지는 것을 확인 할 수 있다.

그렇다면 직접 반복문을 만들어보자.!

아래와 같은 반복문을 만들것이다.
ebx = 0;
eax = 1;
while(eax <= 10){
 ebx += eax;
 eax++;
}

(실습 어셈블리어 코드)

분기문 하기에 앞서 사칙연산을 정리해보겠다.

사칙연산하는 C코드의 어셈블리어는 어떻게 구성될까?

(C코드)

컴파일 후 확인해본다!

(어셈블 코드)

저번 글에서 만들었던 형태가 비슷하게 나오는 것을 확인 할 수 있다.

오늘은 분기문을 공부 할 것이다.
jmp는 해당 주소로 이동하는 것이다.

이것을 이용하면 조건문도 만들 수 있고 반복문도 만들 수 있다.
실제로 C코드에서 if와 switch는 jmp 명령어로 이루어져있고
어셈블 차원에서 보면 똑같다.

사용 형식은
jmp addr
이런식으로 써준다.

그렇다면 jmp로 무한루프를 만들어보겠다.

(무한루프 코드)

jmp 명령에 의해 _start로 돌아간다.
_start는 레이블 이름으로 주소값이다. 컴파일 전에 주소값을 우리는 모르니 레이블 이름을 달아주어 사용한다.
컴파일한다.

(컴파일)

컴파일 후 실행해보면

(실행 모습)

실행되는 모습이다.

그렇다면 C코드의 기본적인 if문을 어셈블러로 구현해보자!
먼저 C코드의 기본적인 if문 코드이다.

(if문 코드)

(실행모습)

여기서는 조건 분기를 사용한다. 위의 jmp는 무조건 분기로 다른 조건없이 바로 해당 주소로 넘어가지만 조건분기는 조금 다르다.

조건 분기
 - EFLAGS 레지스터를 참조해서 분기할지 말지를 결정한다.
조건 분기문을 쓰기전에 cmp를 해줘야 EFLAGS에 기록하고 이걸 보고 조건문기문이
동작한다.

 - cmp

조건분기 종류를 살펴보면
 - je (jmp equal) = jz
 - jne (jmp not equal) = jnz
 - jl (jmp less)
 - jg (jmp greater)
 - jnl
 - jng
 - jle
 - jge
 - ja (jmp above) 초과
 - jb (jmp below) 미만
 - jna
 - jnb
 ...

3. cmp : 비교명령어
 cmp vleft vright
 -> 두개의 값이 같은지 비교
- vleft 값과 vright 값의 차를 구한다.
- 그 결과에 따라서 EFLAGS 레지스터의 플래그를 조절한다.
cmp에서 사용하는 flg
- ZF, SF
1) vleft - vright의 결과가 0인 경우
 : ZF = 1, SF=0 -> 두 값이 같다고 판단
2) vleft - vright의 결과가 음수인 경우
 : ZF=0, SF=1 -> 오른쪽이 더 크다.
3) vleft - vright의 결과가 양수인 경우
 : ZF=0,SF=0
조건분기문 사용 직전에 cmp를 해줘야한다.

이를 이용해 기본적인 if C코드를 어셈블러 코드로 구현하면 아래와 같다.

(조건분기문 사용)

(실행결과)

실행 결과 잘 나오는 듯하다.
(하지면 이 코드에는 문제점이 있다.)

값을 5보다 작게 2로 설정하여 확인해보겠다.

(작은 값 입력)

(실행결과)

실행결과를 보니 2가 작음에도 크다고 출력되었다.

왜 이럴까??
원인은 바로 점프하지 않고도 그 아래에 출력해주는 명령문이 있기 때문에 아래 코드가 순차적으로 실행 되었던 것이다. 이것을 막아주기 위해서는 아래 처럼 추가해주면된다.

(추가 코드)

(실행결과)

실행한 결과 작을 때는 이제 출력되지 않는 우리가 원하던 C코드의 동작을 하게 되었다.

다르게 표현을 하자면 jmp문 하나로도 완성 가능하다.

(다른 표현)

C코드를 컴파일 한 내용과 비교해보겠다.
상수끼리 비교하면 컴파일러가 알아서 계산을 해놓아서...
변수를 따로 선언을 해주었다.

(C코드 수정)

컴파일 후 어셈블러를 확인해보면

(어셈블 코드)

우리가 만든 코드와 비슷하게 나온 것을 확인 할 수 있다.

그렇다면 실습으로 아래와 같은 코드를 어셈블 코드로 만들어보자!

(실습 코드)

실습 결과는 아래와 같이 만들 수 있다.

(실습 결과)

jmp 문에 대한 내용이었다.

오늘은 어셈블리로 사칙연산 명령어를 공부할 것이다.

1. 덧셈
명령어 : add
형식
add     dst,     src
:dst에 더한값을 저장한다.
dst에는 레지스터, 메모리가 올 수 있고
src에는 레지스터 메모리 상수가 올 수 있다.

*주의 한번에 두개의 메모리를 참조할 수 없다.
ex) add 메모리, 메모리
(이건 mov도, 기타등등 여러 명령어에서도 마찬가지이다.)

그러면 add명령어를 사용해보겠다.

(add 코드)

eax에 2를 저장하고 add 명령어를 이용해 3을 더했다.

실행하게되면

(실행화면)

결과는 5가 나온다.

이번에는 레지스터가 아닌 메모리를 사용해 덧셈을 해보겠다.

(메모리 사용)

sum 주소에 2를 저장하고 3을 더해주었다.
대신 주소값을 쓰는게 아니라 주소에 있는 데이터값을 쓰는것이므로 
[ ] 브라켓을 씌워준다.

(실행결과)

실행 결과 역시 5가 나왔다.

2. 뺄셈
명령어 : sub
형식
sub     dst,     src
내용은 덧셈과 같다.

그렇다면 뺄셈을 사용해보겠다.

(뺄셈 코드)

(실행화면)

실행화면을 보면 10-5의 결과로 5가 제대로 나온 것을 볼 수 있다.

* 실습 문제
 - 다음과 같은 두 개의 값의 덧셈 결과와 뺄셈 결과를 출력
segment  .data
 num1     dd     20
 num2     dd     10

(실습 코드)

코드를 보면 알겠지만 조금 오바해봤다.

실제 계산부분만 보면 되겠다.
실행해보면

(실행결과)

덧셈과 뺄셈이 잘 되는 걸 확인 할 수 있다.

이번에는 덧셈은 레지스터, 뺄셈은 (꾸이꾸이) 메모리를 사용해 해보겠다.

(실습 코드2)

(실행결과)

실행 결과가 같다.

이번에는 주소값과 주소에 있는 데이터와의 차이를 보겠다.

아래의 코드를 먼저 본다.

(어셈블 코드)

위에는 그냥 num 아래는 [num] 을 사용했다.
실행하여 결과를 확인해보자.

(실행결과)

실행 결과를 보니 그냥 num을 쓴 것은 주소값이 출력되었고
[num]은 그 주소에 있는 데이터 10의 값이 출력되었다.

여기서 이제 mov와 lea를 비교하면서 lea가 뭔지 살펴보겠다.
lea는 mov와 거의 비슷하다. 다만 조금 다른점이 있는데 직접 눈으로 확인해보겠다.

아래에 lea와 mov를 추가해서 확인해본다.

(mov와 lea 추가)

(실행결과)

실행 결과를 보니 mov로는 [num]이기 때문에 우리가 알던대로
num의 주소에 있는 데이터인 10이 출력되었다.

근데 이상한점이 있다. lea로 [num]을 넣어주었는데
주소값이 출력되었다.
바로 이게 차이점이다.
lea는 [ ] 브라켓을 꼭 써야하고
그 안에있는 값 그대로 출력해준다. 그래서 num의 주소값이 그대로 출력된 것이다.

바로 이 점을 이용해 덧셈을 할 수 있는데
아래 코드에서 마지막 부분을 보면 된다.

(lea를 통한 덧셈)

(실행 결과)

실행 결과를 보면 14로 덧셈이 잘 된것을 확인 할 수 있다.
lea eax, [ebx+4]
이렇게 하면 우리가 ebx에 10을 넣어주었으니 ebx는 10이되고 10+4로 14의 값이 그대로 전달되는 것이다.

3. 곱셈
명령어 : mul, imul
형식
mul     피연산자
-> 부호없는 곱셈

imul 피연산자
 imul 피연산자, 피연산자, 피연산자
 -> 최대 3개까지 올 수 있다.
 -> 부호 있는 곱셈

mul 는 a 레지스터를 쓰게 되어있다.
무조건 a레지스터에 있는 값과 곱하게 된다.

그렇다면 곱셈을 사용해보자!

(곱셈 코드)

(실행화면)

실행화면을 보면 곱셈의 결과 6이 나온 것을 확인할 수 있다.

이제 곱셈의 이상한?점을 볼 차례이다.
바로 사이즈가 커진다는 것인데
곱셈은 결과가 원래 사이즈를 넘어갈 수 가 있다.
그렇기 때문에 결과를 큰 사이즈에 저장하게된다.
위에서도 보다시피 1바이트 곱셈인데 결과는 우리가 eax를 푸쉬해서 출력했다.

아래처럼 255로 꽉채워서 곱셈을 하게되면 사이즈가 초과되기 때문에 결과는 eax로 저장이 된다.

(초과 곱셈)

(실행결과)

그렇기 때문에 곱셈의 결과가 정확하게 나올 수 있는 것이다.

그러면 이제 imul을 사용해보겠다. 이 명령어는 부호가 있는 곱셈이라고 했다.
부호가 있을때 사용하라는 말이 아니라 비트중 MSB를 인식한다는 뜻이다.

우리가 255 255 곱셈을 하게되면 어떻게 될까? 왜냐하면 MSB가 모두 1이기 때문에 궁금하다.

(imul)

(실행결과)

실행결과 255를 -1로 인식하여
-1 곱하기 -1 을 하여 1이 나왔다.

imul은 mul처럼 사용할 수 도 있지만
인자를 2개 3개까지 받을 수 있는데 살펴보겠다.

2개를 쓸 때

(2개 사용 코드)

(실행 모습)

2개를 쓸 때는 이렇게 사용한다.

3개를 쓸 때는?

(3개 사용)

(결과)

2번째 3번째 곱셈의 결과를 1번째 인자에 저장한다.

곱셈은 결과가 사이즈가 초과할 수 있어 그보다 더 큰 레지스터에 저장한다고 했다.
그렇다면 eax 4바이트 단위의 곱셈은 어디다 저장이 되는 걸까?

해보자!

(초과 결과 코드)

(실행 모습)

eax를 출력해보니 뭔가 완전하지 않은듯한 느낌이든다.

원래 곱셈의 결과라면
0x11111111  *  0x22222222 는 아래와 같다.

(결과)

그렇다면 앞 부분은 어디갔다는 말인가?!

바로 edx에 저장된다.
edx도 함께 출력해보겠다.

(edx 추가 출력)

(실행화면)

실행화면을 보면 eax와 edx에 나누어서 결과가 저장이 된 것을 확인 할 수 있다.

나머지와 mod 연산은 다음 글에서 이어서 써보겠다. :)

오늘은 데이터를 저장하는 방식에 대해 이야기해보겠다.

크게 나누면 메모리를 이용하는 방식과 스택을 이용하는 방식이 있다.

그 중 메모리를 이용하는 방법을 알아볼 것이다.

먼저 데이터 단위이다.
* 데이터의 기본 단위
Unit  bytes  Letter
byte  -> 1 bytes : 표현 B
word -> 2 bytes : 표현 W
double word -> 4 bytes : 표현 D
quad word -> 8 bytes : 표현 Q
ten bytes -> 10 bytes : 표현 T
paragraph -> 16 bytes

* 데이터를 저장하기 위해 사용가능한 메모리
1. 데이터 메모리 : C에서는 전역변수 개념

1) 초기화된 데이터 메모리 영역 :.data
-> 지난 시간까지 사용했던 영역이다.
-> 중간에 type이 db라고 써있는 것에 대해 설명하자면 data 영역에서는 앞에 d를 붙여줘야한다.
    그 뒤에 나오는 것은 데이터 단위로 b는 byte로 1 바이트를 나타낸다.

2) 비초기화된 데이터 메모리 영역 : .bss
중간에 type에 앞쪽에 res를 적어주고 그 뒤에는 데이터 타입을 적어준다.
ex) resb

어셈블리 기본 명령어 구조(인텔기반)
- 명령어( pushfd, nop, ret,  ... ) 피연산자가 없는 경우도 있다. 단일명령어형태
- 명령어 피연산자( pop esp,      jmp addr, ...)
- 명령어 피연산자1, 피연산자2 ( mov ebx, 2  ...)
- 명령어 피연산자1, 피연산자2, 피연산자3 ( mul, ...)

* mov 명령어
mov : 데이터 이동
 mov dst, src
- dst에 올수 있는 것은 메모리와 레지스터 외에 다른 값이 올 수 없다.
- src : 메모리, 레지스트리, 일반 값 전부 다 올 수 있다.

이것들을 이용해 실습하면서 확인해보겠다.
먼저 data 영역에 데이터를 저장하고 출력해보겠다.

(어셈블 코드)

이 코드를 실행하면 numbers에 있는 값들이 출력될까?
실행해보면

(실행결과)

우리가 저장한 값은 전혀 아니라는 것을 확인 할 수 있다.
이 값은 numbers의 주소 값이다.
기본적으로 전달할때 어셈블리언어에서는 주소를 전달한다.

그렇다면 data영역에 numbers 에 우리가 1,2,3,4,5 를 저장했는데 이 값을 출력하려면 어떻게 해야할까?

(출력 코드)

이런식으로 [ ] 브라켓에 담아주면된다.
이렇게 표현을 하면 C언어에서 포인터 같은 역할을 하게된다.
주소값이 아닌 그 주소에 있는 데이터 값을 가져온다.
위 코드를 실행하면 1이 출력이 될것이고
그렇다면 그 다음 값인 2를 출력하려면?

(2 출력 코드)

DWORD가 4바이트이므로 4바이트+ 시켜준 주소값으로 브라켓으로 값을 가져오면 된다.

(실행모습)

2가 출력되는 것을 확인 할 수 있다.

DWORD 써준이유?
numbers 라고 우리가 주소값을 전달해주는데 얼마나 가져오라는 말이 없다.
즉 이 말을 안써주면 어디까지 우리가 가져와야하는지 모르니까 DWORD처럼 가져올 단위를 적어줘야한다.
레지스트리에서 안쓴 이유는 레지스트리 이름 자체에 크기를 뜻하기 때문이다.

이번엔 bss 영역에 초기화 되지 않은 변수들에다가 값을 저장하고 그 값을 출력해보겠다.

(bss 코드)

mov 명령어를 통해 number의 위치에 데이터를 10을 저장한다.
그 후 number 위치의 값을 가져와 출력한다.

(실행 결과)

실행 결과 우리가 10을 너어주었는데
10이 잘 출력된 것을 확인 할 수 있었다.

어제까지 배운 지식으로 토끼모양을 출력하는 프로그램을 어셈블 언어로 작성해보자!

코드는 다음과 같다.

(어셈블 코드)

(출력 결과)

오늘은 레지스터에 대해 알아볼 것이다.

* 레지스터

-> 이름이 범용이 들어가는 것 처럼 이곳저곳에서 많이 쓰이는 레지스터이다. 레지스터의 크기에 따라 명칭이 달라진다.

(어셈블 코드)

위 코드는 레지스터 eax에 0101010101010101 이 들어간 값을 출력하는 프로그램이다.
레지스터의 내부구조를 살펴보기위해 만든 코드이다.
출력은 16진수로 표현된다. 그러므로 출력결과는 55555555 로 될것이다.

(출력 결과)

출력 결과가 55555555이 나왔다. 여기까지는 크게 다른 내용은 없다.
계산기에서 55555555을 입력하여 비트단위로 보면 0101010101010101인것을 확인 할 수 있다.

(55555555 (16))

여기서 eax 그대로에 ax를 사용하려 했으나 eax가 여기서 함수호출로 인해 사용되므로 ebx로 바꿔서 계속 진행해보겠다.
ebx 레지스터에 55555555을 넣고 bx 레지스터에 2222를 넣었다.
그리고 ebx를 출력해보면 출력결과가 어떻게 나올까?

(어셈블코드)

그 내용을 담은게 위의 코드이다.
실행해보겠다.

(실행결과)

(비트단위)

ebx 결과를 보면 ebx 내부 2바이트가 2222로 덮여쓰여진 것을 볼 수 있다.

계속해서 1바이트를 표현하는 bl, bh를 사용해보겠다. 이 둘은 상위1바이트 하위 1바이트를 가리키는 레지스터이다. ebx는 그대로 사용한 채 bh에 44 bl에 33을 넣어보겠다.

(어셈블코드)

실행하게 되면

(실행 모습)

(실행결과)

상위 1바이트는 44로 표현이 되었고 하위 1바이트는 33으로 표현되었다.

이렇게 범용레지스터는 크기를 나타내는 용어가 다르다. 즉 1바이트를 사용하고싶거나 2바이트, 4바이트 이렇게 사용하고 싶은 크기에 따라 다른 레지스터를 사용하면 된다.

2. 포인터 레지스터
 - 주소를 표현하는 레지스터이다. 이 레지스터는 용도가 분명하게 있다.
 - 용도가 정확하게 정해져 있기 때문에 다른용도로쓰면 세그먼트 폴트등 오류가 난다.

저번에 Hello World를 출력하는 코드가 프로그램으로 번역되는
컴파일 과정을 살펴보았다.

오늘은 번역된 결과인 어셈블 언어를 공부를 시작해볼 것이다.
저번에 만들었던 코드를 조금 수정해서 printf에 넘겨주는 함수 인자를 2개로 만들어보았다.

(함수 인자 2개)

(출력 모습)

프로그램이 동작하는 결과는 같다.

다만 이 프로그램을 어셈블언어로 살펴보면

(인자 전달)

PUSH 두개가 보이고 그 후에 call이 나온다.
먼저 간단히 설명하자면 PUSH로 스택에 전달할 인자 2개를 넣어 둔 후
함수를 호출하면서 함수에 인자를 전달한다. 바로 이게 함수에 인자를 전달하는 방법 중 하나이다.

* 함수에 인자를 전달하는 방법
1. 스택 메모리를 통한 전달
이 방법을 통해 어셈블언어로 직접 구현해보겠다.

(어셈블언어)

여기서 extern은 C언어에서도 사용하는 키워드로 외부의 함수를 이용하기 위해 사용하는 것이고
우리는 printf 를 사용하기 위해 extern으로 알려주었다.
그 다음으로 segment로 data 영역과 text 영역이 보인다. text 영역에는 코드를 작성하고 data 영역에는 우리가 사용할 문자열을 저장해두었다.
함수에 전달하는 값은 순서가 반대로 입력이 된다. 스택구조는 제일 먼저 들어온 것이 가장 나중에 나오는 자료구조의 특징때문이다.

이 어셈블 코드를 목적파일로 만들고 링크작업까지 끝내고 objdump로 살펴보면 다음과 같이 확인할 수 있다.

(objdump 모습)

우리가 입력해준 데이터 msg1, msg2의 값의 주소값으로 들어간 것을 확인 할 수 있다.
여기서 msg1, 2 는 우리가 레이블이라고 표현하는데 주소값을 컴파일 전에는 알 수 없으므로 네이밍 해준 것이다.

이번에는 printf에 인자를 3개 줘보겠다. 먼저 C코드에서의 모습이다.

(C코드 모습)

이러한 코드를 어셈블언어로 작성하면?

(어셈블언어)

위와 같다. 스택구조로써 PUSH 하는 순서는 반대로 넣어주고 함수를 call 하면 된다.

실행 화면을 확인해보면 다음과 같다.

(실행 화면)

실행 화면을 보면 기존의 출력과 똑같이 나오는 것을 확인 할 수 있다.
또 objdump로 다시 살펴보면

(objdump)

3개의 인자로 넘겨주려고 했던 것들이 PUSH 되고 함수가 call 되는 것을 확인 할 수 있다.

2. 레지스터를 통한 인자 전달
두번째 방법으로는 레지스터를 통해 함수에 인자를 전달 할 수 있다. ( 사실 어셈블언어에서 함수라는 개념은 없지만 지금은 이해하기 쉽게 함수라 표현하였다.)

* 레지스터 - CPU가 사용하는 고속의 기억장치

1. 범용 레지스터( general register ) (순서대로 이용한다.)
1). EAX( Extended Accumulator Register )
2). EBX( Extended Base        Register )
3). ECX( Extended Counter     Register ) : 반복관련
4). EDX( Extended Data        Register ) : 보조적인 데이터 저장

-> 사실 이 용도로만 쓰지는 않는다. 범용이라 아무대서나 쓰이기도한다.

(시스템콜)

약 200여가지 시스템 콜을 사용할 수 있다.

사용하는데 방법을 알아보기 위해서는
# man 2 함수이름
이런식으로 메뉴얼을 볼수 있다. 우리는 화면에 출력할 write를 살펴보겠다.

(write 시스템콜)

ssize_t write(int fd, const void *buf, size_t count);
3개의 인자가 필요하다.
정리하면 buf에 있는 내용을 count만큼 fd로 전달한다.

이 내용을 C코드로 작성해보면 다음과 같다.

(c코드)

fd 는 표준 출력인 1로 주었고 문자열을 buf에 입력하고 문자열 수 14를 count에 입력하였다.
프로그램 실행 결과는 다음과 같다.

(실행 결과)

그렇다면 이러한 시스템콜이 printf에도 쓰이지 않았을까?
-> 그렇다! 우리가 사용했던 C코드로 만든 프로그램이 사용한 시스템콜을 확인해보면 된다.

strace -> 해당 프로그램이 사용하는 시스템콜 목록을 확인할 수 있다.

ltrace -> 사용하는 라이브러리를 보여준다.

(strace)

printf 가 사용된 프로그램에 write 시스템콜이 사용된 것을 확인할 수 있다.

지금까지 정리한 내용을 토대로 Hello, World!를 출력하는 프로그램을 어셈블 언어를 이용하여 작성해보겠다.

(어셈블 코드)

레지스트 eax에는 시스템콜 번호를 써준다. write의 시스템콜번호는 4번이므로 4를 입력해주었다.
그 다음으로는 인자를 차례로 적어주면된다.
ebx에는 fd의 값
ecx에는 버퍼에 담긴 내용 (여기서는 레이블을 이용해 주소값을 전달한다.)
edx에는 크기

그리고 마지막에 int는 정수형이 아니라 인터럽트를 뜻한다.
int 0x80은 시스템콜 인터럽트를 의미한다.
int 0x80  인터럽트가 걸리면 바로 eax를 참조하고 eax에 적힌 시스템콜번호를 확인하여 시스템콜을 수행하게 된다.

자! 컴파일하여 실행해보자!

(컴파일)

(실행)

잘 실행되는 것을 확인할 수 있다.

여기서 마지막에 Segementation 어쩌구 오류가 나오는데
우리가 프롤로그, 에필로그를 써주지 않아서 그렇다. 아직 우리가 공부하지 않았지만 시스템콜 중 exit를 이용하면 이 에러메세지가 안뜨게 종료시킬 수 있다.

그렇다면 exit를 추가해보자!

(exit(0) 추가)

이것도 똑같은 시스템 콜이므로
eax에 시스템 콜번호
그 다음 0으로 인자를 줄것이므로 ebx에는 0 그리고
int 0x80 으로 시스템콜 인터럽트를 걸면 된다.

(실행모습)

그렇게 되면 위와같이 실행이 정상적으로 종료된다.

시스템 공부에 들어서면서
바이너리 분석에 들어가 볼 것이다.

* 바이너리(실행파일)란?
 - 우리가 흔히 보는 윈도우즈의 .exe 확장자의 실행파일이라고 생각하면 된다.
 - 0과 1로 되어있는 기계어로 번역되있는 파일이다.

이 바이너리분석을 하기 위해서는 실행 파일이 어떻게 만들어지는지 공부할 필요가 있다.
즉,
다시말하면
프로그래밍된 코드가 어떻게 기계어로 번역되는지 이런 과정을 크게 Compile이라고 한다.
이 Compile 과정에 대해 알아보겠다.
우리는 C언어로 작성된 코드가 실행파일이 되는 과정을 살펴볼 것이다.

먼저! 간단하게 C코드를 작성한다. 

(sample.c 작성)

* gcc는 확장자를 보기 때문에 파일 이름 뒤에 .c를 붙여줘야한다.

만든 후 gcc를 이용해 컴파일을 해볼 것이다. gcc는 GNU C Compiler의 약자로 리눅스에서 제공하는 컴파일러이다.
아래처럼 컴파일 해본다.

(컴파일)

컴파일 완료되면 위와 같이 실행파일이 생성된것을 확인 해 볼 수 있다.
또 이 실행파일을 실행시키면 우리가 작성한 대로 Hello World 문구가 나오는 것을 확인 할 수 있다.

이 실행파일은 바이너리로 되어있기 때문에 vi 편집기 혹은 cat으로 볼 수 없고
헥스값을 볼 수 있는 xxd 데몬을 이용해서 볼 수 있다.

(바이너리 파일)

* gcc 뒤에 -o 옵션을 주어 우리가 원하는 파일이름으로 컴파일하여 실행파일을 만들 수 있다.

(-o 옵션)

* gcc 뒤에 -v 옵션을 주면 컴파일 과정이 화면에 그대로 출력된다.
우리는 gcc -v 옵션을 주어 컴파일이 이루어지는 과정을 그대로 살펴볼 것이다.

(-v 옵션)

위 화면을 보면 컴파일 과정이 주르르륵 나온 것을 볼 수 있다.
하나하나 과정을 짚어가며 살펴보겠다.

* 컴파일 과정

(1) 전처리 과정 : 컴파일 중 가장 먼저 이뤄지는 작업으로 매크로, #include 문장 해석을 한다.
전처리 : precompile

(-save-temps 옵션)

옵션을 추가하니 여러 부산(?)물들 파일이 생긴것을 확인 할 수 있다.

우리가 먼저 확인해볼 것은 sample.i (전처리 과정에서 생기는 파일) 이다.!

(sample.i 파일)

큰 변화가 없어보인다?...

전처리 과정에서 어떤 일이 일어나는지 직접 눈으로 확인해보기 위해 c코드를 조금 수정해보겠다.!
define문장을 추가해보자!

(define 문장 추가)

다시 컴파일 하겠다!

(재컴파일)

재컴파일 후
sample.i 파일을 확인해본다.

(sample.i 파일)

- define 문장이 사라지고 소스코드 안에 썻던 define이 100(우리가 설정했던 값)
으로 모두 치환되어 있는 것을 확인 할 수 있다.
-> 바로 이게 전처리기의 역할이다.

2. 어셈블 과정 : 전처리된 파일을 어셈블리 형태로 변환

(sample.s 파일)

sample.s 파일을 확인해보면 어셈블 언어로 바뀐것을 확인할 수 있다.

3. 컴파일 과정 : 어셈블 파일을 기계어(숫자)로 번역하는 과정이다. 정확히말하면 컴파일 과정은 이부분이지만 크게 말해 이 모든 과정을 컴파일이라고 통상적으로 말하곤 한다.

해당문구

(sample.o 파일)

파일을 보면 이제부터는 vi 편집기로 볼 수 없다. 이제부터는 바이너리이기 때문에 xxd 혹은 objdump 등 바이너리를 다루는 도구를 통해 봐야한다. objdump를 이용해 확인해보겠다.

(sample.o 파일 확인)

파일을 보면 .s 파일에서 봤던 어셈블 언어가 모두 바이너리로 바뀐것을 확인 할 수 있다.

4. 링크 단계 : 완벽한 실행파일을 생성한다. 이 때 필요한 라이브러리를 모두 합친다.

(a.out 파일 확인)

그렇다면 a.out 파일을 확인해보겠다.

(a.out 바이너리)

파일을 보면 왼쪽에는 메모리 주소인데 파일내용에서 해당 내용을 찾으려면(보통 파일구조 그대로 메모리로 올라가기 때문에) 대략 뒤 3자리를 참조하면된다. (항상 그런것은 아니다.)
확인해보면 3d0의 위치를 보자 

(3d0 위치)

3d0 위치에 우리가 확인했던 바이너리 문자를 볼 수 있다.

* 어셈블 언어로 코드를 작성해보고 컴파일 해보자!
Hellow World 를 출력하는 실행파일을 만들것이다. :)
nasm을 이용할 것이다! 그러기위해 .asm 확장자로 작성한다.

(sample.asm 파일 작성)

(sample.asm 내용)

컴파일 과정에서 어셈블 언어로 바꾸는 과정까지 우리가 직접 한 셈이다.
그러니 그 후 나머지 작업만 해주면 된다.

먼저 오브젝트 파일을 생성해야한다.(바이너리로 바꿔준 파일)
nasm을 이용하여 -f옵션 파일 타입 elf 로 명시한 후 sample.asm을 입력한다.

(sample.o 파일 생성)

그 후 우리가 printf 함수를 사용했으므로 이 함수의 라이브러리를 연결해주어야한다.
바로 링크단계이다.
여기서는 간단하게 static으로 구현해 볼것이다.

(링크 작업)

링크 작업이 끝나면 실행파일이 만들어지게 된다.

(실행파일)

실행 파일이 만들어진 것을 확인 할 수 있고
실행되는 것 또한 확인 할 수 있었다.