cumtctf2018_初赛部分wp

比较晚的复现 一直挂念着当时没做出来的MFC逆向

还有RC4的源码 和 介绍
当时差一点点做出300的那题 就差最后的解方程 没时间了 很气
这里就写两题逆向的吧

0x00 Symmetric Cipher – 250

当时完全摸不着头脑的MFC逆向题 真鸡儿难！

主要是完全找不到关键的check函数

基于MFC的教程1

基于MFC的教程2

基于MFC的教程3

这里我用的是第三篇里的方法 搜索控件ID(也可以用xspy)


看到输入框的ID是比较特殊的1003
用ida搜索立即数的功能 alt+I


我们要找到.rdata中指令为数据，并且数值是1003(十六进制为0x3EB)的地址，注意这边只会显示一个字节db，所以是0x3EB的EB，双击跟进是不是一下子就到了消息映射表了？只要把当前的消息映射表用上一篇的方法转换下，很快就能定位到对应的按钮处理函数了

不用转换也行 就是往下翻一翻 点开函数就能看到关键函数了

第一个是判断flag长度是否到了30

int __thiscall sub_4024C0(char *this)
{
  char *v1; // edi@1
  int v2; // esi@1

  v1 = this;
  sub_4213DC(1);
  sub_41E9CD(v1 + 172);
  v2 = *(_DWORD *)(*((_DWORD *)v1 + 43) - 12);
  sub_42335A(1);
  return sub_423213(v2 == 30);//这里就是判断输入的flag的长度的
}

第二个是关键的check函数


进去是一个rc4加密

RC4详解（也可参考课堂5）

RC4由伪随机数生成器和异或运算组成。RC4的密钥长度可变，范围是[1,255]。RC4一个字节一个字节地加解密。给定一个密钥，伪随机数生成器接受密钥并产生一个S盒。S盒用来加密数据，而且在加密过程中S盒会变化。
由于异或运算的对合性，RC4加密解密使用同一套算法。

包括初始化算法（KSA）和伪随机子密码生成算法（PRGA)

前两个循环是密钥的加密形成

char __thiscall sub_4025F0(void *this)
{
  v20 = xmmword_5B2188;
  v1 = this;
  v21 = xmmword_5B2198;
  sub_5542A0(v19, 0, 256);
  v3 = 0;
  v2 = strlen(&v20);
  sub_5542A0(v18, 0, 256);
  v4 = 0;
  do
  {
    v19[v4] = v4;
    v18[v4] = *(&v20 + v4 % v2);
    ++v4;
  }
  while ( v4 < 256 );//S盒长度256
  v5 = 0;
  do
  {
    v6 = v19[v5];
    v3 = (v19[v5] + v18[v5] + v3) % 256; //这个是特点 三个相加%256
    v19[v5++] = v19[v3];
    v19[v3] = v6;
  }
  while ( v5 < 256 );

后一个循环是对明文的加密

v7 = strlen(v1);
v8 = 0;
v9 = 0;
v17 = 0;
if ( v7 > 0 )
{
  do
  {
    v9 = (v9 + 1) % 256;
    v10 = v19[v9];
    v11 = v19[v9];
    v8 = (v11 + v8) % 256;
    v19[v9] = v19[v8];
    v19[v8] = v10;
    v12 = v17;
    *(v1 + v12) ^= v19[(v11 + v19[v9])];
    ++v17;
  }
  while ( v12 + 1 < v7 );
}

最后这段代码就是一个比较

  v13 = &v20;
  v20 = xmmword_5B26B0;
  *&v21 = -7515150351613074048i64;
  v14 = 27;
  DWORD2(v21) = 1762473319;
  WORD6(v21) = 10706;
  BYTE14(v21) = 0;
  while ( *v1 == *v13 )
  {
    v1 = v1 + 4;
    v13 = (v13 + 4);
    v15 = v14 < 4;
    v14 -= 4;
    if ( v15 )
    {
      if ( *v1 == *v13 && *(v1 + 2) == *(v13 + 2) )
        return 1;
      return 0;
    }
  }
  return 0;
}

这里专门写一下 RC4 的python的代码

class RC4:
    def __init__(self,k):
        self.Sbox = self.RC4_init(k)
    def RC4_init(self,k):
        Sbox = range(256)
        T = [ord(k[i % len(k)])for i in range(256)]
        j= 0
        for i in range(256):
            j=(j + Sbox[i] + T[i]) & 0xFF
            Sbox[i],Sbox[j] = Sbox[j] , Sbox[i]
        return Sbox

    def Encrypt(self,m):
        c = ""
        S = self.Sbox[:]
        i = j = 0
        for ch in m:
            i = (i + 1) & 0xFF
            j= (j + S[i]) & 0xFF
            S[i],S[j] = S[j],S[i]
            t = (S[i] +S[j]) & 0xFF
            c += chr(ord(ch) ^ S[t])
        return c
if __name__ == "__main__" :
    key = "1234"
    rc4 = RC4(key)
    s = "6d2c1dc39c9b687f637f".decode('hex')
    m = rc4.Encrypt(s)
    print m

输出

helloworld

改一下输入 key是硬编码

key = 'noitaicossA_llabteksaB_lanoitaN'[::-1]
rc4 = RC4(key)
s = '29D2690D356797B4D2927A7365804560DD28BEF14F6DB2DE525C8161BEAE'
s=s[2::].decode('hex')[::-1]
print base64.b64encode(s)
m = rc4.Encrypt(s)
print m

rr5hgVxS3rJtT/G+KN1gRYBlc3qS0rSXZzUNadI=

cumtctf{Mfc_1s_VerY_difflcUIt}

领航杯的

# -*- coding: utf-8 -*-
import random, base64
from hashlib import sha1
def crypt(data, key):
    """RC4 algorithm"""
    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)


def tencode(data, key, encode=base64.b64encode, salt_length=16):
    """RC4 encryption with random salt and final encoding"""
    salt = ''
    for n in range(salt_length):
        salt += chr(random.randrange(256))
    data = salt + crypt(data, sha1(key + salt).digest())
    if encode:
        data = encode(data)
    return data


def tdecode(data, key, decode=base64.b64decode, salt_length=16):
    """RC4 decryption of encoded data"""
    if decode:
        data = decode(data)
    salt = data[:salt_length]
    return crypt(data[salt_length:], sha1(key + salt).digest())


if __name__ == '__main__':
    for i in range(999,10000):
        key=str(i)
        encoded_data='nKgI13JDX8qpFyUcvsnZqyKxb8Zfv9jCnrWul2knc8ZzhlfDpPxZmA=='
        decoded_data = tdecode(data=encoded_data, key=key)
        if decoded_data[0]=='f':
            print decoded_data

0x01 Windows Cracker

这题差在最后的解方程 没找到合适的方法解方程 导致功亏一篑

是一个Windows下的GUI程序，程序本身很简单，就是弹出一个对话框，根据输入计算flag
程序的量比较小 可以靠翻翻到主要的check函数

在这个程序中，窗口过程首先接受WM_CREATE消息，进行窗口控件的创建，创建了一个文本框和一个确定按钮。对于确定按钮，定义了HMENU参数是250,一句话，也就是说在点击按钮后，产生wParam消息的低位是250，直接进入sub_401350()函数中进行判断

这里调用GetWindowTextA()API来判断输入长度，当输入长度不是41的时候，直接通过SendMessageW()向窗口过程发送消息，且wParam参数是1111，上一级函数里，此时会直接调用MessageBoxW(hWnd, L”flag错误”, L”FAIL”, 0x40u)即弹框，flag错误。所以我们可以确定flag长度就是41。接下来进入核心的Check函数验证算法

#coding:utf-8
__author__='zjgcjy'
import binascii
from z3 import *

def solver():
    res = ''
    cipher = "97b1c8cdd5d29694b8b4c5daa471718fbe94a4d0def3d5d4d4c4d9e5c1c4d5daf4e7c1bed7c196646a"
    mat = [Int('mat%d'% i)for i in xrange(41)]
    auth = [ord(i) for i in binascii.a2b_hex(cipher)]
    s = Solver()
    s.add(And(
        auth[0] == mat[7] + mat[24],
        auth[1] == mat[24] + mat[0],
        auth[2] == mat[0] + mat[17],
        auth[3] == mat[17] + mat[34],
        auth[4] == mat[34] + mat[10],
        auth[5] == mat[10] + mat[27],
        auth[6] == mat[27] + mat[3],
        auth[7] == mat[3] + mat[20],
        auth[8] == mat[20] + mat[37],
        auth[9] == mat[37] + mat[13],
        auth[10] == mat[13] + mat[30],
        auth[11] == mat[30] + mat[6],
        auth[12] == mat[6] + mat[23],
        auth[13] == mat[23] + mat[40],
        auth[14] == mat[40] + mat[16],
        auth[15] == mat[16] + mat[33],
        auth[16] == mat[33] + mat[9],
        auth[17] == mat[9] + mat[26],
        auth[18] == mat[26] + mat[2],
        auth[19] == mat[2] + mat[19],
        auth[20] == mat[19] + mat[36],
        auth[21] == mat[36] + mat[12],
        auth[22] == mat[12] + mat[29],
        auth[23] == mat[29] + mat[5],
        auth[24] == mat[5] + mat[22],
        auth[25] == mat[22] + mat[39],
        auth[26] == mat[39] + mat[15],
        auth[27] == mat[15] + mat[32],
        auth[28] == mat[32] + mat[8],
        auth[29] == mat[8] + mat[25],
        auth[30] == mat[25] + mat[1],
        auth[31] == mat[1] + mat[18],
        auth[32] == mat[18] + mat[35],
        auth[33] == mat[35] + mat[11],
        auth[34] == mat[11] + mat[28],
        auth[35] == mat[28] + mat[4],
        auth[36] == mat[4] + mat[21],
        auth[37] == mat[21] + mat[38],
        auth[38] == mat[38] + mat[14],
        auth[39] == mat[14] + mat[31],
        auth[40] == mat[31] + mat[7],))
    for i in xrange(41):
        s.add(mat[i] > 0x20)
        s.add(mat[i] < 0x80)
    if(s.check() == sat):
        m = s.model()
        for i in xrange(41):
            res += chr(m[mat[i]].as_long())
    print res
if __name__ == '__main__':
    main()
def decode():
    mat = [i for i in xrange(41)]
    str1 = r'''cao1iutIP_mlv_Ct0eyacn_0Nt5eU_f!q_h{}USeA'''
    for i in xrange(41):
        mat[(i * 5) % 41] = str1[(i * (-16)) % 41]
    print ''.join(mat)

cumtctf{Ai_CaN_he1P_y0U_SoIve_eqUatl0n5!}