Code1018

이 자료 또한 어떠한 문서를 참조했다고 나와있었다.

(참조 문서)

heap overlapping 2번째 분석을 시작하자!

(5개의 힙)

뒷자리가 8인 것을 보면 눈치 채겠지만, off-by-one에 취약할 것이다.

(각 힙영역의 범위)

각 힙영역을 표시하기 위해 해당 영역에 문자들을 넣어주었다.

(문자 입력)

: 그렇기에 p4를 free해준 것이다.

(free)

p1을 이용해 p2의 청크 사이즈를 조작한다.

(청크 사이즈 조작)

(p2 free)

그 후 malloc을 통해 p3을 포함할만큼 커다란 영역을 할당받는다면?

(큰 영역 할당)

그렇게 되면 p3영역이 포함된 영역을 할당해준다.

(할당된 영역)

현재 p3에 들어있는 데이터

(p3의 데이터)

그 후 p6을 F로 1500 글자 채워준다.

(F로 채우기)

그렇게 되면 500자가 p3영역을 침범하게 되어 p3 데이터 앞부분이 F로 채워지게 된다.

(확인)

확인을 통해 p3가 중첩된 영역을 할당받은 것을 확인 할 수 있다.

해당 문서를 먼저 읽어보았다.

(참고 문서)

먼저 3개의 malloc 주소를 할당받는다.

(malloc)

그 후 각각의 heap 영역을 표시하기 위해 아래와 같은 작업을 한다.

(영역 표시)

그리고 p2를 free해준다.

(free)

(아직 우리가 해당 주소를 가지고 있으므로 p2에!)

(적어줄 사이즈)

(SIZE 조작)

변화 과정을 메모리에서 살펴보면

(덮어쓰기 전)

(덮어쓴 후)

그렇다면 여기서 malloc(0x180)을 한다면?

(malloc(0x180))

return 된 주소를 확인해보자.

(return 된 주소)

(return 영역)

덮어쓰여진 것을 한번 테스트해보자!

(4로 덮어쓰기)

그러면 p4의 영역을 4로 가득채우면?

(결과)

그러면 p3을 3으로 다시 덮어쓰면?

(3으로 덮어쓰기)

(결과)

이 방법은 The Forgotten Chunks 문서에 나와있다.

이 공격으로 스택영역의 주소를 malloc으로 받아서, return 주소를 덮어써서 임의의 코드를 실행해 볼 것이다.

(임의의 코드)

먼저, 스택영역에 가짜 청크의 구조를 만들어야한다.

(가짜청크 영역)

가짜 청크 영역을 잡아둔다.

그 후 우리가 이용할 chunk를 하나 만든다.

(chunk 생성)

알다시피, 정확한 chunk의 주소를 구하기 위해서는 2 WORD를 빼줘야한다.

(진짜 chunk 주소)

이 모든 것은 아래의 small bin corruption check를 우회하기 위한 것이다.

(small bin corruption check)

가짜 청크에 값들을 넣어준다.

(조건 우회)

(메모리 모습)

그 후 1000사이즈로 다시 malloc한다.

(malloc)

그리고 free!

(free)

그렇게 되면 아래와 같은 모습이 된다.

(free된 모습)

다른 large bin 영역의 사이즈로 다시 malloc 한다.

(malloc)

그리고 다시 victim 청크를 보면

(victim 청크)

이제 victim 청크의 bk주소에 스택버퍼1의 주소를 넣으면 된다.

(bk 조작)

그 후 victim 청크의 모습을 보면

(victim 청크)

사이즈는 100으로 malloc 한다.

(malloc)

그러면 지금 스택버퍼1을 보면?

(스택버퍼1)

이제 그다음 malloc(100)을 하면 우리의 스택버퍼1 차례이다.

(malloc)

p4에 스택버퍼1의 주소가 들어간다.

(결과)

그렇다면 이제 이걸 이용해서 ret 주소를 덮어쓸 것이다.

(ret 덮어쓰기)

직접 확인해보니 return 주소까지 72바이트 떨어진 자리였다.

(확인)

ret 주소에 jackpot 함수 주소가 들어가 있다.

(임의의 코드 실행)

결과적으로 마지막에 jackpot 함수(임의의 코드)가 실행되었다.

malloc으로 시작한다.

(malloc)

(실제 사용 가능한 사이즈)

실제 사용 가능한 사이즈는 어떻게 될까?

(실제 사용 가능한 사이즈)

실제 사용 가능한 사이즈는 0x8 바이트 더 쓸수 있게 나와있는데, 이는 이전 포스트 글에서 설명했으므로 넘어갈 것이다. ( malloc의 사용가능영역 이라는 글에 정리해 두었다. )

(추가 malloc)

여기서 b 영역의 사이즈를 확인해보기 위해 포인터를 이용했다.

(b chunk size 포인터)

(gdb 메모리 확인)

그 후 b를 free해준다.

(free(b))

c chunk의 header에서 PREV_SIZE 영역에 이전 chunk가 b이므로 b가 해제된 순간 b의 사이즈가 c chunk header에 적히게 된다.

(PREV_SIZE)

그렇기에 b주소 + 0x200 의 위치에 0x200 을 적어줘야한다.

(check 우회)

해당 위치에 0x200을 넣는다.

(확인)

그리고 b chunk 헤더에 있는 chunk size를 확인해보면

(b chunk size)

이제 여기서 한바이트를 덮어쓰면

(덮어쓰기)

여기서는 편하게 배열의 인덱스로 접근하여 적었다. 실제에서는 문자열을 이용해 null을 입력한다.

(덮어쓴 모습)

아까 b chunk 크기보다 작은 크기로

(malloc)

이 값이 우리가 조작한 PREV_SIZE 위치에 적히게 된다.

(조작된 PREV_SIZE)

b1이 쓰고 남은 그 뒤를 할당받는다.

(b2 malloc)

b2의 내용이 원래 B로 채워진 값들이었다고 치자.

(B로 채우기)

(현재 b2의 값)

여기서 b1과 c를 free한다.

(free)

그 후 다시 malloc을 통해 0x300( 원래 b 사이즈 + 원래 c 사이즈)의 크기로 요청을 한다면

(malloc)

그 후에 b2의 값을 확인해보면?

(b2의 내용)

이것이 구조체여서 함수값을 조작할 수도 있고 가능성은 넓다.

간단하게 malloc으로 0x10과 0x18 사이즈로 두개를 할당받는 코드를 만들었다.

(테스트코드)

그리고 malloc_usable_size 함수로 사용가능한 크기를 확인해보았다.

(확인 결과)

gdb를 통해 메모리 모습을 확인해보았다.

(메모리 모습)

먼저 malloc을 해준다.

(malloc)

이제 free의 인자로 넘길 포인터 변수를 만들어준다.

(포인터 변수 생성)

stack영역에는 비교적 우리가 값을 적기 쉽기 때문에 stack영역에 가짜 청크를 만들어 준 것 같다.

(가짜 청크를 위한 메모리 공간 확보)

그 다음으로 가짜 청크를 만들어주는 작업이다.

(가짜 청크 생성)

free시 청크 뒤에 있는 청크의 사이즈를 검사한다. 그렇기에 정상적인 사이즈를 넣어야한다.

(검사 조건)

SIZE_SZ란

(SIZE_SZ)

av->system_mem 보다 작아야한다는 것

(system_mem)

이 자료에서는 0x1234라는 값을 넣어주었다.

(두번째 청크 크기 설정)

이제 이 주소를 free 시키기 위해 포인터 변수에 이 주소를 먼저 넣어야한다.

(주소 입력)

그 후 free 해준다.

(free)

이제 다시 malloc(0x30)을 하면 fastbin리스트에서 0x40의 주소를 찾아가 현재 있는 a의 주소를 return하게 되는 것이다.

(malloc)

공격 결과를 확인해보면 다음과 같다.

(공격 성공)

먼저 글로벌 변수 chunk0_ptr을 선언해준다.

(글로벌 변수)

malloc_size = 0x80

(malloc)

fd와 bk를 설정해준다.

(fd 설정)

(bk 설정)

(fd, bk 설정)

(우회방법)

두번째 청크의 헤더를 바꾸기 위해 포인터로 직접 주소에 접근한다.

(헤더 설정)

free를 한다!

(free)

free전 chunk0_ptr에 있는 값이다.

(free 전)

free 후를 비교해보면

(free 후)

글로벌변수[3] 으로 직접 이 값을 바꿀 수 있다.

(공격)

그렇게 되면 이제 글로벌변수[3]에 해당 victim_string의 주소를 넣어주면

(공격)

값을 직접 쓸 수 있다.

(메모리 작성)

(공격 모습)

오늘 분석한 자료는 이전 포스팅에서 다루었던 fastbin_dup을 이용하여
malloc으로 할당받는 주소를 우리가 원하는 주소로 할당받는 것이다.

이번 자료에서는 그 주소를 stack 영역의 주소로 할당받는 것이 목적이다.

fastbin_dup과 같이, free list가 a -> b -> a 이러한 상황을 만들어야한다.
같은 chunck를 free 2번 시킨 후 하나를 다시 malloc으로 받은 후 그 주소에 접근할 수 있으므로 다음 chunk를 가리키는 포인터를 조작하는 방법이다.

이 기술을 직접 사용하기 위해서는
free 3번(같은 chunk로 2번), malloc으로 double free한 chunk를 받아오거나 double free한 chunk에 접근 할 수 있는 상황과 그 조작한 chunk를 malloc 시킬 수 있는 상황이어야한다.
그렇다면 stack 주소뿐 아니라 다른 주소로도 malloc을 이용해 받을 수 있다.
(단, chunk의 구조체중 size 멤버가 적절해야한다.)

fastbin_dup_into_stack 자료를 분석해보자.

먼저 주소로 받을 위치는 stack_var의 주소이다.

(우리의 목적 주소)

여기서 +8을 해준 주소를 목적이라고 한 것은 heap의 chunk 구조를 보면 앞의 8바이트가 chunk size정보가 들어있는 위치이기 때문이다. 

먼저, fastbin_dup과 같이 3개의 malloc을 해준다.

(3개의 malloc)

fastbin을 이용할 것이기에 8바이트를 할당한다.
최소 16바이트이기 때문에 16바이트의 user data 영역이 생기고 8바이트의 size, 8바이트의 prev_size영역으로 총 32바이트, 총 chunk의 크기는 0x20일 것이다.

첫번째 free 해준다.

(첫번째 free)

b를 free해준 뒤 a를 free해준다.

(free)

여기서 malloc을 해주어 a의 주소를 d에 넣고, 다시 malloc을 해준다.

(malloc)

그렇기에 stack_var주소 위치에 0x20을 넣는다.

(chunk 총 크기)

그렇기에 d의 sizeof의 값이 8바이트이기에 sizeof(d)를 해주었다.

(fd 포인터 조작)

메모리의 상황은 다음과 같다.

(메모리 상황)

이번에 다시 malloc을 하게 되면 stack 주소가 반환되는 것이다.

(stack 주소 malloc)

(stack 주소 반환)

(* 위의 캡쳐 사진은 따로따로 찍은 것으로 gdb메모리 상황과 stack 주소 반환 결과가 같지 않다.)

(fast bin 구조)

먼저 3개의 chunk를 할당한다.

(3개의 malloc 할당)

그 후 a를 free해준다.

(a chunk free)

대신 b를 free해준다.

(b chunk free)

그러면 우리는 a를 다시 free시킬 수 있게 된다.

(a chunk 두번째 free)

지금 이 상황의 메모리를 보자

(메모리 상황)

fastbin에는 a -> b -> a 이렇게 들어있다. 그렇기에 a의 주소(6000)에 b의 주소(6020)가 들어있고,
b의 주소인 6020의 다음 노드는 6000 으로 설정되어 있는 것이다.

여기서 다시 3개의 malloc을 해보면 결과는 아래와 같이 a, b, a의 주소가 나오고 결과적으로 a의 주소가 두번 malloc이 되는 상황이 나온다.

(결과)

how2heap의 첫번째 분석 자료는 first_fit 이다.
first fit이란 메모리 할당 전략 중 하나이다.

대표적으로 3가지가 있는데
first fit, best fit, worst fit 이 있다.

기본적으로 리눅스에서 heap 할당 관련해서는 first fit전략을 취하고 있다.

first fit이란 할당 가능한 메모리 영역을 발견하면 바로 할당하는 방식이다.
best fit은 internal fragment가 최대한 작게  딱 맞는 크기의 영역을 할당하는 방식이고
worst fit은 정반대로 최대한 널널한 영역을 할당하는 방식이다.

first fit 프로그램은 취약점을 보여주는 프로그램은 아니고
리눅스의 메모리 할당방식을 직접 보여주는 프로그램이다.

과정을 따라가며 분석해보겠다.

(메모리 할당)

a와 b에 할당을 해준다.

(메모리 할당 확인)

프로그램 실행시 확인해 볼 수 있다.
첫번째로 할당한 영역의 주소는 46010 이고 (뒷자리만 부를것이다.)

두번째로 할당한 영역의 주소는 46220 이었다.

(할당된 메모리 사용)

그리고 할당된 주소를 사용한다. a라는 주소에 문자열을 입력해준다.

(메모리 해제)

다시 이어서 malloc을 해준다.

(malloc)

확인을 위해 이번엔 방금 할당된 주소를 사용해본다.

(메모리 사용)

c변수 방금 할당했던 주소가 담긴 변수를 주소값과 안에 담긴 문자열을 출력해본다.

(같은 주소)

결과는 처음 할당했던 주소가 46010이었는데 해제(free)해준 뒤 다시 malloc을 통해 받은 주소가 똑같은 46010이다. 그리고 그 안에 있는 문자열은 thist is C! 로 정확히 같은 주소라는 것을 보여준다.