Code1018

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

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이 잘 출력된 것을 확인 할 수 있었다.

저번에 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으로 구현해 볼것이다.

(링크 작업)

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

(실행파일)

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