AliCTF 2015-题目解析之代码血案

一、题目说明：

服务器端有个程序在监听端口30000，该程序有一个安全漏洞，通过阅读源码找出漏洞。
向该程序提交请求，如果触发漏洞，便会在响应中发回88字节的flag
每个参赛者有自己的Token，提交的请求中需要包含Token，每个Token只有四次提交请求的机会

二、解题工具：

BurpSuit + WireShark

工具说明：

用自己的python代理，给服务器发送数据，服务器不响应，用浏览器却可以，使用wireshark抓包比较，也没发现区别(希望有大神告诉我为什么)，为了节省时间干脆就用BurpSuit Repeater发包，用WireShark查看收到的数据包内容。。。

三、解题过程：

1、理解源码

程序的流程
一系列初始化 -> 监听端口 -> 接受请求 -> 判断格式 -> 判断token -> 交给rpc函数处理

rpc函数列表

0号 rpc_strcat
1号 rpc_insert
2号 rpc_setstr
3号 rpc_replace
4号 rpc_delete
5号 rpc_strcmp
6号 rpc_readlog
7号 rpc_test

2、发现漏洞

看到rpc_readlog、writelog，凭直觉这两个函数有蹊跷（没事提供读写日志功能干嘛- -！），虽然察觉到了，但是发现漏洞的过程还是很艰难(- -!)。
经过漫长曲折的分析，最后发现问题确实出现在rpc_readlog中，rpc_readlog函数的代码如下：

 1 response_t *rpc_readlog(request_t *request){
 2     req_t req;
 3     memcpy(&req,request->data,sizeof(req_t));
 4     if(req.str1.len != strlen(req.str1.string) || req.str2.len != strlen(req.str2.string) || req.str1.len != 0 || req.str2.len != 0 || req.pos < 0 || req.len == 0 || validkey(&req) == FAIL){
 5         char *message = "Wrong Argument.";
 6         return create_response(strlen(message), message);
 7     }
 8     
 9     char *buffer;
10     char len = req.len;
11     
12     if(len < 0)
13         len = -len;
14     if((buffer = (char*)malloc(len + SAFE_SPACE_LEN)) == NULL){
15         char *message = "Malloc Error.";
16         return create_response(strlen(message),message);
17     }
18     memset(buffer,0,len + SAFE_SPACE_LEN);
19     if((readlog(request->token,request->len_token,&req,buffer)) < 0){
20         free(buffer);
21         char *message = "Operation Error.";
22         return create_response(strlen(message),message);
23     }
24     
25     response_t *response = create_response(len,buffer);
26     free(buffer);
27     return response;
28 }

代码中使用有符号char型变量len存储长度，如果len小于0就取负得到正的len，然后为buffer分配空间，长度为len+ 130（SAFE_SPACE_LEN），问题就出在这里，为什么呢？
在本地gcc编译环境中进行试验，发现当len 等于 -128(0x80) 时，负 len 还等于-128(0x80) ，而-128又是合法的值。
如果直接将len传给malloc，分配空间是会失败的，但是，代码中给len加上了个SAFE_SPACE_LEN，这会导致成功给buffer分配2字节的空间，最终造成了后面的”血案“。
rpc_readlog为buffer分配空间后，调用了readlog函数：

 1 int readlog(char* token,unsigned char len_token,req_t* req,char* response){
 2     int fd;
 3     int pos = req->pos;
 4     char len = req->len;
 5     char filename[512] = "/rpcserver/";
 6     char *filecontent;
 7     int filesize = 0;
 8     struct stat buf;
 9 
10     if(pos < 0)
11         return FAIL;
12     if(len < 0){
13         pos = pos + len;
14         len = -len;
15     }
16     assert(SAFE_POSITIVE(len));
17 
18     memcpy(filename + 11,token,len_token);
19     memcpy(filename + 11 + len_token,".log",5);
20 
21     if((fd = open(filename,O_RDONLY,0644)) < 0)
22         return FAIL;
23     if(fstat(fd,&buf) < 0){
24         close(fd);
25         return FAIL;
26     }
27     filesize = buf.st_size;
28     if(pos < 0 || pos > filesize || pos + len > filesize || (filecontent = (char*)malloc(filesize)) == NULL ){
29         close(fd);
30         return FAIL;
31     }
32 
33     if(filesize != read(fd,filecontent,filesize)){
34         close(fd);
35         free(filecontent);
36         return FAIL;
37     }
38     
39     char l = len;
40     do{
41         response[l] = filecontent[pos + l];
42         l--;
43     }while(l >= 0);
44     
45     close(fd);
46     free(filecontent);
47     return SUCCESS;
48 }

这个函数的功能就是读取log文件中的部分内容，读取的位置和长度由请求中的pos和len指定，最后将读取的内容写到buffer中，我们来分析一下len = -128时，是否可以通过合法性检测并触发漏洞。
首先注意到开始部分有个断言：

assert(SAFE_POSITIVE(len));

这个断言咋一看看挺“吓人”的，但实际SAFE_POSITIVE宏的定义是这样的：

#define SAFE_POSITIVE(x)( x = x >0? x : x + SAFE_SPACE_LEN )>0

也就是说len>0或者len+ SAFE_SPACE_LEN >0就可以了，换句话说，len=-128是没问题的。再看后面的合法性检查，可以总结出当len = -128时，只要pos > 128就可以了，当然还要求存在log文件且有一定长度的内容。

看来len=-128通过合法性检测是没有问题了，现在直接看最后这个循环：

1     char l = len;
2     do{
3         response[l] = filecontent[pos + l];
4         l--;
5     }while(l >= 0);

filecontent中存储了log文件中的所有内容，这个循环便是将指定pos和len的内容复制到response中，response就是rpc_readlog中分配了2字节长度的buffer。当 l = -128时，l-- = 127，也就是会给response[-128]以及response[0]->response[127]的内存空间赋值，结果就是导致堆溢出。