스택 카나리 (Stack Canary)
스택 카나리 (Stack Canary)
1. 스택 카나리
1. 스택 카나리 (Stack Canary) 란?
BOF 공격으로부터 반환 주소를 보호하기 위해 스택 카나리 (Stack Canary) 보호기법이 생겼다.
스택 카나리는 함수의 프롤로그에서 스택 버퍼와 반환 주소 사이에 임의의 값을 삽입하고,
함수의 에필로그에서 해당 값의 변조를 확인하는 보호 기법이다.
카나리 값의 변조가 확인되면 프로세스는 강제로 종료 된다.
BOF 공격에서 반환 주소를 덮으려면 반드시 카나리를 먼저 덮어야 하므로
카나리를 모르는 공격자는 반환 주소를 덮을 때 카나리 값을 변조하게 된다.
2. 카나리 정적 분석
1. 스택 카나리 비활성화
// Name: canary.c
#include <unistd.h>
int main() {
char buf[8];
read(0, buf, 32);
return 0;
}BOF 가 발생하는 C 코드이다.
gcc 는 기본적으로 스택 카나리를 적용하여 컴파일한다.
-fno-stack-protector따라서 컴파일 옵션으로 -fno-stack-protector 을 추가해야 카나리 없이 컴파일 할 수 있다
$ gcc -o no_canary canary.c -fno-stack-protector
$ ./no_canary
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
Segmentation fault (core dumped)카나리가 없을 때는 반환주소가 덮이기 때문에 Segmentation fault 에러가 발생한다
$ gcc -o canary canary.c
$ ./canary
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
*** stack smashing detected ***: terminated
Aborted (core dumped)카나리가 있을 때 BOF 가 발생하면 stack smashing detected 에러와 Aborted 에러가 발생한다.
이는 BOF가 발생하여 프로세스가 강제종료 된 것이다.
2. 어셈블리 비교
0x0000000000001169 <+0>: endbr64
0x000000000000116d <+4>: push rbp
0x000000000000116e <+5>: mov rbp,rsp
0x0000000000001171 <+8>: sub rsp,0x10
0x0000000000001175 <+12>: mov rax,QWORD PTR fs:0x28
0x000000000000117e <+21>: mov QWORD PTR [rbp-0x8],rax
0x0000000000001182 <+25>: xor eax,eax
0x0000000000001184 <+27>: lea rax,[rbp-0x10]
0x0000000000001188 <+31>: mov edx,0x20
0x000000000000118d <+36>: mov rsi,rax
0x0000000000001190 <+39>: mov edi,0x0
0x0000000000001195 <+44>: call 0x1070 <read@plt>
0x000000000000119a <+49>: mov eax,0x0
0x000000000000119f <+54>: mov rcx,QWORD PTR [rbp-0x8]
0x00000000000011a3 <+58>: xor rcx,QWORD PTR fs:0x28
0x00000000000011ac <+67>: je 0x11b3 <main+74>
0x00000000000011ae <+69>: call 0x1060 <__stack_chk_fail@plt>
0x00000000000011b3 <+74>: leave
0x00000000000011b4 <+75>: ret카나리가 적용된 파일의 어셈블리이다.
0x0000000000001149 <+0>: endbr64
0x000000000000114d <+4>: push rbp
0x000000000000114e <+5>: mov rbp,rsp
0x0000000000001151 <+8>: sub rsp,0x10
0x0000000000001155 <+12>: lea rax,[rbp-0x8]
0x0000000000001159 <+16>: mov edx,0x20
0x000000000000115e <+21>: mov rsi,rax
0x0000000000001161 <+24>: mov edi,0x0
0x0000000000001166 <+29>: call 0x1050 <read@plt>
0x000000000000116b <+34>: mov eax,0x0
0x0000000000001170 <+39>: leave
0x0000000000001171 <+40>: ret카나리가 적용되지 않은 파일의 어셈블리이다.
두 어셈블리를 비교해보면
0x0000000000001175 <+12>: mov rax,QWORD PTR fs:0x28
0x000000000000117e <+21>: mov QWORD PTR [rbp-0x8],rax
0x0000000000001182 <+25>: xor eax,eax함수 프롤로그에는 위와 같은 코드가
0x000000000000119f <+54>: mov rcx,QWORD PTR [rbp-0x8]
0x00000000000011a3 <+58>: xor rcx,QWORD PTR fs:0x28
0x00000000000011ac <+67>: je 0x11b3 <main+74>
0x00000000000011ae <+69>: call 0x1060 <__stack_chk_fail@plt>함수 에필로그에는 위와 같은 코드가 추가되었다.
3. 카나리 동적 분석
1. 카나리 저장 (프롤로그)
추가된 프롤로그의 코드를 다시 보자.
0x0000000000001175 <+12>: mov rax,QWORD PTR fs:0x28
0x000000000000117e <+21>: mov QWORD PTR [rbp-0x8],rax
0x0000000000001182 <+25>: xor eax,eaxmain+12는 fs:0x28 의 데이터를 읽어서 rax 에 저장한다.
프로세스가 시작될 때 fs:0x28 에 랜덤 값을 저장한다.
fs:0x28 에 저장되는 값을 master canary 라고 한다.
main+12 에 break 를 걸고 실행 후 rax 의 값을 확인하면
pwndbg> p /a $rax
$2 = 0x9754f337edc93300첫 바이트가 NULL 인 8바이트 데이터가 저장되어 있다.
이 값이 master canary 이다.
main+21 에서 master canary 를 rbp-0x8 에 저장한다.
pwndbg> x/gx $rbp-0x8
0x7fffffffd148: 0x9754f337edc93300스택 프레임에 저장되는 값을 stack cananry 라고 한다.
2. 카나리 검사 (에필로그)
추가된 에필로그의 코드를 다시 보자.
0x000000000000119f <+54>: mov rcx,QWORD PTR [rbp-0x8]
0x00000000000011a3 <+58>: xor rcx,QWORD PTR fs:0x28
0x00000000000011ac <+67>: je 0x11b3 <main+74>
0x00000000000011ae <+69>: call 0x1060 <__stack_chk_fail@plt>main+54 에서 rbp-0x8 에 저장한 master canary 값을 rcx에 옮긴다
main+58 에서 rcx값과 fs:0x28값을 xor 연산한다
pwndbg> p /a $rcx
$6 = 0x9754f337edc93300카나리가 변조되지 않아 rcx 의 값이 fs:0x28의 값과 같으면
xor 연산했을 때 0이 되어 je 의 조건을 만족한다.
pwndbg> ni
[Inferior 1 (process 20990) exited normally]프로그램이 정상적으로 종료된다.
pwndbg> p /a $rcx
$7 = 0x7ffff7ed81f2 <__GI___libc_read+18>카나리가 변조되어 rcx 의 값이 fs:0x28의 값과 다르면
xor 연산했을 때 0이 되지 않아 __stack_chk_fail 함수가 호출된다.
pwndbg> ni
Program terminated with signal SIGABRT, Aborted.
The program no longer exists.
프로그램이 강제로 종료된다.
4. 카나리 생성 과정
1. TLS 주소 파악
카나리 값(master canary) 은 프로세스가 시작될 때 TLS 에 전역변수로 저장된다.
fs 레지스터는 TLS 를 가리키기 때문에 fs 의 값을 알면 TLS 의 주소를 알 수 있다.
그러나 리눅스에서 fs 의 값은 특정 시스템 콜을 사용해야만 조회하거나 설정할 수 있다.
gdb 에서 print, info 명령어 등으로 값을 알아낼 수 없다.
fs 의 값을 설정할 때 호출하는 시스템 콜은
arch_prctl(ARCH_SET_FS, addr) 의 형태로 호출된다.
이렇게 호출하면 fs 의 값이 addr 로 설정된다.
따라서 arch_prctl 시스템 콜에 break 를 설정해서 fs 의 값을 알아내보자.
gdb catch (catchpoint)catch 명령어는 특정 이벤트가 발생했을 때 프로세스를 중지하는 명령어이다.
init_tls() 안에서 catchpoint 에 도달할 때까지 continue 명령어를 실행한다.
pwndbg> catch syscall arch_prctl
Catchpoint 1 (syscall 'arch_prctl' [158])
pwndbg> r
Catchpoint 1 (call to syscall arch_prctl), init_tls () at rtld.c:758
758 rtld.c: No such file or directory.
► 0x7ffff7fd0cc0 <init_tls+208> test eax, eax
0x7ffff7fd0cc2 <init_tls+210> je init_tls+258 <init_tls+258>
0x7ffff7fd0cc4 <init_tls+212> lea rbx, [rip + 0x24805]
0x7ffff7fd0ccb <init_tls+219> nop dword ptr [rax + rax]
pwndbg> i r $rdi
rdi 0x1002 4098 // ARCH_SET_FS 0x1002
pwndbg> i r $rsi
rsi 0x7ffff7fbd540 140737353864512
pwndbg> x/gx 0x7ffff7fbd540 + 0x28
0x7ffff7fbd568: 0x0000000000000000
rdi 의 값인 0x1002 는 ARCH_SET_FS 의 상수값이다.
rsi 의 값은 0x7ffff7fbd540 이므로 TLS 를 0x7ffff7fbd540 에 저장하고 fs 는 이를 가리키게 된다.
카나리가 저장될 fs+0x28 (0x7ffff7fbd540 + 0x28) 의 값은 아무것도 설정되어 있지 않은 것을 볼 수 있다.
2. 카나리 값 설정
TLS + 0x28 에 값을 쓸 때 watchpoint 를 설정한다.
gdb watch (watchpoint)watch 명령어는 특정 주소에 지정된 값이 변경되면 프로세스를 중단시키는 명령어이다.
pwndbg> watch *(0x7ffff7fbd540 + 0x28)
Hardware watchpoint 2: *(0x7ffff7fbd540 + 0x28)
pwndbg> c
Continuing.
Hardware watchpoint 2: *(0x7ffff7fbd540 + 0x28)
Old value = 0
New value = 187826944
dl_main (phdr=<optimized out>, phnum=<optimized out>, user_entry=<optimized out>, auxv=<optimized out>) at ../sysdeps/unix/sysv/linux/dl-osinfo.h:77
77 ../sysdeps/unix/sysv/linux/dl-osinfo.h: No such file or directory.
pwndbg> x/gx 0x7ffff7fbd540 + 0x28
0x7ffff7fbd568: 0xb698679e6b32eb00TLS + 0x28 의 값을 조회하면 master canary 값이 0xb698679e6b32eb00 으로 설정된 것을 확인할 수 있다.
0xb698679e6b32eb00 의 값이 실제 main 함수에서 사용되는 값인지 확인해보자.
0x555555555175 <main+12> mov rax, qword ptr fs:[0x28]main +12 부분에 break를 걸고 실행하면
pwndbg> b *main +12
Breakpoint 3 at 0x555555555175
pwndbg> c
Continuing.
0x555555555175 <main+12> mov rax, qword ptr fs:[0x28]
► 0x55555555517e <main+21> mov qword ptr [rbp - 8], rax
0x555555555182 <main+25> xor eax, eax
0x555555555184 <main+27> lea rax, [rbp - 0x10]
pwndbg> i r $rax
rax 0xb698679e6b32eb00 -5289363832245654784rax 의 값에 0xb698679e6b32eb00 카나리 값이 들어간 것을 확인할 수 있다.
5. 카나리 우회
1. 무차별 대입 (Brute Force)
x64
8byte 의 canary 가 생성된다.
첫 바이트는 NULL 이므로 7바이트의 랜덤한 값이다.
2567번 연산이 필요하다
연산량이 많아 사실상 무차별 대입 공격으로 canary 를 알아내는 것은 불가능하다.
x86
4byte 의 canary 가 생성된다.
첫 바이트는 NULL 이므로 3바이트의 랜덤한 값이다.
2563번의 연산이 필요하다
canary 를 구할순 있지만 실제 서버를 대상으로 무차별 대입 공격을 시도하는 것은 불가능하다.
2. TLS 접근
canary 는 TLS 에 전역변수로 저장된다.
매 함수마다 이를 참조해서 사용한다.
TLS 의 주소는 매 실행마다 바뀌지만 만약 실행 중에 TLS의 주소를 알 수 있고,
임의 주소에 대한 읽기 쓰기가 가능하다면 TLS 에 설정된 카나리 값을 읽거나, 조작할 수 있다.
BOF 를 할 때 알아낸 카나리값이나 조작한 카나리 값으로 카나리 검사를 우회할 수 있다
3. 카나리 릭 (Canary Leak)
// Name: canary.c
// Compile : gcc -z execstack -no-pie -o canary_leak canary.c
#include <stdio.h>
#include <unistd.h>
void setup_environment() {
setvbuf(stdin, NULL, _IONBF, 0);
setvbuf(stdout, NULL, _IONBF, 0);
setvbuf(stderr, NULL, _IONBF, 0);
}
int main() {
setup_environment();
char buf[8];
read(0, buf, 32);
printf("%s", buf);
return 0;
}카나리 릭을 테스트할 C 코드이다.
위의 코드와 동일하지만
입출력이 버퍼를 사용하지 않고 직접적으로 이루어지도록 하는 함수만 추가했다.
어셈블리를 확인해보자
0x00000000004011fb <+0>: endbr64
0x00000000004011ff <+4>: push rbp
0x0000000000401200 <+5>: mov rbp,rsp
0x0000000000401203 <+8>: sub rsp,0x10
0x0000000000401207 <+12>: mov rax,QWORD PTR fs:0x28
0x0000000000401210 <+21>: mov QWORD PTR [rbp-0x8],rax
0x0000000000401214 <+25>: xor eax,eax
0x0000000000401216 <+27>: mov eax,0x0
0x000000000040121b <+32>: call 0x401196 <setup_environment>
0x0000000000401220 <+37>: lea rax,[rbp-0x10] ; buf = rbp-0x10
0x0000000000401224 <+41>: mov edx,0x20 ; 32
0x0000000000401229 <+46>: mov rsi,rax ; buf
0x000000000040122c <+49>: mov edi,0x0 ; 0
0x0000000000401231 <+54>: call 0x401090 <read@plt> ; read(0, buf, 32)
0x0000000000401236 <+59>: lea rax,[rbp-0x10]
0x000000000040123a <+63>: mov rsi,rax
0x000000000040123d <+66>: lea rdi,[rip+0xdc0] # 0x402004
0x0000000000401244 <+73>: mov eax,0x0
0x0000000000401249 <+78>: call 0x401080 <printf@plt>
0x000000000040124e <+83>: mov eax,0x0
0x0000000000401253 <+88>: mov rcx,QWORD PTR [rbp-0x8]
0x0000000000401257 <+92>: xor rcx,QWORD PTR fs:0x28
0x0000000000401260 <+101>: je 0x401267 <main+108>
0x0000000000401262 <+103>: call 0x401070 <__stack_chk_fail@plt>
0x0000000000401267 <+108>: leave
0x0000000000401268 <+109>: ret위의 코드를 확인하면 buf 는 rbp-0x10 이다
C 코드를 보면 buf 는 분명 8이다
그런데 어셈을 보면 buf 는 0x10 인 것을 알 수 있다.
이 차이는 스택을 보면 알 수 있다.
스택 프레임 구조를 살펴보자.
buf 는 8
64bit 아키텍처이기 때문에 canary 도 8이다
따라서 buf 는 0x10 , 16이 된다.
buf 에 8 만큼 dummy 값을 넣고
canary 의 첫 바이트인 NULL 값 1 만큼을 덮으면
canary 값이 출력될 것이다.
$ ./canary_leak
aaaaaaaaa
aaaaaaaaa
�_q�?g*** stack smashing detected ***: terminated
]Aborted (core dumped)예상대로 카나리 값이 출력되었다.
깨져서 보이는 이유는 카나리 값에 대응하는 ASCII 코드가 없어서 그렇다.