SCTF逆向writeup

 

上周末做了一下SCTF的逆向题，整体质量还不错，这里简单分析一下我的做题思路，有问题欢迎交流

 

signin

一个GUI程序，使用pyinstaller打包，需要输入正确的用户名的密码。
使用pyinstxtractor解包，发现是py3.8，于是用相应版本的uncompyle反编译main.pyc：

import sys
from PyQt5.QtCore import *
from PyQt5.QtWidgets import *
from signin import *
from mydata import strBase64
from ctypes import *
import _ctypes
from base64 import b64decode
import os

class AccountChecker:

    def __init__(self):
        self.dllname = './tmp.dll'
        self.dll = self._AccountChecker__release_dll()
        self.enc = self.dll.enc
        self.enc.argtypes = (c_char_p, c_char_p, c_char_p, c_int)
        self.enc.restype = c_int
        self.accounts = {'SCTFer': b64decode('PLHCu+fujfZmMOMLGHCyWWOq5H5HDN2R5nHnlV30Q0EA')}
        self.try_times = 0

    def __release_dll(self):
        with open(self.dllname, 'wb') as (f):
            f.write(b64decode(strBase64.encode('ascii')))
        return WinDLL(self.dllname)

    def clean(self):
        _ctypes.FreeLibrary(self.dll._handle)
        if os.path.exists(self.dllname):
            os.remove(self.dllname)

    def _error(self, error_code):
        errormsg = {0:'Unknown Error', 
         1:'Memory Error'}
        QMessageBox.information(None, 'Error', errormsg[error_code], QMessageBox.Abort, QMessageBox.Abort)
        sys.exit(1)

    def __safe(self, username: bytes, password: bytes):
        pwd_safe = 'x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00'
        status = self.enc(username, password, pwd_safe, len(pwd_safe))
        return (pwd_safe, status)

    def check(self, username, password):
        self.try_times += 1
        if username not in self.accounts:
            return False
        encrypted_pwd, status = self._AccountChecker__safe(username, password)
        if status == 1:
            self._AccountChecker__error(1)
        if encrypted_pwd != self.accounts[username]:
            return False
        self.try_times -= 1
        return True


class SignInWnd(QMainWindow, Ui_QWidget):

    def __init__(self, checker, parent=None):
        super().__init__(parent)
        self.checker = checker
        self.setupUi(self)
        self.PB_signin.clicked.connect(self.on_confirm_button_clicked)

    @pyqtSlot()
    def on_confirm_button_clicked(self):
        username = bytes((self.LE_usrname.text()), encoding='ascii')
        password = bytes((self.LE_pwd.text()), encoding='ascii')
        if username == '' or password == '':
            self.check_input_msgbox()
        else:
            self.msgbox(self.checker.check(username, password))

    def check_input_msgbox(self):
        QMessageBox.information(None, 'Error', 'Check Your Input!', QMessageBox.Ok, QMessageBox.Ok)

    def msgbox(self, status):
        msg_ex = {0:'', 
         1:'', 
         2:"It's no big deal, try again!", 
         3:'Useful information is in the binary, guess what?'}
        msg = 'Succeeded! Flag is your password' if status else 'Failed to sign inn' + msg_ex[(self.checker.try_times % 4)]
        QMessageBox.information(None, 'SCTF2020', msg, QMessageBox.Ok, QMessageBox.Ok)


if __name__ == '__main__':
    app = QApplication(sys.argv)
    checker = AccountChecker()
    sign_in_wnd = SignInWnd(checker)
    sign_in_wnd.show()
    app.exec()
    checker.clean()
    sys.exit()

可以看到用户名为SCTF，对应的密码经过enc函数加密后，与那串base64解码后的值相同。
因此接下来的重点在enc函数，虽然我们找不到其定义，但是可以看到从mydata中读取了一个base64并解码写入到tmp.dll，那enc函数基本就在tmp.dll中没跑了。
我们可以直接运行程序，找到当前目录的tmp.dll，也可以从mydata中提取出来。
然后整理enc函数的逻辑：首先输入在sub_180011311做了一个lfsr，然后再做一个异或加密，相应恢复即可：

from libnum import *

def enc(n):
    x = n
    for i in range(64):
        if x & 0x8000000000000000 != 0:
            x = (2*x) ^ 0xB0004B7679FA26B3
        else:
            x *= 2
        x &= 0xffffffffffffffff
    return x

def dec(n):
    x = n
    for i in range(64):
        if x & 1 != 0:
            x = (x ^ 0x1B0004B7679FA26B3) >> 1
        else:
            x /= 2
    return x

e='PLHCu+fujfZmMOMLGHCyWWOq5H5HDN2R5nHnlV30Q0EA'.decode('base64')
key='SCTFer'
dec0=''
for i in range(len(e)):
    dec0+=chr( ord(e[i]) ^ ord(key[i%6]) )
flag=''
for i in range(0, len(dec0), 8):
    x = s2n(dec0[i:i+8][::-1])
    flag += n2s(dec(x))[::-1]
print flag

 

flag_detector

GO写的web server，首先用golang_loader_assist恢复符号。
main_main里可以看到注册了几个API（都是GET）：

1./v1/login：接受一个name参数，会在当前目录写个json，不加name的话默认是guest，发现并没啥用
2./v2/user：调用一些初始化函数，写一个asdf文件，里面一堆数字（应该是vm相关的东西）
3./v2/flag：在当前目录写一个hjkl的文件，里面是假的flag
4./v3/check：调用一个vm检查hjkl文件

因此重点是逆向check中的vm。
逆向vm可以写反汇编器也可以动态调试，由于这个vm中有几个比较复杂的操作，因此可以尝试在关键位置下断点进行调试。
断点下在cmp指令，可以看到对flag长度的判断，长度输入正确后会对flag进行加密，最后进行逐字节比较。
由于是逐字节比较，就可以侧信道爆破了，我们patch一下程序让它直接运行vm，然后根据断点断在cmp的次数判断flag正确的位置，逐位爆破即可：

# gdb -n -q -x
import gdb
import re
import os 

flag = "SCTF{"
pool=''
for i in range(32, 128):
    pool+=chr(i)
gdb.execute("set pagination off")
gdb.execute("break *0x96CAE5")
while 1:
    for i in range(len(pool)):
        tmp = flag + pool[i]
        cur_len = len(tmp)
        tmp = tmp.ljust(22,'~')
        with open("hjkl", "w") as f:
            f.write(tmp)

        gdb.execute("run")
        for j in range(48):
            gdb.execute("c",to_string=True)
        for j in range(cur_len):
            gdb.execute("c",to_string=True)
        try: 
            gdb.execute("c",to_string=True)
            flag += pool[i]
            break
        except: 
            pass
        print flag

print(flag)

 

get_up

IDA中shift+f12跟踪字符串引用，从you should give me a word找到输入被读取的位置，即位于0x402700的函数。
创建函数后，可以看到word长度在6以内，且sub_401DF0函数中检测了其md5值，这里cmd5可以查到是sycsyc
另外通过right和wrong的引用可以定位到sub_401A70函数，里面有明显的RC4特征。
根据最后的比较if ( v5[k] != *(&v12 + k) )可知函数上面的一串数字为密文，密钥syclover可以通过动态调试看到，解RC4即可得到flag：

dest = [0]*30
dest[0] = 128;
dest[1] = 85;
dest[2] = 126;
dest[3] = 45;
dest[4] = 209;
dest[5] = 9;
dest[6] = 37;
dest[7] = 171;
dest[8] = 60;
dest[9] = 86;
dest[10] = 149;
dest[11] = 196;
dest[12] = 54;
dest[13] = 19;
dest[14] = 237;
dest[15] = 114;
dest[16] = 36;
dest[17] = 147;
dest[18] = 178;
dest[19] = 200;
dest[20] = 69;
dest[21] = 236;
dest[22] = 22;
dest[23] = 107;
dest[24] = 103;
dest[25] = 29;
dest[26] = 249;
dest[27] = 163;
dest[28] = 150;
dest[29] = 217;

enc=''.join(map(chr,dest))
key='syclover'
def rc4(data, key):
    x = 0
    box = range(256)
    for i in range(256):
        x = (x + box[i] + ord(key[i % len(key)])) % 256
        box[i], box[x] = box[x], box[i]
    x = y = 0
    out = []
    for char in data:
        x = (x + 1) % 256
        y = (y + box[x]) % 256
        box[x], box[y] = box[y], box[x]
        out.append(chr(ord(char) ^ box[(box[x] + box[y]) % 256]))

    return ''.join(out)

print rc4(enc, key)

 

secret

安卓逆向，从MainActivity入手，发现check用到的d.a.c类中的5个函数无法正常反编译，查看smali发现全是nop，猜测应该是运行时动态加载代码。
由于SCTF类中调用了native函数，于是接下来逆向一下so文件。
IDA打开后可以看到一些奇怪名字的函数，然后从JNIOnload入手，可以看到一些_Z12dexFindClassPK7DexFilePKc之类的字符串，和一些诸如relocateInstruction、dexReadClassData之类的函数名，基本上可以猜出是对dex动了手脚。
另外data段有几个可以的base64字符串，通过引用可以发现他们在init_proc函数被解密，可以通过动态调试或者逆向算法（即base64+RC4）得到解密后的值：

Ld/a/c;
syclover
UYc0pLw6EdGoEIH3mCpj/kkzRMR5+nl+9VGFICIIL6w=
sctf/secret/SCTF

其中Ld/a/c;就是那个无法反编译的类，而sctf/secret/SCTF是调用native函数的类，另外两个字符串暂时用途未知。

另外initproc中还解密了5个不可打印字符串，看起来与正常dex文件中的Dalvik字节码很像，直觉猜测与那5个被nop的函数有关系。

这里我们使用010editor的dex模板打开apk中的dex文件，定位到这5个函数的位置，发现其中代码的长度刚好与这5个字符串刚好一一对应。

于是我们根据长度，将解密后的字节码恢复回去，就可以正常反编译了。
可以看到加密过程就是xxtea+base64，但是我们用SCTF中的密钥和密文解出来是fake flag，在联想到之前那两个用途未知的字符串，猜测是替换了密文和密钥，尝试一下果然解出正确的flag：

import xxtea
from Crypto.Cipher import AES

key = 'syclover'+'x00'*8
s = 'UYc0pLw6EdGoEIH3mCpj/kkzRMR5+nl+9VGFICIIL6w='.decode('base64')

dec = xxtea.decrypt(s, key,padding=False)
print repr(dec)

 

Orz

程序的主要逻辑是做了两段加密。
第一段加密，首先根据flag中三个byte的和做种子，来生成一些随机数。之后，这些随机数与输入一起做一些数字运算：
sum0 = flag[0] ^ rand[0]
sum1 = flag[0] ^ rand[1] + flag[1] ^ rand[0]
sum2 = flag[0] ^ rand[2] + flag[1] ^ rand[1] + flag[2] ^ rand[0]
…
这个过程在随机数固定的前提下是可以逐位推回去的，由于三个可打印字符的和只有几百种可能性，因此可以直接爆破。
第二段是lfsr+des，其中des可以根据常量表识别，调试可以发现是标准des，lfsr跟signin类似，也很好逆回去。加密过程中有许多细节还是需要通过动态调试确认。
最后两段逻辑连起来，爆破出一个可打印字符串即为flag：

from libnum import *
dest = [0]*64
dest[0] = 0x4ECECA3B;
dest[1] = 0x1DE25ED2;
dest[2] = 0xDA7EBA7A;
dest[3] = 0x44F2041D;
dest[4] = 0x71270A83;
dest[5] = 0x715B81E2;
dest[6] = 0xCC2D1A85;
dest[7] = 0x6B97F8E2;
dest[8] = 0x4596FD5E;
dest[9] = 0xC9405183;
dest[10] = 0x67849B79;
dest[11] = 0xEF406872;
dest[12] = 0xDB7BE64E;
dest[13] = 0x77CA5D7F;
dest[14] = 0x6070B274;
dest[15] = 0xC2D41ACA;
dest[16] = 0x29662171;
dest[17] = 0x3A3AA2EB;
dest[18] = 0x54295545;
dest[19] = 0x51A2A886;
dest[20] = 0xB8591BC3;
dest[21] = 0xE6483C3B;
dest[22] = 0x8CFFBA61;
dest[23] = 0x53D9BFBD;
dest[24] = 0x5DACAA24;
dest[25] = 0x44052042;
dest[26] = 0x6F8736A6;
dest[27] = 0x4AD433FC;
dest[28] = 0x4DA7890F;
dest[29] = 0x1186C3C6;
dest[30] = 0x6BDC52CA;
dest[31] = 0x92FE845E;
dest[32] = 0xC7BBCDC0;
dest[33] = 0xDE6CAAF1;
dest[34] = 0x53A24F48;
dest[35] = 0x78834993;
dest[36] = 0x488B8BDA;
dest[37] = 0xEEA0C8A;
dest[38] = 0x1CC9883A;
dest[39] = 0xCDD1C18E;
dest[40] = 0xEE39C8CC;
dest[41] = 0xBA7C009;
dest[42] = 0x226A5717;
dest[43] = 0x5DC4DC65;
dest[44] = 0xEDE6EE3E;
dest[45] = 0x98620CDC;
dest[46] = 0xEDE770F4;
dest[47] = 0xD228163E;
dest[48] = 0x354BE5A8;
dest[49] = 0x7ECFB5E9;
dest[50] = 0x4D0D6FEA;
dest[51] = 0xE4C117B9;
dest[52] = 0x414C97B1;
dest[53] = 0x2F630D6;
dest[54] = 0xA9AB28BC;
dest[55] = 0x7A42D719;
dest[56] = 0x5436A531;
dest[57] = 0x5AFEBE42;
dest[58] = 0xB0E3691A;
dest[59] = 0x3E1B42F0;
dest[60] = 0xCA9380FC;
dest[61] = 0x44BEA9CC;
dest[62] = 0xF32B3091;
dest[63] = 0x57A91678;

def delfsr(n):
    ret = []
    odds = []
    x = n
    for i in range(64):
        x &= 0xffffffffffffffff
        ret.append(x)

        if x & 1 != 0:
            x ^= 0x3FD99AEBAD576BA5
            x = x/2 | 0x8000000000000000
            odds.append(1)
        else:
            x = x/2
            odds.append(0)
    ret.append(x & 0xffffffffffffffff)
    return ret, odds

from pyDes import des
xor_buf = [0x73,0x79,0x63,0x6c,0x6f,0x76,0x65,0x72]
dest_enc = []
for i in range(0, 64, 4):
    x = (dest[i+1] << 32) | dest[i] 
    keys, odds = delfsr(x)
    text = n2s((dest[i+3] << 32) | dest[i+2])[::-1]
    for j in range(64):
        kk = n2s(keys[j]).rjust(8, 'x00')
        kk=kk[::-1]
        text = des(kk).decrypt(text)
        if odds[j] == 1:
            text2 = ''
            for i in range(8):
                text2 += chr(ord(text[i]) ^ xor_buf[i])
            text = text2
        else:
            pass
    r2 = s2n(text[::-1])

    dest_enc.append(keys[64]&0xffffffff)
    dest_enc.append(keys[64]>>32)
    dest_enc.append(r2&0xffffffff)
    dest_enc.append(r2>>32)

for aa in range(95, 350):
    enc_lst = []
    seed = ((53*(aa))^0xffffffff)&0xfff
    for _ in range(32):
        seed = (0x1ED0675 * seed + 0x6C1)%254
        enc_lst.append(seed)

    flag=[]
    for i in range(32):
        tot = dest_enc[i]
        for j in range(i):
            tot -= flag[j]^enc_lst[i-j]
        flag.append(tot^enc_lst[0])

    if all (x in range(32,128) for x in flag):
        flag = ''.join(map(chr, flag))
        print flag

 

easyre

通过查找字符串引用可以找到check函数sub_40B600，里面逻辑比较复杂，但是通过对输入下硬件断点，可以跟到几处对flag的加密，有aes加密和一些位运算操作，然后最后与一串常量作比较。
如果跟着这段逻辑解完，最后会拿到一个fake flag。
假如我们逆向比较仔细，应该能够发现一个很长很可疑的字符串。在运行时，程序会通过自校验crc值对其进行异或解密。尝试解密，可以发现是一个dll，而且其中有一个enc函数跟check函数长得非常像。
通过查找引用还能找到一个函数sub_409FF0，里面跟check函数打印出了一样的字符串，但是这些字符串也同样被异或加密了，非常可疑。
于是我们解出dll，发现enc函数的逻辑与check函数非常像，但运算顺序和加密方式都有不同，比如aes key假逻辑是做了padding，而真逻辑是做了hex编码、异或密钥不同、和颠倒了三段位运算的顺序。
于是对应修改一下脚本，即可得到真正的flag：

from Crypto.Cipher import AES
dest = [0]*32
dest[0] = 0x8E
dest[1] = 0x38;
dest[2] = 0x51;
dest[3] = 0x73;
dest[4] = 0xA6
dest[5] = 0x99
dest[6] = 0x2A;
dest[7] = 0xF0
dest[8] = 0xDA
dest[9] = 0xD5
dest[10] = 0x6A;
dest[11] = 0x91
dest[12] = 0xE9
dest[13] = 0x4E;
dest[14] = 0x98
dest[15] = 0xCE
dest[16] = 0x2A;
dest[17] = 0xB7
dest[18] = 0x3D;
dest[19] = 0x40;
dest[20] = 0xF1
dest[21] = 0xE5
dest[22] = 0x1D;
dest[23] = 0xAB
dest[24] = 0xEF
dest[25] = 0xEE
dest[26] = 0xB0
dest[27] = 0xD6
dest[28] = 0x14;
dest[29] = 0xB;
dest[30] = 0x2A;
dest[31] = 0x95

aa3=[]

def ror(x, n):
    return ((x>>n)|(x<<(8-n)))&0xff

def enc_ef(x):
    return ror(x^0xef, 4)
def enc_ad(n):
    x=n^0xad
    return (((x&0xaa)>>1) | ((x<<1)&0xaa))&0xff
def enc_be(n):
    x=n^0xbe
    return (((x&0xcc)>>2) | ((x<<2)&0xcc))&0xff

def dec_ef(x):
    return ror(x, 4)^0xef
def dec_ad(x):
    n= (((x&0xaa)>>1) | ((x<<1)&0xaa))&0xff
    return n^0xad
def dec_be(x):
    n= (((x&0xcc)>>2) | ((x<<2)&0xcc))&0xff
    return n^0xbe

j = 0x55

aa3 = [0] * 32
for i in range(32):
    aa3[i] = dest[i]
for i in range(32):
    aa3[i] = aa3[i] ^ j
for i in range(7,14):
    aa3[i] = dec_ef(aa3[i])
for i in range(14,21):
    aa3[i] = dec_be(aa3[i])
for i in range(21,28):
    aa3[i] = dec_ad(aa3[i])

enc = ''.join(map(chr,aa3))
c = AES.new('SCTF2020'.encode('hex'))
ss = c.decrypt(enc)
print ss