Pwnable (17. memcpy)

이번 포스트에서는 Pwnable의 memcpy 문제에 대해 다루겠다.

 

---

문제 코드는 다음과 같다.

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <signal.h>
#include <unistd.h>
#include <sys/mman.h>
#include <math.h>

unsigned long long rdtsc(){
        asm("rdtsc");
}

char* slow_memcpy(char* dest, const char* src, size_t len){
        int i;
        for (i=0; i<len; i++) {
                dest[i] = src[i];
        }
        return dest;
}

char* fast_memcpy(char* dest, const char* src, size_t len){
        size_t i;
        // 64-byte block fast copy
        if(len >= 64){
                i = len / 64;
                len &= (64-1);
                while(i-- > 0){
                        __asm__ __volatile__ (
                        "movdqa (%0), %%xmm0\n"
                        "movdqa 16(%0), %%xmm1\n"
                        "movdqa 32(%0), %%xmm2\n"
                        "movdqa 48(%0), %%xmm3\n"
                        "movntps %%xmm0, (%1)\n"
                        "movntps %%xmm1, 16(%1)\n"
                        "movntps %%xmm2, 32(%1)\n"
                        "movntps %%xmm3, 48(%1)\n"
                        ::"r"(src),"r"(dest):"memory");
                        dest += 64;
                        src += 64;
                }
        }

        // byte-to-byte slow copy
        if(len) slow_memcpy(dest, src, len);
        return dest;
}

int main(void){

        setvbuf(stdout, 0, _IONBF, 0);
        setvbuf(stdin, 0, _IOLBF, 0);

        printf("Hey, I have a boring assignment for CS class.. :(\n");
        printf("The assignment is simple.\n");

        printf("-----------------------------------------------------\n");
        printf("- What is the best implementation of memcpy?        -\n");
        printf("- 1. implement your own slow/fast version of memcpy -\n");
        printf("- 2. compare them with various size of data         -\n");
        printf("- 3. conclude your experiment and submit report     -\n");
        printf("-----------------------------------------------------\n");

        printf("This time, just help me out with my experiment and get flag\n");
        printf("No fancy hacking, I promise :D\n");

        unsigned long long t1, t2;
        int e;
        char* src;
        char* dest;
        unsigned int low, high;
        unsigned int size;
        // allocate memory
        char* cache1 = mmap(0, 0x4000, 7, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
        char* cache2 = mmap(0, 0x4000, 7, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
        src = mmap(0, 0x2000, 7, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);

        size_t sizes[10];
        int i=0;

        // setup experiment parameters
        for(e=4; e<14; e++){    // 2^13 = 8K
                low = pow(2,e-1);
                high = pow(2,e);
                printf("specify the memcpy amount between %d ~ %d : ", low, high);
                scanf("%d", &size);
                if( size < low || size > high ){
                        printf("don't mess with the experiment.\n");
                        exit(0);
                }
                sizes[i++] = size;
        }

        sleep(1);
        printf("ok, lets run the experiment with your configuration\n");
        sleep(1);

        // run experiment
        for(i=0; i<10; i++){
                size = sizes[i];
                printf("experiment %d : memcpy with buffer size %d\n", i+1, size);
                dest = malloc( size );

                memcpy(cache1, cache2, 0x4000);         // to eliminate cache effect
                t1 = rdtsc();
                slow_memcpy(dest, src, size);           // byte-to-byte memcpy
                t2 = rdtsc();
                printf("ellapsed CPU cycles for slow_memcpy : %llu\n", t2-t1);

                memcpy(cache1, cache2, 0x4000);         // to eliminate cache effect
                t1 = rdtsc();
                fast_memcpy(dest, src, size);           // block-to-block memcpy
                t2 = rdtsc();
                printf("ellapsed CPU cycles for fast_memcpy : %llu\n", t2-t1);
                printf("\n");
        }

        printf("thanks for helping my experiment!\n");
        printf("flag : ----- erased in this source code -----\n");
        return 0;
}

## 문제 해석 :

바이트 단위로 처리하는 slow_memcpy() 함수와 블록 단위로 처리하는 fast_memcpy() 함수가 있다. 프로그램이 사용자로부터 10개의 동적할당할 사이즈를 입력 받고 10번 동안 무사히 slow_memcpy()와 fast_memcpy()를 마치면 flag를 획득할 수 있는 것으로 보인다.

## 문제 풀이 :

프로그램을 실행해서 10개의 사이즈를 입력해보겠다.

5번째 실행에서 오류 발생

10개의 사이즈 값을 입력했으나 프로그램이 5번째에서 오류가 발생했다.

 

5번째 넘어갔으니 아마 64 바이트 블록단위로 처리하는 fast_memcpy()에서 오류가 발생한 것 같다. fast_memcpy() 코드의 주요부분을 다시 살펴보자면 다음과 같다.

size_t i;
// 64-byte block fast copy
if(len >= 64){
	i = len / 64;
	len &= (64-1);
	while(i-- > 0){
		__asm__ __volatile__ (
		"movdqa (%0), %%xmm0\n"
		"movdqa 16(%0), %%xmm1\n"
		"movdqa 32(%0), %%xmm2\n"
		"movdqa 48(%0), %%xmm3\n"
		"movntps %%xmm0, (%1)\n"
		"movntps %%xmm1, 16(%1)\n"
		"movntps %%xmm2, 32(%1)\n"
		"movntps %%xmm3, 48(%1)\n"
		::"r"(src),"r"(dest):"memory");
		dest += 64;
		src += 64;
	}
}

"movdqa"라는 어셈블리어 함수가 사용된다.

movdqa : 16바이트 데이터를 옮길 때 사용하는 함수로, 옮길 때에는 16바이트만큼 정렬해줘야 한다.

즉, movdqa는 정렬된 16바이트의 데이터를 옮겨준다.

 

fast_memcpy() 함수에 주소를 출력하는 코드를 추가하여 컴파일을 실행해보겠다.

fast_memcpy() 수정

다시 실행해보겠다.

실행 결과

5번째의 주소가 0x86384a8로 끝나는 것을 알 수 있다.  이를16로 나뉘면 다음과 같다.

나머지 = 8

나머지가 8가 나온 것을 확인할 수 있다. 즉, 64(4번째)를 입력했을 때의 128(5번째)의 주소값이 16의 배수가 아니다.

 

그럼 4번째 사이즈 값에 72(64 + 8)를 입력하고 실행해보겠다.

실행 결과

6번째 사이즈로 넘어간 것을 확인할 수 있다. 마찬가지로 6, 7, 8, 9, 10번째 사이즈 값에도 +8을 하면 해당 문제를 해결할 수 있다.

## 최종 결과 : 

### 공격문 : 8 16 32 72 136 264 520 1032 2056 5004

### 실행 결과 :

공격 실행

Flag = 1_w4nn4_br34K_th3_m3m0ry_4lignm3nt