2019 安洵杯 Re 部分WP

0x01.EasyEncryption

测试文件：https://www.lanzous.com/i7soysb

1.IDA打开

int sub_416560()
{
  int v0; // eax
  int v1; // edx
  int v2; // edx
  int v3; // ecx
  int v4; // ST08_4
  char v6[]; // [esp+310h] [ebp-7E0h]
  char Str; // [esp+700h] [ebp-3F0h]
  int v8; // [esp+AECh] [ebp-4h]
  int savedregs; // [esp+AF0h] [ebp+0h]

  sub_41132A((int)&unk_424091);
  sub_411294(std::cout, "输入flag: ");
  sub_41113B(std::cin, &Str);
  sub_4111F4(&Str, (int)v6);                    // v6="artqkoehqpkbihv"
  if ( (unsigned __int8)sub_4112B7(v6) )
  {
    sub_41105F("you are right\n");
    system("pause");
    sub_411339(v3, v2);
  }
  else
  {
    v0 = sub_411294(std::cout, "wrong");
    sub_41114A(v0, );
  }
  v4 = v1;
  sub_41137A(&savedregs, &dword_416660, );
  return sub_411339((unsigned int)&savedregs ^ v8, v4);
}

2.代码分析

输入flag之后，首先经过sub_4111F4(&Str, (int)v6)函数处理，再经过sub_4112B7(v6)函数判断。因为v6未知，所以首先通过最后一个函数找到v6

2.1 sub_4112B7函数分析

打开sub_4112B7函数

int __cdecl sub_413980(char *Str)
{
  int v1; // edx
  int v2; // ecx
  int v3; // edx
  int v4; // ecx
  int v5; // edx
  int v6; // ecx
  char *Str1; // [esp+D0h] [ebp-8h]

  sub_41132A((int)&unk_42405B);
  Str1 = (char *)sub_4112D5(Str);               // Base64
  if ( !j_strcmp(Str1, "YXJ0cWtvZWhxcGtiaWh2") )
  {
    free(Str1);
    sub_411339(v6, v5);
  }
  else
  {
    free(Str1);
    sub_411339(v2, v1);
  }
  return sub_411339(v4, v3);
}

通过分析得到，sub_4112D5函数是Base6加密，因此这个函数实际上就是将Str进行Base64加密，得到字符串Str1与"XJ0cWtvZWhxcGtiaWh2"比较。将"XJ0cWtvZWhxcGtiaWh2"进行Base64解密，得到Str，即v6="artqkoehqpkbihv"

2.2 sub_4111F4函数分析

接着，打开sub_4111F4函数，太长了，就不贴出来了。这个函数，分为三个部分：

0x01 第一部分：

 for ( i = ; byte_41EC80[i]; ++i )
  {
    v16 = (unsigned __int8)byte_41EC80[i] - ;
    v2 = j_abs(v16);
    v15[i] = v2;
  }

byte_41EC80已知，可以写出脚本变换，得到v15

Serial = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"

Li = []

for i in Serial:
    Li.append(abs(ord(i) - 97)

0x02 第二部分

 v10 = j_strlen(Str);
  if ( v10 % i <=  )
  {
    v3 = v10 % i;                               // 余数
    v9 = v10 / i;                               // 商
  }
  else
  {
    v3 = v10 % i;
    v9 = v10 / i + ;
  }

0x03 第三部分

  for ( j = ; j < v9; ++j )
  {
    for ( k = ; k < i; ++k )
    {
      if ( Str[v14] )                           // 输入的字符值不能为0
      {
        if ( Str[v14] <  || Str[v14] >  )  // 输入只能是小写字母
          exit();
        if ( (Str[v14] + v15[k] - ) %  +  >  )
          v4 = (Str[v14] + v15[k] - ) %  + ;
        else
          v4 = (Str[v14] + v15[k] - ) %  + ;
        v8 = v4;
        v3 = v14 + a2;
        *(_BYTE *)(v14++ + a2) = v8;
      }
    }
  }

第二部分,第三部分和v6，结合分析，可以得到输入的flag应该是15，那么v9=1,v3=15，而第三部分实际上就是一个根据输入字符，进行选择变换得到v14（即v6）,因为输入只能是小写字母，那我逆向变换的时候，只要得到的是小写字母，那就行了

3.脚本解密

Serial = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"

Li = []

for i in Serial:
    Li.append(abs(ord(i) - 97))
print(Li)

t1 = len(Li) - 1

enc = "artqkoehqpkbihv"
v10 = len(enc)
v14 = 0
Str = ''
for j in range(1):
    for k in range(v10):
        for n in range(10):
            tmp1 = ord(enc[v14]) - 71 + 26 * n + 97 - Li[k]
            tmp2 = ord(enc[v14]) - 97 + 26 * n + 97 - Li[k]
            if tmp1 >= 97 and tmp1 <= 122:
                print ("SUCCESS!")
                Str += chr(tmp1)
                break
            elif tmp2 >= 97 and tmp2 <= 122:
                print ("SUCCESS!")
                Str += chr(tmp2)
                break
            else:
                print("ERROR!")
        v14 = v14 + 1
print (Str)

4.get flag！

flag{umpnineissogood}

0x02 crackme

测试文件：https://www.lanzous.com/i7sucre

1.函数定位

首先定位到起始的函数sub_412AB0

 int __stdcall sub_412AB0(int a1, int a2, int a3, int a4)
 {
   size_t i; // [esp+D8h] [ebp-8h]

   for ( i = ; i < j_strlen(BASE64_table_41A080); ++i )
   {
     if ( BASE64_table_41A080[i] <=  && BASE64_table_41A080[i] >=  )
     {
       BASE64_table_41A080[i] -= ;
     }
     else if ( BASE64_table_41A080[i] <=  && BASE64_table_41A080[i] >=  )
     {
       BASE64_table_41A080[i] += ;
     }
   }
   MessageBoxA(, "hooked", "successed", );
   AddVectoredExceptionHandler(, Handler);
   return ;
 }

2.程序分析

2.1 Base64变表1

根据起始函数的第一个for循环，这里首先对Base64的表进行的变换，将大小写进行对换。

#include <iostream>
#include <string>

using namespace std;

string Str = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

int main()
{
    char v2;

    size_t i; // [esp+D8h] [ebp-8h]

    for (i = ; i < Str.length(); ++i)
    {
        if (Str[i] <=  && Str[i] >= )
        {
            Str[i] -= ;
        }
        else if (Str[i] <=  && Str[i] >= )
        {
            Str[i] += ;
        }
    }

    cout << Str << endl;

    system("PAUSE");
    return ;
}

Base64大小写变换

得到新base64表"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789+/"

2.2 向量化异常处理

SetUnhandledExceptionFilter()函数：https://baike.baidu.com/item/SetUnhandledExceptionFilter/2334228?fr=aladdin

AddVectoredExceptionHandler()函数：https://www.cnblogs.com/suanguade/p/6674232.html

接着使用向量化异常处理，进入 Handler

 int __stdcall Handler_0(_DWORD **a1)
 {
   char v2; // [esp+D0h] [ebp-18h]
   char v3; // [esp+D1h] [ebp-17h]
   char v4; // [esp+D2h] [ebp-16h]
   char v5; // [esp+D3h] [ebp-15h]
   char v6; // [esp+D4h] [ebp-14h]
   char v7; // [esp+D5h] [ebp-13h]
   char v8; // [esp+D6h] [ebp-12h]
   char v9; // [esp+D7h] [ebp-11h]
   char v10; // [esp+D8h] [ebp-10h]
   char v11; // [esp+D9h] [ebp-Fh]
   char v12; // [esp+DAh] [ebp-Eh]
   char v13; // [esp+DBh] [ebp-Dh]
   char v14; // [esp+DCh] [ebp-Ch]
   char v15; // [esp+DDh] [ebp-Bh]
   char v16; // [esp+DEh] [ebp-Ah]
   char v17; // [esp+DFh] [ebp-9h]

   if ( **a1 == - )
   {
     v2 = 'w';
     v3 = 'h';
     v4 = 'e';
     v5 = 'r';
     v6 = 'e';
     v7 = '_';
     v8 = 'a';
     v9 = 'r';
     v10 = 'e';
     v11 = '_';
     v12 = 'u';
     v13 = '_';
     v14 = 'n';
     v15 = 'o';
     v16 = 'w';
     v17 = '?';
     sm4_func((int)&unk_41A218, (int)&v2);
     SetUnhandledExceptionFilter((LPTOP_LEVEL_EXCEPTION_FILTER)TopLevelExceptionFilter);
   }
   return ;
 }

2.2.1 sm4加密

pysm4包下载安装教程：https://www.cnblogs.com/Mayfly-nymph/p/11939336.html

进入sm4_func函数（这个我改过名了）

int __cdecl sub_411F50(int a1, unsigned int *a2)
{
  unsigned int v2; // eax
  int v3; // ecx
  int result; // eax
  unsigned int v5; // [esp+D0h] [ebp-B8h]
  unsigned int v6; // [esp+DCh] [ebp-ACh]
  unsigned int v7; // [esp+E0h] [ebp-A8h]
  unsigned int v8; // [esp+E4h] [ebp-A4h]
  int v9; // [esp+E8h] [ebp-A0h]
  int v10[]; // [esp+ECh] [ebp-9Ch]
  unsigned int v11; // [esp+174h] [ebp-14h]
  unsigned int v12; // [esp+178h] [ebp-10h]
  unsigned int v13; // [esp+17Ch] [ebp-Ch]
  unsigned int v14; // [esp+180h] [ebp-8h]

  v5 = ;
  v11 = _byteswap_ulong(*a2);
  v12 = _byteswap_ulong(a2[]);
  v13 = _byteswap_ulong(a2[]);
  v2 = _byteswap_ulong(a2[]);
  v14 = v2;
  v6 = v11 ^ 0xA3B1BAC6;
  v7 = dword_417A68[] ^ v12;
  v8 = dword_417A68[] ^ v13;
  v3 = dword_417A68[] ^ v2;
  result = ;
  v9 = v3;
  while ( v5 < 0x20 )
  {
    v10[v5] = *(&v6 + v5) ^ sub_4114E0(dword_417A78[v5] ^ *(&v9 + v5) ^ *(&v8 + v5) ^ *(&v7 + v5));
    *(_DWORD *)(a1 +  * v5) = v10[v5];
    result = v5++ + ;
  }
  return result;
}

Google搜了下0xA3B1BAC6

发现了这个函数应该是sm4加密

2.2.2 异常处理

接着，使用SetUnhandledExceptionFilter捕获异常，进入TopLevelExceptionFilter

 _DWORD *__cdecl sub_412C30(_DWORD *a1)
 {
   _DWORD *result; // eax
   char v2; // STD7_1
   size_t i; // [esp+DCh] [ebp-8h]

   result = a1;
   if ( *(_DWORD *)*a1 == - )
   {
     for ( i = ; i < j_strlen(Str2); i +=  )
     {
       v2 = Str2[i];
       Str2[i] = Str2[i + ];
       Str2[i + ] = v2;
     }
     Str1 = sub_41126C(byte_41A180);
     *(_DWORD *)(a1[] + ) = *(_DWORD *)(*a1 + );
     *(_DWORD *)(a1[] + ) = *(_DWORD *)(*a1 + );
     *(_DWORD *)(a1[] + ) = *(_DWORD *)(*a1 + );
     *(_DWORD *)(a1[] + ) = *(_DWORD *)(*a1 + );
     *(_DWORD *)(a1[] + ) = *(_DWORD *)(*a1 + );
     *(_DWORD *)(a1[] + ) = *(_DWORD *)(*a1 + );
     *(_DWORD *)(a1[] + ) = sub_411136;
     result = (_DWORD *)-;
   }
   return result;
 }

第一个for循环就是在将Str2相邻两位互换

#include <iostream>
#include <string>

using namespace std;

string Str2 = "1UTAOIkpyOSWGv/mOYFY4R!!";

int main()
{
    char v2;

    for (int i = ; i < Str2.length(); i += )
    {
        v2 = Str2[i];
        Str2[i] = Str2[i + ];
        Str2[i + ] = v2;
    }

    cout << Str2 << endl;

    system("PAUSE");
    return ;
}

Str2相邻位变换

接着通过sub_41126C函数传入byte_41A180，返回值为Str2，最后将Str1与Str2比较是否相同，输出success或者error，这就很明显了，肯定要输出‘success’，那Str2就要等于'U1ATIOpkOyWSvGm/YOYFR4!!'

2.2.3 Base64变表2

打开sub_41126C函数

 _BYTE *__cdecl sub_413090(char *Str)
 {
   int k; // [esp+E4h] [ebp-5Ch]
   int v3; // [esp+F0h] [ebp-50h]
   signed int j; // [esp+FCh] [ebp-44h]
   int v5; // [esp+108h] [ebp-38h]
   signed int i; // [esp+114h] [ebp-2Ch]
   _BYTE *v7; // [esp+120h] [ebp-20h]
   signed int v8; // [esp+12Ch] [ebp-14h]
   int v9; // [esp+138h] [ebp-8h]

   v5 = ;
   v8 = j_strlen(Str);                           // Str长度
   if ( v8 %  )                                 // 设置字节长度
     v9 =  * (v8 / ) + ;
   else
     v9 =  * (v8 / );
   v7 = malloc((v9 + ) | -__CFADD__(v9, ));    // 申请空间
   v7[v9] = ;
   for ( i = ; i < v8; i +=  )                 // 三位三位的处理，base64？
   {
     v3 = ;
     for ( j = ; j < ; ++j )
       v3 |= (unsigned __int8)Str[j + i] <<  * ( - j);
     for ( k = ; k < ; ++k )
     {
       if ( k >=  - (i +  - v8) && i +  > v8 )// 长度大于等于4的部分使用'!'补齐
         v7[v5] = '!';
       else
         v7[v5] = ::Str[sub_4110FF((v3 >>  * ( - k)) & 0x3F)];
       ++v5;
     }
   }
   return v7;
 }

在函数sub_4110FF有一步不同的操作

int __cdecl sub_412760(int a1)
{
  return (a1 + ) % ;
}

这里+24，相当于变表的值为原表取值右移24位

Str = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789+/"

Str1 = ''

for i in Str:
    Str1 += Str[(Str.find(i)+24) % len(Str)]
print (Str1)

得到新的Base64表"yzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789+/abcdefghijklmnopqrstuvwx"

到这我们整个过程就分析完毕了，接下来只需要逆向操作就行了。

3.逆向解密

# encoding: utf-8
from pysm4 import decrypt,encrypt
from base64 import b64decode

Str = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789+/"
Str_ = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/="

Str1 = ''

# 变换之后的Base64表
for i in Str:
    Str1 += Str[(Str.find(i)+24) % len(Str)]
print (Str1)

# 之前是用变换之后的表进行Base64加密
# 现在转换为正常的Base64加密，
# 再解密得到sm4加密之后的字符串
enc = "U1ATIOpkOyWSvGm/YOYFR4!!"
dec1 = ''
for i in range(len(enc)):
    if enc[i] == '!':
        dec1 += '='
    else:
        dec1 += Str_[Str1.find(enc[i])]
print (dec1)

dec2 = b64decode(dec1)
print (dec2)

import codecs

# 先进行hex编码，再转换为十进制整型
encode_hex = codecs.getencoder("hex_codec")
dec3 = int(encode_hex(dec2)[0],16)
print (dec3)

# 将key转换为十进制
key = "where_are_u_now?"
key = int(encode_hex(key)[0],16)
print (key)

# 将解密的字符串转换会hex
decode_hex = codecs.getdecoder("hex_codec")
dec4 = decrypt(dec3, key)
dec4 = str(hex(dec4)[2:-1])

print (decode_hex(dec4)[0])

4. get flag！

flag{SM4foRExcepioN?!}

官方公布源码：https://github.com/D0g3-Lab/i-SOON_CTF_2019

其他WP：https://blog.csdn.net/Zarcs_233/article/details/103338006

这次进入线下，希望能够好好发挥，加油！