首页
论坛
课程
招聘
[原创]看雪.TSRC 2017CTF秋季赛第三题 wp
2017-10-29 19:34 1379

[原创]看雪.TSRC 2017CTF秋季赛第三题 wp

2017-10-29 19:34
1379

看雪.TSRC 2017CTF秋季赛第三题 wp

我为了做题,拒绝妹纸的邀请~

 

这是一道很简单的题,反调试的坑略多。这道题采用了很多常用的反调试手段,比如调用IsDebuggerPresent、进程名检查等等。另外也有利用SEH的非常规检测方法。现在的OD插件能轻松对付常规反调试,暗坑还需手动处理,我的工具太原始了。

 

我做这道题,猜+Python直接输出了答案,有了答案再对程序做了详细点的分析。猜是把算法和输入数据猜对了。所以有一定运气成分。

代码定位

首先通过对GetDlgItemTextA 下断点定位到关键函数434EF0(Base:400000).

 

在这个函数的开头,有常规反调试,可以无视。接着会调用GetDlgItemTextA获取用户输入的字符串并将输入的字符串进行两次变换,经过我测试发现,大部分输入经过两次变换后内存都是00(缓冲区长度1024左右),然后将变换后的结果取前3个字节送入一段数字摘要算法,该数字摘要算法的结果为32字节,转换HEX String后应当有64个ASCII字符,最后将64位长度的签名与用户输入进行比较。

 

初次看来,这段算法既然是摘要算法,那么输入怎么可能等于输出?这道题连续两次调用一个转换函数,会把任意字符串转成00,又因为每次固定取3字节签名,所以送入算法的数据恒定为:00 00 00. 后面会对这段摘要算法进行分析。

 

关键部分代码如下:

      String[0] = 0;
      memset1(&String[1], 0, 1023);
      a3 = 0;
      memset1(&v22, 0, 1023);
      v4 = GetDlgItemTextA(hDlg, 1001, String, 1025);
      v24 = runtimecheck(&v11 == &v11, v4);
      v19 = 0;
      memset1(&v20, 0, 1023);
      j_translate(String, 0x400u, &a3);
      v17 = 0;
      memset1(&v18, 0, 1023);
      j_translate(&a3, 0x400u, &v19);
      sub_42D96A(&v19, &v17, 1024);
      v16 = 3;                                  
      j_sm3(&v19, 3, v15);
      for ( i = 0; i < 32; ++i )
        springf1(&v14[2 * i], "%02x", v15[i]);
      v5 = strlen1(v14);
      v6 = &String[strlen1(String)];
      v7 = strlen1(v14);
      if ( !memcmp(v14, &v6[-v7], v5) )// &v6[-v7]实际是指向String,也就是输入的字符串 V5=0X40,V14是定值
      {
        sub_42D0B4();
        if ( sub_42D9AB(&dword_49B000, &v17) == 1 )// aa
        {
          v8 = MessageBoxA(0, "ok", "CrackMe", 0);
          runtimecheck(&v11 == &v11, v8);
        }
      }
    }

这段算法应该属于OpenSSL的一部分,有明显的OPenSSL风格,但是作者在算法内部内嵌了很多非常规的异常反调试手段,一共有4块,手动修改EIP绕过即可。

 

以下代码片段是作者封装的sm3算法函数:

int __cdecl sm3(int a1, int a2, int a3)
{
  int v3; // eax@1
  char v5; // [sp+Ch] [bp-1B4h]@1
  char v6; // [sp+D0h] [bp-F0h]@1
  unsigned int v7; // [sp+1BCh] [bp-4h]@1
  int savedregs; // [sp+1C0h] [bp+0h]@1

  memset(&v5, 0xCCu, 0x1B4u);
  v7 = &savedregs ^ dword_49B344;
  sub_42D294(&v6);   // init 初始化ctx
  sub_42DF2D(&v6, a1, a2); //update  传入加密数据
  sub_42D15E(&v6, a3); //final 获取结果
  memset1(&v6, 0, 232);
  sub_42D65E(&savedregs, &dword_437F18);
  v3 = sub_42D1E5(&savedregs ^ v7);
  return runtimecheck(1, v3);
}

作者分别在sub_42D294、sub_42DF2D、sub_42D15E插入了反调试代码,代码非常显眼。

 

几乎所有反调试相关的代码都是这种判断格式,汇编特征更加明显:

 

在动态调试时,直接强制修改EIP到pop edi处实现绕过,后面几处同样的方法处理,一定要注意别跳错了,我就因为跳错了,程序没报错,算出来的结果是错的。

 

特征大概是call xxx,mov [XXX],eax,cmp eax,0 类似的指令序列。

 

那么我是如何判断这个算法的呢?这个算法是sm3算法,在百度上有很多资料。 通过搜索关键常量,就可以在百度上找到相关实现代码。

 

*(a1 + 8) = 0x7380166F;

 

*(a1 + 12) = 0x4914B2B9;

 

*(a1 + 16) = 0x172442D7;

 

*(a1 + 20) = 0xDA8A0600;

 

*(a1 + 24) = 0xA96F30BC;

 

*(a1 + 28) = 0x163138AA;

 

*(a1 + 32) = 0xE38DEE4D;

 

*(a1 + 36) = 0xB0FB0E4E;

 

Python实现如下:

import struct 
IV="7380166f 4914b2b9 172442d7 da8a0600 a96f30bc 163138aa e38dee4d b0fb0e4e" 
IV = int(IV.replace(" ", ""), 16) 
a = [] 
for i in range(0, 8): 
        a.append(0) 
        a[i] = (IV >> ((7 - i) * 32)) & 0xFFFFFFFF 
IV = a 


def out_hex(list1): 
        for i in list1: 
                print "%08x" % i, 
        print "\n", 


def rotate_left(a, k): 
        k = k % 32 
        return ((a << k) & 0xFFFFFFFF) | ((a & 0xFFFFFFFF) >> (32 - k)) 


T_j = [] 
for i in range(0, 16): 
        T_j.append(0) 
        T_j[i] = 0x79cc4519 
for i in range(16, 64): 
        T_j.append(0) 
        T_j[i] = 0x7a879d8a 


def FF_j(X, Y, Z, j): 
        if 0 <= j and j < 16: 
                ret = X ^ Y ^ Z 
        elif 16 <= j and j < 64: 
                ret = (X & Y) | (X & Z) | (Y & Z) 
        return ret 


def GG_j(X, Y, Z, j): 
        if 0 <= j and j < 16: 
                ret = X ^ Y ^ Z 
        elif 16 <= j and j < 64: 
                #ret = (X | Y) & ((2 ** 32 - 1 - X) | Z) 
                ret = (X & Y) | ((~ X) & Z) 
        return ret 


def P_0(X): 
        return X ^ (rotate_left(X, 9)) ^ (rotate_left(X, 17)) 


def P_1(X): 
        return X ^ (rotate_left(X, 15)) ^ (rotate_left(X, 23)) 


def CF(V_i, B_i): 
        W = [] 
        for j in range(0, 16): 
                W.append(0) 
                unpack_list = struct.unpack(">I", B_i[j*4:(j+1)*4]) 
                W[j] = unpack_list[0] 
        for j in range(16, 68): 
                W.append(0) 
                W[j] = P_1(W[j-16] ^ W[j-9] ^ (rotate_left(W[j-3], 15))) ^ (rotate_left(W[j-13], 7)) ^ W[j-6] 
                str1 = "%08x" % W[j] 
        W_1 = [] 
        for j in range(0, 64): 
                W_1.append(0) 
                W_1[j] = W[j] ^ W[j+4] 
                str1 = "%08x" % W_1[j] 


        A, B, C, D, E, F, G, H = V_i 
        """ 
        print "00", 
        out_hex([A, B, C, D, E, F, G, H]) 
        """ 
        for j in range(0, 64): 
                SS1 = rotate_left(((rotate_left(A, 12)) + E + (rotate_left(T_j[j], j))) & 0xFFFFFFFF, 7) 
                SS2 = SS1 ^ (rotate_left(A, 12)) 
                TT1 = (FF_j(A, B, C, j) + D + SS2 + W_1[j]) & 0xFFFFFFFF 
                TT2 = (GG_j(E, F, G, j) + H + SS1 + W[j]) & 0xFFFFFFFF 
                D = C 
                C = rotate_left(B, 9) 
                B = A 
                A = TT1 
                H = G 
                G = rotate_left(F, 19) 
                F = E 
                E = P_0(TT2) 


                A = A & 0xFFFFFFFF 
                B = B & 0xFFFFFFFF 
                C = C & 0xFFFFFFFF 
                D = D & 0xFFFFFFFF 
                E = E & 0xFFFFFFFF 
                F = F & 0xFFFFFFFF 
                G = G & 0xFFFFFFFF 
                H = H & 0xFFFFFFFF 
                """ 
                str1 = "%02d" % j 
                if str1[0] == "0": 
                        str1 = ' ' + str1[1:] 
                print str1, 
                out_hex([A, B, C, D, E, F, G, H]) 
                """ 


        V_i_1 = [] 
        V_i_1.append(A ^ V_i[0]) 
        V_i_1.append(B ^ V_i[1]) 
        V_i_1.append(C ^ V_i[2]) 
        V_i_1.append(D ^ V_i[3]) 
        V_i_1.append(E ^ V_i[4]) 
        V_i_1.append(F ^ V_i[5]) 
        V_i_1.append(G ^ V_i[6]) 
        V_i_1.append(H ^ V_i[7]) 
        return V_i_1 


def hash_msg(msg): 
        len1 = len(msg) 
        reserve1 = len1 % 64 
        msg = msg + chr(0x80) 
        reserve1 = reserve1 + 1 
        for i in range(reserve1, 56): 
                msg = msg + chr(0x00) 


        bit_length = (len1) * 8 
        bit_length_string = struct.pack(">Q", bit_length) 
        msg = msg + bit_length_string 


        #print len(msg) 
        group_count = len(msg) / 64 


        m_1 = B = [] 
        for i in range(0, group_count): 
                B.append(0) 
                B[i] = msg[i*64:(i+1)*64] 


        V = [] 
        V.append(0) 
        V[0] = IV 
        for i in range(0, group_count): 
                V.append(0) 
                V[i+1] = CF(V[i], B[i]) 


        return V[i+1]

输出答案:

 

y = hash_msg("\x00\x00\x00")

 

print out_hex(y)

 

183920f0 0e15a043 3ee3a8fc 90dd9ac1 64c4142c cf63ca18 9a8f645e c96ff8de


[培训]12月3日2020京麒网络安全大会《物联网安全攻防实战》训练营,正在火热报名中!地点:北京 · 新云南皇冠假日酒店

收藏
点赞0
打赏
分享
最新回复 (0)
游客
登录 | 注册 方可回帖
返回