dreamhack의 [Background: Library - Static Link vs. Dynamic Link]를 토대로 정리하였으며, 추가적으로 덧붙인 내용입니다.

 

Dynamic Link에서는 PLTGOT이 필요함. Static Link 방식으로 컴파일하면 라이브러리가 프로그램 내부에 있어 별도로 함수의 주소를 알아내는 과정이 필요하지 않음. 그러나 Dynamic Link 방식으로 컴파일하면 라이브러리가 외부에 위치해 함수 주소를 알아오는 과정이 필요하게 됨.

 

PLT(Procedure Linkage Table)이란?

외부 library 함수를 사용할 수 있도록 연결해주는 table

PLT를 통해 다른 라이브러리에 있는 함수를 호출해 사용할 수 있음

 

GOT(Global Offset Table)이란?

PLT가 참조하는 table

PLT에서 호출하는 resolve 함수를 통해 구한 library 함수들의 절대 주소가 저장되어 있음

 


PLT와 GOT의 호출 관계

출처: https://bpsecblog.wordpress.com/2016/03/07/about_got_plt_1/

Dynamic Link 방식에서 프로그램이 함수를 호출하게 되면 PLT를 가장 먼저 참조하게 됨

PLT에서 GOT로 jump하게 되며, GOT에 기록된 실제 함수 주소(library에 기록되어 있음)를 호출하여 함수가 동작하게 됨

 

이는 1번째 호출인지, 아닌지에 따라 동작 과정에 차이가 있음

바이너리가 실행되면 ASLR에 의해 library가 임의의 주소에 mapping 됨
해당 상태에서 library 함수를 호출하면, 함수의 이름을 바탕으로 library에서 symbol들을 탐색하고 해당 함수의 정의를 발견하였을 때 그 주소로 실행 흐름을 옮김
→ 이 과정을 runtime resolve라고 부름

 

만약, 반복적으로 호출되는 함수 정의를 매번 탐색하게 된다면 이는 매우 비효율적임

이에 GOT이라는 table에 resolve된 함수의 주소를 저장하여 사용하고 있음 → 저장된 주소를 꺼내쓰기만 하면 되기 때문!

 

결론적으로 함수에 대해 1번째 호출하게 된다면, 다음과 같이 호출흐름을 그려볼 수 있음

✨함수 호출 → PLT 이동 → GOT 참조 → PLT로 재이동 → _dl_runtime_resolve 수행 → GOT에 실제 주소 저장 후 실제 함수 주소로 분기

출처: https://bob3rdnewbie.tistory.com/190

 

반대로, 함수의 최초 호출이 진행된 후 재호출하게 된다면 GOT에 저장된 실제 함수 주소를 참조하기만 하면 됨

✨ 함수 호출 → PLT 이동 → GOT 참조 → 실제 함수 주소로 jump

출처: https://bob3rdnewbie.tistory.com/190

 

위의 상황을 모두 조합하여 흐름을 figure로 확인해보면 아래와 같음

출처: https://bnzn2426.tistory.com/27


실습으로 알아보는 resolve 전후 과정

실습 코드

cpp
닫기
// Name: got.c // Compile: gcc -o got got.c -no-pie #include <stdio.h> int main() { ​​puts("Resolving address of 'puts'."); ​​puts("Get address from GOT"); }
  • 코드는 단순히 puts 함수를 2번 호출하고 있음
    • 1번째 puts 함수2번째 puts 함수의 동작 과정은 상이할 것임! (1번째 puts 함수에서는 resolve 과정이 수행되기 이고, 2번째 puts 함수에서는 resolve 과정이 끝난 상태일 것)

 

gdb 동적 분석

main 함수

cpp
닫기
pwndbg> disass main Dump of assembler code for function main: ​​​0x0000000000401136 <+0>: endbr64 ​​​0x000000000040113a <+4>: push rbp ​​​0x000000000040113b <+5>: mov rbp,rsp ​​​0x000000000040113e <+8>: lea rdi,[rip+0xebf] # 0x402004 ​​​0x0000000000401145 <+15>: call 0x401040 <puts@plt> ​​​0x000000000040114a <+20>: lea rdi,[rip+0xed0] # 0x402021 ​​​0x0000000000401151 <+27>: call 0x401040 <puts@plt> ​​​0x0000000000401156 <+32>: mov eax,0x0 ​​​0x000000000040115b <+37>: pop rbp ​​​0x000000000040115c <+38>: ret End of assembler dump.
  • main+15, main+27에서 puts 함수를 호출하고 있음

 

puts 함수

cpp
닫기
pwndbg> disass puts Dump of assembler code for function puts@plt: ​​​0x0000000000401040 <+0>: endbr64 ​​​0x0000000000401044 <+4>: bnd jmp QWORD PTR [rip+0x2fcd] # 0x404018 <puts@got.plt> ​​​0x000000000040104b <+11>: nop DWORD PTR [rax+rax*1+0x0] End of assembler dump.

resolve되기 전

cpp
닫기
pwndbg> start pwndbg> got GOT protection: Partial RELRO | GOT functions: 1 [0x404018] puts@GLIBC_2.2.5 -> 0x401030 ◂— endbr64

binary를 실행한 직후의 GOT 주소를 확인해보면 0x401030을 가리키고 있음(실제 puts 함수 주소가 아님)

 

1번째 puts 함수를 호출하는 부분(main+15)에 bp를 걸어 puts 함수을 step in 해보면 

cpp
닫기
pwndbg> b *main+15 pwndbg> c pwndbg> si ​​​0x401040 <puts@plt> endbr64 ​► 0x401044 <puts@plt+4> bnd jmp qword ptr [rip + 0x2fcd] <0x401030> ​​​​↓ ​​​0x401030 endbr64 ​​​0x401034 push 0 ​​​0x401039 bnd jmp 0x401020 <0x401020> ​​​​↓ ​​​0x401020 push qword ptr [rip + 0x2fe2] <_GLOBAL_OFFSET_TABLE_+8> ​​​0x401026 bnd jmp qword ptr [rip + 0x2fe3] <_dl_runtime_resolve_xsavec> ​​​​↓ ​​​0x7ffff7fe7bc0 <_dl_runtime_resolve_xsavec> endbr64 ​​​0x7ffff7fe7bc4 <_dl_runtime_resolve_xsavec+4> push rbx ​​​0x7ffff7fe7bc5 <_dl_runtime_resolve_xsavec+5> mov rbx, rsp ​​​0x7ffff7fe7bc8 <_dl_runtime_resolve_xsavec+8> and rsp, 0xffffffffffffffc0

puts@plt+4에서 앞서 확인한 0x401030으로 jump하는 것을 볼 수 있음

이후에는 _dl_runtime_resolve_xsavec 함수가 실행되는데, 해당 함수가 실행되면서 puts 함수의 실제 주소가 구해짐

_dl_runtime_resolve_xsavec 함수를 통해 구한 주소는 GOT table에 저장됨

 

cpp
닫기
pwndbg> finish pwndbg> got GOT protection: Partial RELRO | GOT functions: 1 [0x404018] puts@GLIBC_2.2.5 -> 0x7ffff7e46420 (puts) ◂— endbr64

GOTputs 함수의 실제 주소가 저장된 것을 확인할 수 있음


resolve된 후

1번째 puts 함수를 호출할 때 _dl_runtime_resolve_xsavec 함수를 통해 실제 puts 함수 주소를 구해 GOT에 저장했음

2번째 puts 함수를 호출할 때에는 1번째 puts 함수를 호출하며 구한 주소가 GOT에 저장되어 있으므로 바로 puts 함수를 실행할 수 있음

cpp
닫기
pwndbg> b *main+27 pwndbg> c pwndbg> si 0x401040 <puts@plt> endbr64 ​​​0x401044 <puts@plt+4> bnd jmp qword ptr [rip + 0x2fcd] <puts> ​​​​↓ ​​​0x7ffff7e46420 <puts> endbr64 ​​​0x7ffff7e46424 <puts+4> push r14 ​​​0x7ffff7e46426 <puts+6> push r13 ​​​0x7ffff7e46428 <puts+8> push r12 ​​​0x7ffff7e4642a <puts+10> mov r12, rdi ​​​0x7ffff7e4642d <puts+13> push rbp ​​​0x7ffff7e4642e <puts+14> push rbx ​​​0x7ffff7e4642f <puts+15> call *ABS*+0x9f630@plt <*ABS*+0x9f630@plt> ​​​0x7ffff7e46434 <puts+20> mov r13, qword ptr [rip + 0x167b0d]

PLT & GOT의 보안 취약점

PLT에서 GOT을 참조하여 실행 흐름을 옮길 때, GOT의 값을 검증하지 않음

앞선 실습에서 1번째 puts 함수를 호출하며 GOT에 저장한 puts 함수의 실제 주소를 변조할 수 있다면, 2번째 puts 함수를 호출할 때 puts 함수 대신 다른 코드가 실행되도록 할 수 있음(GOT Overwrite)

 

실습 코드를 약간 수정하여 /bin/sh를 호출할 수 있는 get_shell 함수를 삽입함

cpp
닫기
// Name: got.c // Compile: gcc -o got got.c -no-pie #include <stdio.h> void get_shell(){ ​​​​​​​​system("/bin/sh"); } int main() { ​​puts("Resolving address of 'puts'."); ​​puts("Get address from GOT"); }
cpp
닫기
pwndbg> info func All defined functions: Non-debugging symbols: 0x0000000000401000 _init 0x0000000000401050 puts@plt 0x0000000000401060 system@plt 0x0000000000401070 _start 0x00000000004010a0 _dl_relocate_static_pie 0x00000000004010b0 deregister_tm_clones 0x00000000004010e0 register_tm_clones 0x0000000000401120 __do_global_dtors_aux 0x0000000000401150 frame_dummy 0x0000000000401156 get_shell 0x0000000000401172 main 0x00000000004011a0 __libc_csu_init 0x0000000000401210 __libc_csu_fini 0x0000000000401218 _fini pwndbg> disass puts Dump of assembler code for function puts@plt: ​​​0x0000000000401050 <+0>: endbr64 ​​​0x0000000000401054 <+4>: bnd jmp QWORD PTR [rip+0x2fbd] # 0x404018 <puts@got.plt> ​​​0x000000000040105b <+11>: nop DWORD PTR [rax+rax*1+0x0] End of assembler dump.
cpp
닫기
pwndbg> b *main+27 Breakpoint 1 at 0x40118d pwndbg> r pwndbg> set *(unsigned long long*) 0x404018=0x401156 pwndbg> c Continuing. $ ls got got.c Return_Address_Overwrite ReturnToShellcode ssp_000 ssp_001 $
  • gdb에서 값을 변경하고 싶을 때에는 set 명령을 이용할 수 있음
    • puts@got(0x404018)get_shell 함수 주소(0x401156)으로 변조하면 2번째 puts 함수를 호출하였을 때 /bin/sh 쉘이 출력되는 것을 확인할 수 있음

새롭게 알게 된 것

libc의 모든 함수들은 정해진 순서가 있으며, 외부 바이너리에서 함수를 호출하면 공유 라이브러리 내부의 순서를 우선시하여 index를 부여함

'Hacking Study > Pwnable' 카테고리의 다른 글

Static Link vs Dynamic Link  (0) 2023.03.02
Stack Canary  (2) 2023.03.01
dreamhack의 [Background: Library - Static Link vs. Dynamic Link]를 토대로 정리하였으며, 추가적으로 덧붙인 내용입니다.

 

Library란?

컴퓨터 시스템에서 프로그램들이 함수나 변수 등을 공유하여 사용할 수 있도록 하는 것
  • 대표적으로 printf, scanf, strlen, memcpy, malloc 등의 함수가 있음
  • 자주 사용되는 함수들의 정의를 묶어 하나의 라이브러리 파일로 만들고, 이를 여러 프로그램이 공유하여 사용할 수 있도록 지원하고 있음
  • Library를 사용하면 같은 함수를 반복적으로 정의하지 않아도 손쉽게 활용할 수 있어 코드 개발의 효율을 높임
    • 각 언어에서 범용적으로 많이 사용되는 함수들은 표준 라이브러리가 제작되어 있어 호출만 하면 사용할 수 있음
  • C의 표준 Library인 libc는 ubuntu에 기본으로 탑재되어 있으며, /lib/x86-64-linux-gnu/libc-2.27.so에 존재함

해당 경로에서 위와 같은 방법으로 찾아볼 수 있으나, 필자는 ubuntu 버전차로 libc-2.27.so는 존재하지 않음

 

C의 printf 함수

 

libc에 정의된 printf 함수의 source code는 다음과 같음

cpp
닫기
/* Copyright (C) 1991-2018 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with the GNU C Library; if not, see <http://www.gnu.org/licenses/>. */ #include <libioP.h> #include <stdarg.h> #include <stdio.h> #undef printf /* Write formatted output to stdout from the format string FORMAT. */ /* VARARGS1 */ int __printf (const char *format, ...) { ​​va_list arg; ​​int done; ​​va_start (arg, format); ​​done = vfprintf (stdout, format, arg); ​​va_end (arg); ​​return done; } #undef _IO_printf ldbl_strong_alias (__printf, printf); /* This is for libg++. */ ldbl_strong_alias (__printf, _IO_printf);

출처: https://github.com/lattera/glibc/blob/master/stdio-common/printf.c

 

 

만약 libraryprintf 함수가 정의되어 있지 않다면, printf("Hello, World")를 출력하고자 할 때 printf 함수의 원형을 함께 정의해주어야만 사용할 수 있음

cpp
닫기
#include <libioP.h> #include <stdarg.h> #include <stdio.h> #undef printf int __printf (const char *format, ...) { ​​va_list arg; ​​int done; ​​va_start (arg, format); ​​done = vfprintf (stdout, format, arg); ​​va_end (arg); ​​return done; } #undef _IO_printf ldbl_strong_alias (__printf, printf); /* This is for libg++. */ ldbl_strong_alias (__printf, _IO_printf); int main(){ printf("Hello, World"); ​​​​return 0; }

정확하진 않지만 대략적으로 이러한 형태로 사용해야 할 것임

사용하는 모든 함수에 대해 매번 정의하는 것은 매우 비효율적임

그렇기 때문에 자주 사용하는 함수들에 대해 미리 정의해둔 libc를 불러와 사용할 수 있으면 코드 개발에 있어 효율이 높아지게 되는 것!

 

💡 그렇다면 libc를 어떻게 연결해준다는 것인지에 대한 의문이 발생할 수 있음

Link란?

프로그램에서 어떤 라이브러리의 함수를 사용하고자 할 때, 호출된 함수와 실제 라이브러리 함수를 연결해주는 과정

 

리눅스에서 C source code는 전처리 → 컴파일 → 어셈블 과정을 거쳐 ELF형식을 갖춘 Object File로 번역됨

쉽게 말해, 인간의 언어를 컴퓨터에게 전달하기 위해서는 고급언어(인간 친화적인 언어)인 C, C++, Java 등의 언어로 작성한 소스코드를 0과 1로만 구성된 기계어로 번역하는 과정이 필요함

이를 변환해주는 과정을 컴파일이라고 지칭하며, 세부적으로 전처리 → 컴파일 → 어셈블 과정을 거침

출처: https://bpsecblog.wordpress.com/2016/03/07/about_got_plt_1/

 

✨ 고급 언어와 저급 언어

 

어셈블 예

cpp
닫기
// Name: hello-world.c // Compile: gcc -o hello-world hello-world.c #include <stdio.h> int main() { ​​puts("Hello, world!"); ​​return 0; }

해당 코드는 

cpp
닫기
gcc -c hello-world.c -o hello-world.o

와 같은 방식으로 어셈블할 수 있음

 

Object File은 실행 가능한 형식을 갖추고 있지만, library 함수들의 정의가 어디에 존재하는지 알 수 없어 실행 불가함

cpp
닫기
// Path: /usr/include/stdio.h ... /* Write a string, followed by a newline, to stdout. This function is a possible cancellation point and therefore not marked with __THROW. */ extern int puts (const char *__s); ...

puts 함수에 대한 선언은 /usr/include/stdio.h에 정의되어 있음

그러나 puts 함수 내부 코드에 대해서는 정의되어 있지 않음

이와 관련된 정보들을 찾아 최종 실행 파일에 기록하는 것이 link 과정에서 일어나는 것임!

 

코드에 대해 완전히 컴파일하고, link 되기 전후 과정을 비교해보면 다음과 같음

cpp
닫기
$ gcc -o hello-world hello-world.c $ readelf -s hello-world | grep puts ​​​​​2: 0000000000000000 0 FUNC GLOBAL DEFAULT UND puts@GLIBC_2.2.5 (2) ​​​​46: 0000000000000000 0 FUNC GLOBAL DEFAULT UND puts@@GLIBC_2.2.5 ​​​​ $ ldd hello-world ​​​​​​​​linux-vdso.so.1 (0x00007ffec3995000) ​​​​​​​​libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6 (0x00007fee37831000) ​​​​​​​​/lib64/ld-linux-x86-64.so.2 (0x00007fee37e24000)

libc에 대해 source code와 함께 컴파일하지 않았음에도 불구하고 libc에서 puts 함수에 대해 탐색할 수 있었던 것은, libc 파일이 존재하는 /lib/x86_64-linux-gnu/표준 library 경로에 포함되어 있기 때문임

gcc 컴파일러는 source code를 컴파일할 때 표준 library 경로에 있는 모든 library File들을 탐색함

이렇게 Link 과정을 거치고 나면 binary에서 puts 함수를 호출할 때, puts 함수가 정의되어 있는 libc에서 puts 함수의 코드를 찾아 실행하게 됨

🔍 요약
Link/Linking은 컴파일 이후 프로그램을 실행하기 이전에, 프로그램이 사용하는 다른 프로그램이나 library를 가져와 연결하는 과정

표준 libc로 지정한 파일 이외에도 사용자가 작성한/보유한 파일에 대해 직접 linking 해줄 수도 있음

실행 흐름 정리)
binary에서 puts 함수 호출 → libc에서 puts 함수 코드 찾아 실행 → binary에서 puts 함수의 다음 코드 실행
참고) 표준 Library 경로 탐색 명령
cpp
닫기
$ ld --verbose | grep SEARCH_DIR | tr -s ' ;' '\n' SEARCH_DIR("=/usr/local/lib/x86_64-linux-gnu") SEARCH_DIR("=/lib/x86_64-linux-gnu") SEARCH_DIR("=/usr/lib/x86_64-linux-gnu") SEARCH_DIR("=/usr/lib/x86_64-linux-gnu64") SEARCH_DIR("=/usr/local/lib64") SEARCH_DIR("=/lib64") SEARCH_DIR("=/usr/lib64") SEARCH_DIR("=/usr/local/lib") SEARCH_DIR("=/lib") SEARCH_DIR("=/usr/lib") SEARCH_DIR("=/usr/x86_64-linux-gnu/lib64") SEARCH_DIR("=/usr/x86_64-linux-gnu/lib")

Link 종류

Library동적 library, 정적 library로 구분되며, 동적 librarylink하는 것을 Dynamic Linking, 정적 librarylink하는 것을 Static Link라고 부름

 

Dynamic Link

동적 link된 binary를 실행하면 동적 library가 프로세스의 메모리에 mapping됨

실행 중 library의 함수를 호출하면, mapping된 library에서 호출할 함수의 주소를 찾고 해당 함수를 실행함

동적 library공유 library라고도 부름

 

Dynamic Compile

cpp
닫기
$ gcc -o dynamic hello-world.c -no-pie

file 명령어를 통해 확인해보면 dynamically linked로 연결된 것을 확인할 수 있음

 

Static Link

binary에 정적 library의 모든 함수가 포함됨

함수를 호출할 때 library를 참조하는 것이 아니라 binary에 원래 존재하는 함수를 호출하는 것처럼 호출할 수 있음

Library에서 원하는 함수를 찾지 않아도 되지만 여러 binary에서 library를 사용하면 해당 library의 복제가 여러 번 이뤄져 많은 용량을 요구하게 됨

즉, library와 object file을 모두 포함하여 하나의 실행파일이 만들어짐

🧨 Static Link 시, 컴파일 옵션에 따라 include한 헤더의 함수가 모두 포함될 수도 그렇지 않을 수도 있음!

 

Static Compile

cpp
닫기
$ gcc -o static hello-world.c -static

file 명령어를 통해 확인해보면 statically linked로 연결된 것을 확인할 수 있음

 

Dynamic Link와 Static Link 비교

1) 용량

  • Dynamic Link로 생성한 dynamic binary에 비해 Static Link로 생성한 static binary의 용량이 훨씬 크다는 것을 알 수 있음(library를 모두 포함하여 컴파일하였기 때문)

 

2) 호출 방법

cpp
닫기
//static ​main: ​​push rbp ​​mov rbp,rsp ​​lea rdi,[rip+0x915dc] # 0x492144 ​​call 0x410230 <puts> ​​mov eax,0x0 ​​pop rbp ​​ret
cpp
닫기
//dynamic main: ​push rbp ​mov rbp,rsp ​lea rdi,[rip+0x92] # 0x400584 ​call 0x4003f0 <puts@plt> ​mov eax,0x0 ​pop rbp ​ret
  • static에서는 puts 함수를 직접적으로 호출하고 있음
  • dynamic에서는 puts의 plt 주소를 호출함 → library에서 puts 함수를 찾아야하기 때문
    • plt는 library에서 puts 함수를 찾기 위해 필요한 테이블임

 

한 눈에 보는 Dynamic Link와 Static Link

출처: https://bpsecblog.wordpress.com/2016/03/07/about_got_plt_1/

 

'Hacking Study > Pwnable' 카테고리의 다른 글

PLT & GOT  (0) 2023.03.02
Stack Canary  (2) 2023.03.01
이론은 [Dreamhack - Mitigation: Stack Canary] 부분을 정리한 뒤 추가적으로 덧붙였습니다.

 

Stack Canary

  • 함수의 프롤로그에서 스택 버퍼와 반환 주소 사이에 임의의 값을 삽입하고, 함수의 에필로그에서 해당 값의 변조를 확인하는 보호 기법
  • 카나리 값의 변조가 확인되면 프로세스는 강제로 종료됨
  • 스택 버퍼 오버플로우로 반환 주소를 덮으려면 반드시 카나리를 먼저 덮어야 함
    • 카나리 값을 모르는 공격자는 반환 주소를 덮을 때 카나리 값을 변조하게 되고, 에필로그에서 변조가 확인되어 공격자는 실행 흐름을 획득하지 못함

 

🦜 카나리 이름의 유래 (Canary in a Coal Mine)
19세기, 20세기에는 일산화탄소 농도의 측정 기술이 부족했고, 탄광에서 유출된 일산화탄소에 광부가 중독사하는 사건이 빈번하게 발생했음. 카나리아라는 새는 유독가스에 민감해 사람이 중독되기 전에 먼저 반응하여 죽기 때문에, 누출을 사전에 인지 가능했음
이로 인해 카나리아는 “위험을 알려주는 새”라는 상징적 의미를 갖게 됨
소프트웨어를 출시하거나 업데이트할 때, 베타 테스트 용도로 공개하는 버전을 카나리 버전이라고 부르는 것도 이런 의미가 반영된 것
카나리 보호 기법도 반환 주소가 덮인 것을 알려준다는 의미에서 “카나리”로 이름 붙여짐
카나리아 새 - 이미지 출처: https://itwiki.kr/w/%EC%B9%B4%EB%82%98%EB%A6%AC

 

 

컴파일 시 카나리 옵션 적용하기

  • gcc 컴파일 시 옵션을 주지 않으면 기본적으로 canary가 적용됨

  • canary 옵션을 빼고 싶다면 -fno-stack-protector 옵션을 사용하면 됨

 

카나리 활성화 여부에 따른 error 발생 차이

실습 바이너리는 [Dreamhack - Return to Shellcode]를 대상으로 수행하였습니다.
  • canary 적용 → stack smashing detected

임의의 값을 지정된 버퍼보다 훨씬 많은 값을 주었을 때 stack smashing detected라는 error가 발생함 -> canary가 존재함을 알 수 있음

  • canary 미적용 → Segmentation fault

canary가 적용되지 않은 경우 버퍼 크기 보다 많은 값을 입력했을 때 Segmentation fault라는 error가 발생함

 

GDB에서 canary가 적용된 것을 확인해보자

push rbp mov rbp,rsp sub rsp,0x10 mov rax,QWORD PTR fs:0x28 mov QWORD PTR [rbp-0x8],rax xor eax,eax lea rax,[rbp-0x10] lea rax,[rbp-0x8] mov edx,0x20 mov rsi,rax mov edi,0x0 call read@plt mov eax,0x0 mov rcx,QWORD PTR [rbp-0x8] xor rcx,QWORD PTR fs:0x28 je 0x6f0 <main+70> call __stack_chk_fail@plt leave ret

 

💎 확인해야 하는 코드 1

python
닫기
mov rax,QWORD PTR fs:0x28 mov QWORD PTR [rbp-0x8],rax

1. fs:0x28 → 데이터를 읽어 rax에 저장함

  • fs: 세그먼트 레지스터의 일종으로 리눅스는 프로세스가 시작될 때 fs:0x28에 랜덤 값을 저장함
💡 cs, ds, es는 CPU가 사용 목적을 명시한 레지스터인 반면, fs와 gs는 목적이 정해지지 않아 운영체제가 임의로 사용할 수 있는 레지스터
  • 리눅스는 fs를 **Thread Local Storage(TLS)**를 가리키는 포인터로 사용
    • TLS에는 카나리를 비롯하여 프로세스 실행에 필요한 여러 데이터가 저장됨

1-1. mov    rax,QWORD PTR fs:0x28

  • 결과적으로 rax에는 첫 1byte가 null-byte인 8byte 랜덤 데이터가 저장됨
pwndbg> print /a $rax $1 = 0xf80f605895da3c00

2. mov    QWORD PTR [rbp-0x8],rax

  • rax에 저장된 canary를 rbp-0x8에 저장(stack memory 상에 위치하게 됨)

 

💎 확인해야 하는 코드 2

python
닫기
mov rcx,QWORD PTR [rbp-0x8] xor rcx,QWORD PTR fs:0x28 je 0x6f0 <main+70> call __stack_chk_fail@plt

1. mov    rcx,QWORD PTR [rbp-0x8]

  • rbp-8에 저장되어 있는 canary 값을 rcx에 저장함

2. xor    rcx,QWORD PTR fs:0x28

  • rcx에 저장된 canary 값과 기존에 fs:0x28에 저장된 canary 값을 xor 연산
  • 두 값이 동일하면 연산 결과가 0이 되면서 je 조건을 만족하여 main 함수가 정상적으로 반환됨
  • 그러나 두 값이 동일하지 않으면 __stack_chk_fail이 호출되면서 프로그램이 강제로 종료됨
가장 처음 생성하였던 fs:0x28의 canary와 스택에 저장된 canary(rbp-0x8)가 같은지 비교하는 것
만약 BOF가 발생하였다면 canary 값을 임의의 값으로 덮어쓰게 될 것이고, 이는 스택에 저장된 canary 값을 변조하게 됨
이로 인해 fs:0x28의 canary와 xor 연산하게 되면 불일치하여 1이 반환될 것! → stack smashing detected error 발생
💡xor 연산
bit 1 bit 2 result
0 0 0
0 1 1
1 0 1
1 1 0
같은 bit일 때 0을 반환, 다를 때 1을 반환 함
canary 또한 두 값이 동일하다면 연산하는 bit 모두 동일하므로 결과적으로 0이 반환되는 것!

 

카나리 생성 과정

  • 카나리 값은 프로세스가 시작될 때 TLS에 전역 변수로 저장되고 각 함수마다 프롤로그와 에필로그에서 해당 값을 참조함

 

TLS의 주소 파악

  • fsTLS를 가리키므로 fs 값을 알면 TLS의 주소를 알 수 있음
    • BUT 리눅스에서 fs 값은 특정 시스템 콜을 사용해야만 조회하거나 설정할 수 있음(info register fs, print $fs 등으로 알 수 없다는 말!)
  • fs의 값을 설정할 때 호출되는 arch_prctl(int code, unsigned long addr) 시스템 콜에 bp 걸어 확인할 수 있음
    • arch_prctl(ARCH_SET_FS, addr)의 형태로 호출하면 fs의 값은 addr로 설정됨
    $ gdb -q ./canary pwndbg> catch syscall arch_prctl Catchpoint 1 (syscall 'arch_prctl' [158]) pwndbg> run Catchpoint 1 (call to syscall arch_prctl), 0x00007ffff7dd6024 in init_tls () at rtld.c:740 740 rtld.c: No such file or directory. ​► 0x7ffff7dd4024 <init_tls+276> test eax, eax ​​​0x7ffff7dd4026 <init_tls+278> je init_tls+321 <init_tls+321> ​​​0x7ffff7dd4028 <init_tls+280> lea rbx, qword ptr [rip + 0x22721] pwndbg> info register $rdi rdi 0x1002 4098 // ARCH_SET_FS = 0x1002 pwndbg> info register $rsi rsi 0x7ffff7fdb4c0 140737354032320 pwndbg> x/gx 0x7ffff7fdb4c0+0x28 0x7ffff7fdb4e8: 0x0000000000000000
💡gdb catch(catchpoint)
특정 이벤트가 발생했을 때 프로세스를 중지함

 

  • catchpoint에 도달했을 때, rdi에 저장된 0x1002ARCH_SET_FS의 상숫값임
  • rsi 값이 0x7ffff7fdb4c0이므로 이 프로세스는 TLS를 0x7ffff7fdb4c0에 저장할 것이며, fs는 이를 가리키게 될 것
  • 카나리가 저장될 fs+0x28(0x7ffff7fdb4c0+0x28)의 값을 보면, 아직 어떠한 값도 설정되어 있지 않음

 

canary 값 설정

  • TLS+0x28에 값을 쓸 때 wathpoint 설정
    • security_init 함수에서 프로세스가 멈춤
💡gdb watch(watchpoint)
특정 주소에 저장된 값이 변경되면 프로세스 중지함
python
닫기
pwndbg> watch *(0x7ffff7fdb4c0+0x28) Hardware watchpoint 4: *(0x7ffff7fdb4c0+0x28) pwndbg> continue Continuing. Hardware watchpoint 4: *(0x7ffff7fdb4c0+0x28) Old value = 0 New value = -1942582016 security_init () at rtld.c:807 807 in rtld.c pwndbg> x/gx 0x7ffff7fdb4c0+0x28 0x7ffff7fdb4e8: 0x2f35207b8c368d00

TLS+0x28의 값을 조회하면 canary 값이 0x2f35207b8c368d00으로 설정된 것을 확인할 수 있음

 

  • 해당 값이 실제 main 함수에서 사용하는 canary 값인지 확인
python
닫기
pwndbg> b *main Breakpoint 3 at 0x5555555546ae Breakpoint 3, 0x00005555555546ae in main () pwndbg> x/10i $rip ​► 0x5555555546ae <main+4>: sub rsp,0x10 ​​​0x5555555546b2 <main+8>: mov rax,QWORD PTR fs:0x28 ​​​0x5555555546bb <main+17>: mov QWORD PTR [rbp-0x8],rax ​​​0x5555555546bf <main+21>: xor eax,eax ​​​0x5555555546c1 <main+23>: lea rax,[rbp-0x10] ​​​0x5555555546c5 <main+27>: mov edx,0x20 ​​​0x5555555546ca <main+32>: mov rsi,rax ​​​0x5555555546cd <main+35>: mov edi,0x0 ​​​0x5555555546d2 <main+40>: call 0x555555554580 <read@plt> ​​​0x5555555546d7 <main+45>: mov eax,0x0 pwndbg> ni 0x00005555555546b2 in main () pwndbg> ni 0x00005555555546bb in main () pwndbg> i r $rax rax 0x2f35207b8c368d00 3401660808553729280

mov rax, QWORD PTR fs:0x28 부분 실행 후 rax 값을 확인해보면 security_init에서 설정한 값과 같은 것을 알 수 있음

 

카나리 우회

1. 무차별 대입(Brute Force)

  • x64 아키텍처에서는 8byte의 canary가 생성됨
    • Brute Force로 최대 256^7번 연산이 필요함
  • x86 아키텍처에서는 4byte의 canary가 생성됨
    • Brute Force로 최대 256^3번의 연산이 필요함
  • canary에는 null-byte가 포함되어, 실제로는 7byte, 3byte의 random한 값이 포함됨!

→ 무차별 대입으로 알아내는 것은 현실적으로 어려움

 

 

2. TLS 접근

  • canary는 TLS에 전역변수로 저장됨
    • 매 함수마다 이를 참조해서 사용함!
    • TLS 주소는 매 실행마다 바뀌지만 실행 중 TLS 주소를 알 수 있고, 임의 주소에 대한 읽기 또는 쓰기가 가능할 경우 TLS에 설정된 canary 값을 읽거나 임의의 값으로 조작할 수 있음

→ stack BOF를 수행할 때 알아낸 canary 값 또는, 조작한 canary 값으로 stack canary를 덮으면 함수 에필로그에 있는 canary 검사를 우회할 수 있음!

 

실습

cpp
닫기
// Name: bypass_canary.c // Compile: gcc -o bypass_canary bypass_canary.c #include <stdio.h> #include <unistd.h> int main() { ​​char memo[8]; ​​char name[8]; ​​ ​​printf("name : "); ​​read(0, name, 64); ​​printf("hello %s\n", name); ​​ ​​printf("memo : "); ​​read(0, memo, 64); ​​printf("memo %s\n", memo); ​​ ​​return 0; }
  • memo, name은 각각 8bytes씩 할당됨
  • read 함수를 통해 name, memo에 64bytes씩 입력할 수 있음 → 주어진 buffer 크기보다 더 많은 값을 입력할 수 있으므로 BOF 취약점 발생
  • printf 함수를 통해 입력한 name과 memo에 대한 값을 출력해줌

stack 구조

💡printf 함수
printf 함수는 null-byte가 오기 직전까지 출력해줌
입력 값의 가장 마지막은 null-byte가 위치하여 메모리 상에서 값에 대한 구분을 하게 됨
즉, memo와 name에 대해 입력하게 된다면 각각의 마지막 byte는 null로서 구분됨
그러나 이때, 마지막 byte를 null-byte가 아닌 임의의 값으로 채워준다면 지정된 buffer 이후의 값도 출력할 수 있음
  • 예를 들어, name에 임의의 값(다수의 a)를 입력한 뒤, memo에 8bytes를 꽉채워 입력하게 되면 null-byte를 덮어쓰게 됨
  • printf 함수는 null-byte가 올 때까지의 모든 것을 출력해주므로, memo 뒤에 위치한 name에 있는 값까지 출력하게 됨

memo에 대한 값을 print하는 부분에서 name 값까지 leak된 것을 확인할 수 있음

 

💡name 직후에 존재하는 canary에 대해서도 이와 같은 방법으로 leak할 수 있음
그러나 여기서는 name에 대한 8byte만 채우면 안됨
canary의 첫 번째 byte가 null-byte이므로 name[8]+canary[1] 만큼의 dummy 값을 줘야 printf 함수를 통해 canary 값을 leak할 수 있음

9byte의 입력 값을 주었을 때 leak된 canary

  • shell에서 보았을 때 canary 값이 이상하게 깨져서 보이는데, 이는 canary가 갖는 hex 값에 대해 ascii 문자로 치환할 수 있는 것이 없기 때문

  • 위의 ascii 코드표(ASCII Table)에 matching되는 hex에 대해서만 치환 가능 

 

상세한 canary leak과 해당 과정을 통해 shell을 획득하는 것에 대해서는 [dreamhack - ReturnToShellcode]
, [dreamhack - ssp_001], [dreamhack - ssp_000] 문제 풀이를 통해 확인할 수 있습니다.

'Hacking Study > Pwnable' 카테고리의 다른 글

PLT & GOT  (0) 2023.03.02
Static Link vs Dynamic Link  (0) 2023.03.02

+ Recent posts