BUUCTF-[SCTF2019]babyre1

内怀童心外表成熟

已于 2023-02-10 21:58:48 修改

阅读量639

点赞数 2

分类专栏： re简单题文章标签：算法 c++ python 网络安全

于 2023-02-10 19:14:11 首次发布

本文链接：https://blog.csdn.net/weixin_61154173/article/details/128971374

版权

re简单题专栏收录该内容

41 篇文章 2 订阅

订阅专栏

题目下载:下载

无壳，载入IDA，进入主函数。发现不能查看伪代码，在查看汇编语言，发现地址处为红色，应该是有花指令。修改花指令：

第一处花指令：

一般这种形式的都是存在花指令的，根据提示“plz tell me the shortest password1”，所以这个指令一定执行所以可以把jb，jnb，loope这三个指令nop掉。继续向下找。

第二处花指令：

同理，nop掉jb，jnb，loop指令。

第三处花指令：

同理，nop掉jb，jnb，jrcxz。

第四处花指令：

把jb，jnb继续nop掉。这里有个in操作，查看他的机器码，因为mov指令的机器码是C7，这里第二个是c7，怀疑是不是个花指令，把mov指令操作给干扰掉了，所以把E4给nop掉。(nop机器码为90h)。

修改后：

发现还有个test指令，他前后是数据，所以按‘D’键把他变成数据，后面应该会重新反汇编识别代码。
这时候可能大家就会直接p键生成函数了。如下：

发现有一处错误，且是0xC22处，观察汇编代码。经过查阅资料可知：

此处 call loc_C22。但是loc_C22并不是个函数，所以要把loc_C22变为函数，跟进loc_C22。按Y重新声明为函数。

之后再把其他的声明为函数类型即可查看伪代码。

发现flag分为三个部分，

看第一部分：

把迷宫赋给v17，然后v7初值是起点，然后看具体操作：

用户输入为v15，从操作可以看出w向上，s向下，a向左，d向右，x向下走一个迷宫大小，y向上走一个迷宫大小。又因为上下走是加减5，所以迷宫五行五列。根据前面的v7初值s为起点。然后根据if条件判断知道路线沿着‘.’走，不能‘*’，终点是‘#’。所以第一个密码是：ddwwxxssxaxwwaasasyywwdd

第二部分：

主要是sub_C22和sub_F67函数，先看一下sub_F67函数。

是判断两字符串是否相等，相等为1，所以经过input2经过sub_C22操作赋值给v13，v13应该等于v8等于'sctf_9102' 。

跟进sub_C22：

unsigned __int64 __fastcall sub_C22(const char *a1, __int64 a2)
{
  int v2; // eax
  int v3; // eax
  int v4; // eax
  int v6; // [rsp+14h] [rbp-24Ch]
  int v7; // [rsp+18h] [rbp-248h]
  int v8; // [rsp+1Ch] [rbp-244h]
  int v9; // [rsp+20h] [rbp-240h]
  int v10; // [rsp+24h] [rbp-23Ch]
  int v11; // [rsp+28h] [rbp-238h]
  int v12; // [rsp+2Ch] [rbp-234h]
  const char *v13; // [rsp+48h] [rbp-218h]
  int v14[130]; // [rsp+50h] [rbp-210h] BYREF
  unsigned __int64 v15; // [rsp+258h] [rbp-8h]

  v15 = __readfsqword(0x28u);
  qmemcpy(v14, &unk_1740, 0x200uLL);
  v7 = 3;
  v6 = 0;
  v9 = 0;
  v10 = 0;
  v11 = strlen(a1);
  v13 = a1;
  while ( 1 )
  {
    v12 = 0;
    if ( v9 < v11 )
      break;
LABEL_7:
    if ( v9 >= v11 )
      goto LABEL_8;
  }
  do
  {
    if ( a1[v9] != 25 )
      break;
    ++v9;
    ++v12;
  }
  while ( v9 < v11 );
  if ( v9 != v11 )
  {
    ++v9;
    goto LABEL_7;
  }
LABEL_8:                                        // 主要代码
  v8 = 0;
  while ( v11 > 0 )
  {
    v7 -= v14[*v13] == '@';
    v6 = v14[*v13] & 0x3F | (v6 << 6);          // v6左移6位，低6位由v14[*v13]低6位替补
    if ( ++v8 == 4 )                            // 每进行完4次v6的位移操作就执行if语句
    {
      v8 = 0;
      if ( v7 )
      {
        v2 = v10++;
        *(_BYTE *)(v2 + a2) = BYTE2(v6);
      }
      if ( v7 > 1 )
      {
        v3 = v10++;
        *(_BYTE *)(v3 + a2) = BYTE1(v6);
      }
      if ( v7 > 2 )
      {
        v4 = v10++;
        *(_BYTE *)(v4 + a2) = v6;
      }
    }
    ++v13;
    --v11;
  }
  return __readfsqword(0x28u) ^ v15;
}

这里是真没看出来是什么，经过查阅wp，部分师傅是用爆破求出，有的则看出这是base64的解密过程，我通过把'sctf_9102'进行base64加密就是正确的input2。

对于爆破而言：v14每遍历4个就会进入if语句，if语句又是把v6按字节的形式分成3个放入a2中。所以通过正向爆破，把sctf_9102分成3个一组，变为16进制。代码参考re学习笔记（38）BUUCTF-re-[SCTF2019]babyre IDA无法F5|代码修复|花指令_Forgo7ten的博客-CSDN博客

#include <stdio.h>


unsigned int data[128] = {
    0x7F, 0x7F, 0x7F, 0x7F, 0x7F, 0x7F, 0x7F, 0x7F,
    0x7F, 0x7F, 0x7F, 0x7F, 0x7F, 0x7F, 0x7F, 0x7F,
    0x7F, 0x7F, 0x7F, 0x7F, 0x7F, 0x7F, 0x7F, 0x7F,
    0x7F, 0x7F, 0x7F, 0x7F, 0x7F, 0x7F, 0x7F, 0x7F,
    0x7F, 0x7F, 0x7F, 0x7F, 0x7F, 0x7F, 0x7F, 0x7F,
    0x7F, 0x7F, 0x7F, 0x3E, 0x7F, 0x7F, 0x7F, 0x3F,
    0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B,
    0x3C, 0x3D, 0x7F, 0x7F, 0x7F, 0x40, 0x7F, 0x7F,
    0x7F, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06,
    0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E,
    0x0F, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16,
    0x17, 0x18, 0x19, 0x7F, 0x7F, 0x7F, 0x7F, 0x7F,
    0x7F, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x20,
    0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,
    0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F, 0x30,
    0x31, 0x32, 0x33, 0x7F, 0x7F, 0x7F, 0x7F, 0x7F
};

int main()
{
    int shuju[3] = { 0x736374,0x665f39,0x313032 };
    int i0, i1, i2, i3, i4, i5;
    for (i0 = 0; i0 < 3; i0++)
    {
        for(i1=32;i1<128;i1++)
            for (i2 = 32; i2 < 128; i2++)
                for (i3 = 32; i3 < 128; i3++)
                    for (i4 = 32; i4 < 128; i4++)
                    {
                        i5 = (((((data[i1] << 6) | data[i2]) << 6) | data[i3]) << 6) | data[i4];
                        if (i5 == shuju[i0])
                            printf("第%d组：%c%c%c%c\n", i0+1,i1, i2, i3, i4);
                    }
    }
    return 0;
}

re学习笔记（38）BUUCTF-re-[SCTF2019]babyre IDA无法F5|代码修复|花指令_Forgo7ten的博客-CSDN博客得到输出第一组：c2N0 第二组 ZI85，第三组有3个，分别是MS=y，MT=y，MTAy。通过动态调试知道应该是MTAy，所以input2是 c2N0ZI85MTAy。

第三部分：看别的wp说可能类似SM4

让sub_FFA函数为0就行。跟进 sub_FFA：

__int64 __fastcall sub_FFA(char *a1)
{
  int v2; // [rsp+18h] [rbp-158h]
  int i; // [rsp+18h] [rbp-158h]
  int v4; // [rsp+1Ch] [rbp-154h]
  int v5; // [rsp+24h] [rbp-14Ch]
  int v6; // [rsp+28h] [rbp-148h]
  int v7; // [rsp+2Ch] [rbp-144h]
  int v8[16]; // [rsp+30h] [rbp-140h]
  int v9[16]; // [rsp+70h] [rbp-100h]
  int v10[26]; // [rsp+B0h] [rbp-C0h]
  unsigned int v11; // [rsp+118h] [rbp-58h] v10[26]
  unsigned int v12; // [rsp+11Ch] [rbp-54h] v10[27]
  unsigned int v13; // [rsp+120h] [rbp-50h] v10[28]
  unsigned int v14; // [rsp+124h] [rbp-4Ch] v10[29]
  unsigned __int64 v15; // [rsp+168h] [rbp-8h]

  v15 = __readfsqword(0x28u);
  v8[0] = 0xBE;
  v8[1] = 4;
  v8[2] = 6;
  v8[3] = 0x80;
  v8[4] = 0xC5;
  v8[5] = 0xAF;
  v8[6] = 0x76;
  v8[7] = 0x47;
  v8[8] = 0x9F;
  v8[9] = 0xCC;
  v8[10] = 0x40;
  v8[11] = 0x1F;
  v8[12] = 0xD8;
  v8[13] = 0xBF;
  v8[14] = 0x92;
  v8[15] = 0xEF;
  v5 = (a1[6] << 8) | (a1[5] << 16) | (a1[4] << 24) | a1[7];
  v6 = (a1[10] << 8) | (a1[9] << 16) | (a1[8] << 24) | a1[11];
  v7 = (a1[14] << 8) | (a1[13] << 16) | (a1[12] << 24) | a1[15];
  v4 = 0;
  v2 = 4;
  v10[0] = sub_78A((a1[2] << 8) | (a1[1] << 16) | (*a1 << 24) | (unsigned int)a1[3]);
  v10[1] = sub_78A(v5);
  v10[2] = sub_78A(v6);
  v10[3] = sub_78A(v7);
  do
  {
    v10[v2] = sub_143B(v10[v4], v10[v4 + 1], v10[v4 + 2], v10[v4 + 3]);
    ++v4;
    ++v2;
  }
  while ( v2 <= 29 );                           // v10共30个元素
  v9[0] = HIBYTE(v11);                          // v8[0] = 190;
  v9[1] = BYTE2(v11);                           // v8[1] = 4;
  v9[2] = BYTE1(v11);                           // v8[2] = 6;
  v9[3] = (unsigned __int8)v11;                 // v8[3] = 128;
  v9[4] = HIBYTE(v12);                          // v8[4] = 197;
  v9[5] = BYTE2(v12);                           // v8[5] = 175
  v9[6] = BYTE1(v12);                           // v8[6] = 118
  v9[7] = (unsigned __int8)v12;                 // v8[7] = 71;
  v9[8] = HIBYTE(v13);                          // v8[8] = 159;
  v9[9] = BYTE2(v13);                           // v8[9] = 204;
  v9[10] = BYTE1(v13);                          // v8[10] = 64;
  v9[11] = (unsigned __int8)v13;                // v8[11] = 31;
  v9[12] = HIBYTE(v14);                         // v8[11] = 31;
  v9[13] = BYTE2(v14);                          // v8[12] = 216;
  v9[14] = BYTE1(v14);                          // v8[13] = 191;
  v9[15] = (unsigned __int8)v14;                // v8[14] = 146;
  for ( i = 0; i <= 15; ++i )                   // v8[15] = 239;
  {
    if ( v9[i] != v8[i] )
      return 0xFFFFFFFFLL;
  }
  return 1LL;
}

我们可以看到，input3也就是a1进行了如下操作所以要知道input3，需要知道v10的前4个元素。看一看v10进行了什么操作。这个则是有v10[0],v10[1],v10[2],v10[3]求v10的其他元素。由while循环条件知道v10由30个元素。跟进sub_143B。是个异或操作，可逆向。在跟进sub_1464：

发现是个循环位移操作。那我们的已知条件是什么呢？我们发现后面有v11，v12，v13,v14。在根据这4个数据在堆栈中的位置，可以知道这四个就是v10[26],v10[27],v10[28],v10[29]，知道这些，又是异或操作那不就可以向前异或求出v10的前四个元素了嘛。又因为这几个元素是由input3依次组成的，所以就可求finput3，代码如下，参考re学习笔记（38）BUUCTF-re-[SCTF2019]babyre IDA无法F5|代码修复|花指令_Forgo7ten的博客-CSDN博客

#include <stdio.h>
#include "defs.h"
unsigned int data1[288] = {
    0xD6, 0x90, 0xE9, 0xFE, 0xCC, 0xE1, 0x3D, 0xB7,
    0x16, 0xB6, 0x14, 0xC2, 0x28, 0xFB, 0x2C, 0x05,
    0x2B, 0x67, 0x9A, 0x76, 0x2A, 0xBE, 0x04, 0xC3,
    0xAA, 0x44, 0x13, 0x26, 0x49, 0x86, 0x06, 0x99,
    0x9C, 0x42, 0x50, 0xF4, 0x91, 0xEF, 0x98, 0x7A,
    0x33, 0x54, 0x0B, 0x43, 0xED, 0xCF, 0xAC, 0x62,
    0xE4, 0xB3, 0x1C, 0xA9, 0xC9, 0x08, 0xE8, 0x95,
    0x80, 0xDF, 0x94, 0xFA, 0x75, 0x8F, 0x3F, 0xA6,
    0x47, 0x07, 0xA7, 0xFC, 0xF3, 0x73, 0x17, 0xBA,
    0x83, 0x59, 0x3C, 0x19, 0xE6, 0x85, 0x4F, 0xA8,
    0x68, 0x6B, 0x81, 0xB2, 0x71, 0x64, 0xDA, 0x8B,
    0xF8, 0xEB, 0x0F, 0x4B, 0x70, 0x56, 0x9D, 0x35,
    0x1E, 0x24, 0x0E, 0x5E, 0x63, 0x58, 0xD1, 0xA2,
    0x25, 0x22, 0x7C, 0x3B, 0x01, 0x21, 0x78, 0x87,
    0xD4, 0x00, 0x46, 0x57, 0x9F, 0xD3, 0x27, 0x52,
    0x4C, 0x36, 0x02, 0xE7, 0xA0, 0xC4, 0xC8, 0x9E,
    0xEA, 0xBF, 0x8A, 0xD2, 0x40, 0xC7, 0x38, 0xB5,
    0xA3, 0xF7, 0xF2, 0xCE, 0xF9, 0x61, 0x15, 0xA1,
    0xE0, 0xAE, 0x5D, 0xA4, 0x9B, 0x34, 0x1A, 0x55,
    0xAD, 0x93, 0x32, 0x30, 0xF5, 0x8C, 0xB1, 0xE3,
    0x1D, 0xF6, 0xE2, 0x2E, 0x82, 0x66, 0xCA, 0x60,
    0xC0, 0x29, 0x23, 0xAB, 0x0D, 0x53, 0x4E, 0x6F,
    0xD5, 0xDB, 0x37, 0x45, 0xDE, 0xFD, 0x8E, 0x2F,
    0x03, 0xFF, 0x6A, 0x72, 0x6D, 0x6C, 0x5B, 0x51,
    0x8D, 0x1B, 0xAF, 0x92, 0xBB, 0xDD, 0xBC, 0x7F,
    0x11, 0xD9, 0x5C, 0x41, 0x1F, 0x10, 0x5A, 0xD8,
    0x0A, 0xC1, 0x31, 0x88, 0xA5, 0xCD, 0x7B, 0xBD,
    0x2D, 0x74, 0xD0, 0x12, 0xB8, 0xE5, 0xB4, 0xB0,
    0x89, 0x69, 0x97, 0x4A, 0x0C, 0x96, 0x77, 0x7E,
    0x65, 0xB9, 0xF1, 0x09, 0xC5, 0x6E, 0xC6, 0x84,
    0x18, 0xF0, 0x7D, 0xEC, 0x3A, 0xDC, 0x4D, 0x20,
    0x79, 0xEE, 0x5F, 0x3E, 0xD7, 0xCB, 0x39, 0x48,
    0xC6, 0xBA, 0xB1, 0xA3, 0x50, 0x33, 0xAA, 0x56,
    0x97, 0x91, 0x7D, 0x67, 0xDC, 0x22, 0x70, 0xB2,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};

unsigned int fun(unsigned int a1)
{
        int v1;
        v1 = (data1[BYTE2(a1)] << 16) | data1[(unsigned __int8)a1] | (data1[BYTE1(a1)] << 8) | (data1[a1 >> 24] << 24);
        return __ROL4__(v1, 12) ^ (unsigned int)(__ROL4__(v1, 8) ^ __ROR4__(v1, 2)) ^ __ROR4__(v1, 6);
}

int main()
{
	unsigned int data[30] = { 0 };
    data[26] = 0xBE040680;
    data[27] = 0xC5AF7647;
    data[28] = 0x9FCC401F;
    data[29] = 0xD8BF92EF;
    int i;
	for (i = 25; i >=0; i--)
		data[i] = fun(data[i+1] ^ data[i+2] ^ data[i+3]) ^ data[i+4];
    printf("%x %x %x %x\n", data[0], data[1], data[2], data[3]);
    for (i = 0; i < 4; i++)
        printf("%c%c%c%c", ((char*)&data[i])[0], ((char*)&data[i])[1], ((char*)&data[i])[2], ((char*)&data[i])[3]);       //把int型数据看出单位为byte的数组
	return 0;
}

所以再根据flag输入格式：sctf{ddwwxxssxaxwwaasasyywwdd-c2N0Zl85MTAy(fl4g_is_s0_ug1y!)}

小贴士：1.因为上面代码中有BYTE0,BYTE2等等定义，这些定义是IDA中的宏，所以我们需要把IDA的plugins的defs.h移动到和你所写的脚本放到一个目录下，然后组成一个项目即可正确运行。

2.由于题目中所给的已知数据都是db类型，且有好几百个，不可能一个一个手动抄吧，所以用内置python，dump出来：

内怀童心外表成熟

关注

2
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
BUUCTF-[SCTF2019]babyre1

我们发现后面有v11，v12，v13,v14。在根据这4个数据在堆栈中的位置，可以知道这四个就是v10[26],v10[27],v10[28],v10[29]，知道这些，又是异或操作那不就可以向前异或求出v10的前四个元素了嘛。用户输入为v15，从操作可以看出w向上，s向下，a向左，d向右，x向下走一个迷宫大小，y向上走一个迷宫大小。这里是真没看出来是什么，经过查阅wp，部分师傅是用爆破求出，有的则看出这是base64的解密过程，我通过把'sctf_9102'进行base64加密就是正确的input2。
复制链接

扫一扫