buu-reverse-刮开有奖 题解

依照传统

根据string中可疑的关键字U g3t 1T!找到主函数

BOOL __stdcall DialogFunc(HWND hDlg, UINT a2, WPARAM a3, LPARAM a4)
{
  const char *v4; // esi
  const char *v5; // edi
  int v7; // [esp+8h] [ebp-20030h]
  int v8; // [esp+Ch] [ebp-2002Ch]
  int v9; // [esp+10h] [ebp-20028h]
  int v10; // [esp+14h] [ebp-20024h]
  int v11; // [esp+18h] [ebp-20020h]
  int v12; // [esp+1Ch] [ebp-2001Ch]
  int v13; // [esp+20h] [ebp-20018h]
  int v14; // [esp+24h] [ebp-20014h]
  int v15; // [esp+28h] [ebp-20010h]
  int v16; // [esp+2Ch] [ebp-2000Ch]
  int v17; // [esp+30h] [ebp-20008h]
  CHAR String; // [esp+34h] [ebp-20004h]
  char v19; // [esp+35h] [ebp-20003h]
  char v20; // [esp+36h] [ebp-20002h]
  char v21; // [esp+37h] [ebp-20001h]
  char v22; // [esp+38h] [ebp-20000h]
  char v23; // [esp+39h] [ebp-1FFFFh]
  char v24; // [esp+3Ah] [ebp-1FFFEh]
  char v25; // [esp+3Bh] [ebp-1FFFDh]
  char v26; // [esp+10034h] [ebp-10004h]
  char v27; // [esp+10035h] [ebp-10003h]
  char v28; // [esp+10036h] [ebp-10002h]

  if ( a2 == 272 )
    return 1;
  if ( a2 != 273 )
    return 0;
  if ( (_WORD)a3 == 1001 )
  {
    memset(&String, 0, 0xFFFFu);
    GetDlgItemTextA(hDlg, 1000, &String, 0xFFFF);
    if ( strlen(&String) == 8 )
    {
      v7 = 90;
      v8 = 74;
      v9 = 83;
      v10 = 69;
      v11 = 67;
      v12 = 97;
      v13 = 78;
      v14 = 72;
      v15 = 51;
      v16 = 110;
      v17 = 103;
      sub_4010F0((int)&v7, 0, 10);
      memset(&v26, 0, 0xFFFFu);
      v26 = v23;
      v28 = v25;
      v27 = v24;
      v4 = sub_401000((int)&v26, strlen(&v26));
      memset(&v26, 0, 0xFFFFu);
      v27 = v21;
      v26 = v20;
      v28 = v22;
      v5 = sub_401000((int)&v26, strlen(&v26));
      if ( String == v7 + 34
        && v19 == v11
        && 4 * v20 - 141 == 3 * v9
        && v21 / 4 == 2 * (v14 / 9)
        && !strcmp(v4, "ak1w")
        && !strcmp(v5, "V1Ax") )
      {
        MessageBoxA(hDlg, "U g3t 1T!", "@_@", 0);
      }
    }
    return 0;
  }
  if ( (_WORD)a3 != 1 && (_WORD)a3 != 2 )
    return 0;
  EndDialog(hDlg, (unsigned __int16)a3);
  return 1;
}

GetDlgItemTextA

GetDlgItemText是C++中的函数，调用这个函数以获得与对话框中的控件相关的标题或文本。GetDlgItemText成员函数将文本拷贝到lpStr指向的位置并返回拷贝的字节的数目。

int GetDlgItemText( HWND hDlg , int nID, LPTSTR lpStr, int nMaxCount) const;

int GetDlgItemText( int nID, CString& rString) const;

依照查询的资料理解其中的string就是输入值，那么大概可以猜得到，string为flag的时候，满足处理和条件就会输出提示正确的字符，所以关键是理解正向的处理和条件反向得到正确的输入值

    memset(&String, 0, 0xFFFFu);
    GetDlgItemTextA(hDlg, 1000, &String, 0xFFFF);
    //又因为U g3t 1T!在if里面输出所以string为八位
    if ( strlen(&String) == 8 ){
        //....
    }

*变量地址分析：string，v7-25

接下来分析if(strlen&String==8){}里面的内容

通过查询连续的变量地址和比照源码得到以下关系

-00020034 var_20034       dd ?    
-00020030 var_20030       dd ?    //v7
-0002002C var_2002C       dd ?    //v8
-00020028 var_20028       dd ?    //v9
-00020024 var_20024       dd ?    //v10
-00020020 var_20020       dd ?    //v11
-0002001C var_2001C       dd ?    //v12
-00020018 var_20018       dd ?    //v13
-00020014 var_20014       dd ?    //v14
-00020010 var_20010       dd ?    //v15
-0002000C var_2000C       dd ?    //v16
-00020008 var_20008       dd ?    //v17
-00020004 String          db ?    //输入的string首字母地址（总长8位以下其实是string的其余部分，因为数组的地址是连续的）
-00020003 var_20003       db ?    //v19 也就是string的第二个字符
-00020002 var_20002       db ?    //v20 也就是string的第三个字符
-00020001 var_20001       db ?    //v21 也就是string的第四个字符
-00020000 var_20000       db ?    //v22 也就是string的第五个字符
-0001FFFF var_1FFFF       db ?    //v23 也就是string的第六个字符
-0001FFFE var_1FFFE       db ?    //v24 也就是string的第七个字符
-0001FFFD var_1FFFD       db ?    //v25 也就是string的第八个字符

可以看得出，，又分别取string的第三到五和第六到七的字符，赋值到另一个长度为3的数组中（首字符为v26），然后取这个数组经过sub_401000处理

//代码初始化了`v7-v17`的内容然后经过`sub_4010F0`处理
  v7 = 90;
  v8 = 74;
  v9 = 83;
  v10 = 69;
  v11 = 67;
  v12 = 97;
  v13 = 78;
  v14 = 72;
  v15 = 51;
  v16 = 110;
  v17 = 103;
  sub_4010F0((int)&v7, 0, 10);
//取string的第六到八也就是v23-25，赋值到另一个长度为3的数组中（v26-28）
//然后对（v26-28）这个数组经过`sub_401000`处理后把返回值赋给v4为头的字符串
  memset(&v26, 0, 0xFFFFu);
  v26 = v23;
  v28 = v25;
  v27 = v24;
  v4 = sub_401000((int)&v26, strlen(&v26));
//取string的第三到五的字符也就是v20-22，赋值到另一个长度为3的数组中（v26-28）
//然后对（v26-28）这个数组经过`sub_401000`处理后把返回值赋给v5为头的字符
  memset(&v26, 0, 0xFFFFu);
  v27 = v21;
  v26 = v20;
  v28 = v22;
  v5 = sub_401000((int)&v26, strlen(&v26));
//判断部分
  if ( String == v7 + 34 //string第一位是v7+34的ascii码（v7-v17被sub_4010F0处理过）
    && v19 == v11 //string的第二位是v11的ascii码（v7-v17被sub_4010F0处理过）
    && 4 * v20 - 141 == 3 * v9
    && v21 / 4 == 2 * (v14 / 9)
    && !strcmp(v4, "ak1w")  //string的第六到八位经sub_401000处理后应该为ak1w
    && !strcmp(v5, "V1Ax") )//string的第三到五位经sub_401000处理后应该为V1Ax
  {
    MessageBoxA(hDlg, "U g3t 1T!", "@_@", 0);
  }

因此很自然的需要解读sub_4010F0和sub_401000做了什么

*sub_4010F0

因为没法直接猜出加密过程是已知的哪一种，或者直接分析太过复杂，因为并不能直接修改

这里sub_4010f0的修改参考的博客：https://www.cnblogs.com/dyhaohaoxuexi/p/11421263.html 原理已补上

#include<bits/stdc++.h>
using namespace std;

// __cdecl是关于堆栈的一个关键字，事关处理优先级，正常可以剔除
// 
//int __cdecl sub_4010F0(int a1, int a2, int a3) 
int sub_4010F0(char a1[], int a2, int a3)
{
  int result; // eax
  int i; // esi
  int v5; // ecx
  int v6; // edx

  result = a3;
  for ( i = a2; i <= a3; a2 = i )
  {
//      _DWORD即double word代表两个word而一个word两字节（Byte）则dword就是四个字节
//      这个过程可以理解为*((_DWORD *)(4 * i + a1));
//      也就是1.a1的地址加上4*i（每个dworld占四字节，因此也代表下一个连续的dword指针地址）（a1原本是数组的首地址）
//      2.把这个地址强制转换为dword指针类型，然后获得这个地址所指向的值（*取值符）  
//      而这个v5就是为了不要每一次都是i*5而储存起来的值 
//      因此如果使用一般数组的表示形式v5=i v6=a1[i] 
//    v5 = 4 * i;
//    v6 = *(_DWORD *)(4 * i + a1);
    v5 = i;
    v6 = a1[i];
    if ( a2 < result && i < result )
    {
      do
      {
          //同理v6>a1[result] 
        //if ( v6 > *(_DWORD *)(a1 + 4 * result) )
        if ( v6 > a1[result] )
        {
          if ( i >= result )
            break;
          ++i;
          //同理a1[v5]（因为修改后v5没×4原本是有的） 
          //*(_DWORD *)(v5 + a1) = *(_DWORD *)(a1 + 4 * result);
          a1[v5] = a1[result];
          if ( i >= result )
            break;
          //同理a1[i] <=6
          //while ( *(_DWORD *)(a1 + 4 * i) <= v6 )
          while ( a1[i] <= v6 )
          {
            if ( ++i >= result )
              goto LABEL_13;
          }
          if ( i >= result )
            break;
          //同理
          //v5=i    a1[result]=a1[i]
          //v5 = 4 * i;
          //*(_DWORD *)(a1 + 4 * result) = *(_DWORD *)(4 * i + a1);
          v5 =i;
          a1[result]= a1[i];
        }
        --result;
      }
      while ( i < result );
    }
LABEL_13:
    //同理a1[result]=v6 
    //*(_DWORD *)(a1 + 4 * result) = v6;
    a1[result] = v6;
    sub_4010F0(a1, a2, i - 1);
    result = a3;
    ++i;
  }
  return result;
}

char s[20]={90,74,83,69,67,97,78,72,51,110,103};
int main()
{
    sub_4010F0(s,0,10);
    for(int i=0;i<=10;i++)
        cout<<"v"<<i+7<<": "<<s[i]<<"(ascii: "<<int(s[i])<<")"<<endl;
    //前面分析过string第一位是v7+34的ascii码（v7-v17被sub_4010F0处理过）
    cout<<"string第一位："<<char(int(s[0])+34)<<endl;
    //前面分析过string的第二位是v11的ascii码（v7-v17被sub_4010F0处理过）
    cout<<"string第二位："<<s[4]<<endl; 
    /*输出： 
        v7: 3(ascii: 51)
        v8: C(ascii: 67)
        v9: E(ascii: 69)
        v10: H(ascii: 72)
        v11: J(ascii: 74)
        v12: N(ascii: 78)
        v13: S(ascii: 83)
        v14: Z(ascii: 90)
        v15: a(ascii: 97)
        v16: g(ascii: 103)
        v17: n(ascii: 110)
        string第一位：U
        string第二位：J
    */ 
}

sub_401000

对于sub_401000其内容中的

        *v8++ = byte_407830[*((char *)&v18 + v12)];

其中的byte_407830是高亮的，可以查询到初始值的，如下

.rdata:00407830 byte_407830     db 41h                  ; DATA XREF: sub_401000+C0↑r
.rdata:00407831 aBcdefghijklmno db 'BCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=',0

参考上一篇：http://poilzero.sipc115.club/index.php/archives/44/ 类似的经验

可以猜测这一段就是base64加密，那么结合主函数的内容

    && !strcmp(v4, "ak1w")  //string的第六到八位经sub_401000处理后应该为ak1w
    && !strcmp(v5, "V1Ax") )//string的第三到五位经sub_401000处理后应该为V1Ax

用base64解码就可以得到string第三到八位的值，经过转换得到第三到八位的值为：WP1jMp

base64解码：

jMp<=ak1w 第六到第八位
WP1<=V1Ax 第三到第五位

那么结合前面得到的第一第二位，为flag的string就应该是UJjMpWP1

总结

个人认为本题有两个难点

  1. 是v7-v25，和string的含义需要结合地址来理解，原理是数组的（汇编后没有数组这一个概念，只是体现在地址上变量是连续的）
  2. sub_4010F0 翻译成可执行代码
Last modification：January 13, 2021
© Allow specification reprint
如果觉得我的文章对你有用，请随意赞赏。咖啡（12RMB）进度+100%，一块巧克力（1RMB）进度+6%。
（赞赏请备注你的名称哦！后台记录中来自理工小菜狗）