buuctf re入门题目解析

目录

1.easyre

 2.reverse1

3.reverse2

4.内涵的软件

5.新年快乐

6.xor

7.helloword

8.reverse3

9.不一样的flag

10.SimpleRev

---

1.easyre

将exe文件放入ida，在主函数main中找到flag，此题结束

 2.reverse1

打开主函数main，发现有一个跳转函数，双击打开

 

这句命令是将str1和str2的内容比较，当两者相同时候输出 “this is the right flag ”

双击str2打开，可以看见str2的内容

提交flag后发现flag错误，重新审计代码

 发现上面藏有这样一条语句，由ascii码得知111为‘o’，48为‘0’

于是正确flag为

flag{hell0_w0rld}

 此题结束

3.reverse2

这道题与reverse1类似，还是先查看主函数

 在下面发现条件与reverse1一致，即都是当输入的值与flag相同时输出‘this is the right flag’

使用shift+F12查找字符串，发现一个疑似flag的字符串

 同样的，我们直接查看flag也能得到这串字符

 需要注意的是，上面的代码也有字符处理

 这里会将‘i’和‘r’替换为‘1’，所以整理后的flag为

flag{hack1ng_fo1_fun}

此题结束

4.内涵的软件

打开main函数，发现有一个mian0，进去之后就可以找到flag

 包上flag，此题结束

（我还以为是base加密过的。。）

5.新年快乐

首先打开exeinfo打开exe文件，查看详细信息，发现文件带壳

 （什么是壳）

 具体壳是什么可以看这个大佬的文章

压缩、加密壳初认识_lllle00的博客-CSDN博客

然后，我们需要使用工具upx来进行脱壳

 脱壳完成后，用ida打开文件，查找flag字符串

 转到 _main函数，审计代码后发现，当输入内容与str2相同时，输出"this is true flag!"

于是我们得到flag

flag{HappyNewYear!}

此题结束

6.xor

用exeinfo检查发现无壳

使用ida打开，查找字符串并审计代码

 这里看到输入的值进行异或计算后再与变量global进行了比较，于是我们反推global的值就能得到flag

（异或计算）

因为我们可以知道flag的开头一定是‘f’，于是我们将其与已经被异或计算后的第2位进行异或计算就能得到原来的值

y[异或计算后的第二位] = x[原有的第一位] ^ z[原有的第二位]

所以：

z[原有的第二位] = x[原有的第一位] ^ y[异或计算后的第二位]

以此类推便能还原原字符串

这里字符后面的h是16进制数的标志，于是我们对其进行整理，得到global的值

global['f','0xA','k',0xC,'w','&','O','.',@',0x11,'x',0xD,'Z',';','U',0x11,'p',0x19,'F',0x1F,'v','"','M','#','D',0xE,'g',6,'h',0xF,'G','2','O',0]

 我们写一个脚本对global进行反异或处理

key = [ 'f',0xA,'k',0xC,'w','&','O','.','@',0x11,'x',0xD,'Z',';','U',0x11,'p',0x19,'F',0x1F,'v','"','M','#','D',0xE,'g',6,'h',0xF,'G','2','O' ]
flag = "f"
x = 0
for i in range(0,len(key)-1):
    if isinstance(key[i],str):
        if isinstance(key[i+1],str):    x = ord(key[i]) ^ ord(key[i+1])     # key[i]，key[i+1]同时为字符串
        else:                           x = ord(key[i]) ^ key[i+1]          # key[i]为字符串，key[i+1]为整数
    else:
        if isinstance(key[i+1],str):    x = key[i] ^ ord(key[i+1])          # key[i]为整数，key[i+1]为字符串
        else:                           x = key[i] ^ key[i+1]               # key[i]，key[i+1]同时为整数
    flag = flag + chr(x)
print(flag)

得到结果

此题结束

7.helloword

这是一个安卓的反编译题目，我们需要使用到工具apkide

使用apkide打开文件后，找到主函数

 即可得到flag

此题结束

8.reverse3

使用exeinfo查看，32位无壳

 使用32位ida打开，shift+F12查看字符串，查找flag字符

进入主函数，审计代码，可以得到对输入的字符串进行sub_4110BE处理后进行了移位处理，与str2进行比较

 

 打开str2得到加密后的flag

打开sub函数查看加密过程

 int v4; // [esp+D4h] [ebp-38h]
  int v5; // [esp+D4h] [ebp-38h]
  int v6; // [esp+D4h] [ebp-38h]
  int v7; // [esp+D4h] [ebp-38h]
  int i; // [esp+E0h] [ebp-2Ch]
  unsigned int v9; // [esp+ECh] [ebp-20h]
  int v10; // [esp+ECh] [ebp-20h]
  int v11; // [esp+ECh] [ebp-20h]
  void *v12; // [esp+F8h] [ebp-14h]
  char *v13; // [esp+104h] [ebp-8h]

  if ( !a1 || !a2 )
    return 0;
  v9 = a2 / 3;
  if ( (int)(a2 / 3) % 3 )
    ++v9;
  v10 = 4 * v9;
  *a3 = v10;
  v12 = malloc(v10 + 1);
  if ( !v12 )
    return 0;
  j_memset(v12, 0, v10 + 1);
  v13 = a1;
  v11 = a2;
  v4 = 0;
  while ( v11 > 0 )
  {
    byte_41A144[2] = 0;
    byte_41A144[1] = 0;
    byte_41A144[0] = 0;
    for ( i = 0; i < 3 && v11 >= 1; ++i )
    {
      byte_41A144[i] = *v13;
      --v11;
      ++v13;
    }
    if ( !i )
      break;
    switch ( i )
    {
      case 1:
        *((_BYTE *)v12 + v4) = aAbcdefghijklmn[(int)(unsigned __int8)byte_41A144[0] >> 2];
        v5 = v4 + 1;
        *((_BYTE *)v12 + v5) = aAbcdefghijklmn[((byte_41A144[1] & 0xF0) >> 4) | (16 * (byte_41A144[0] & 3))];
        *((_BYTE *)v12 + ++v5) = aAbcdefghijklmn[64];
        *((_BYTE *)v12 + ++v5) = aAbcdefghijklmn[64];
        v4 = v5 + 1;
        break;
      case 2:
        *((_BYTE *)v12 + v4) = aAbcdefghijklmn[(int)(unsigned __int8)byte_41A144[0] >> 2];
        v6 = v4 + 1;
        *((_BYTE *)v12 + v6) = aAbcdefghijklmn[((byte_41A144[1] & 0xF0) >> 4) | (16 * (byte_41A144[0] & 3))];
        *((_BYTE *)v12 + ++v6) = aAbcdefghijklmn[((byte_41A144[2] & 0xC0) >> 6) | (4 * (byte_41A144[1] & 0xF))];
        *((_BYTE *)v12 + ++v6) = aAbcdefghijklmn[64];
        v4 = v6 + 1;
        break;
      case 3:
        *((_BYTE *)v12 + v4) = aAbcdefghijklmn[(int)(unsigned __int8)byte_41A144[0] >> 2];
        v7 = v4 + 1;
        *((_BYTE *)v12 + v7) = aAbcdefghijklmn[((byte_41A144[1] & 0xF0) >> 4) | (16 * (byte_41A144[0] & 3))];
        *((_BYTE *)v12 + ++v7) = aAbcdefghijklmn[((byte_41A144[2] & 0xC0) >> 6) | (4 * (byte_41A144[1] & 0xF))];
        *((_BYTE *)v12 + ++v7) = aAbcdefghijklmn[byte_41A144[2] & 0x3F];
        v4 = v7 + 1;
        break;
    }
  }
  *((_BYTE *)v12 + v4) = 0;
  return v12;

分析后发现这是一个base加密

 写一个脚本对其进行解密

import base64
key='e3nifIH9b_C@n@dH'
key=list(key)
for i in range(len(key)):
   key[i]=chr(ord(key[i])-i)
flag=''.join(key)
print(base64.b64decode(flag))

最后得到flag

此题结束

9.不一样的flag

exeinfo查看，32位无壳

32位ida打开，shift+F12查看字符串

 有一个与flag相关，打开字符串位置并反编译

  _BYTE v3[29]; // [esp+17h] [ebp-35h] BYREF
  int v4; // [esp+34h] [ebp-18h]
  int v5; // [esp+38h] [ebp-14h] BYREF
  int i; // [esp+3Ch] [ebp-10h]
  _BYTE v7[12]; // [esp+40h] [ebp-Ch] BYREF

  __main();
  v3[26] = 0;
  *(_WORD *)&v3[27] = 0;
  v4 = 0;
  strcpy(v3, "*11110100001010000101111#");
  while ( 1 )
  {
    puts("you can choose one action to execute");
    puts("1 up");
    puts("2 down");
    puts("3 left");
    printf("4 right\n:");
    scanf("%d", &v5);
    if ( v5 == 2 )
    {
      ++*(_DWORD *)&v3[25];
    }
    else if ( v5 > 2 )
    {
      if ( v5 == 3 )
      {
        --v4;
      }
      else
      {
        if ( v5 != 4 )
LABEL_13:
          exit(1);
        ++v4;
      }
    }
    else
    {
      if ( v5 != 1 )
        goto LABEL_13;
      --*(_DWORD *)&v3[25];
    }
    for ( i = 0; i <= 1; ++i )
    {
      if ( *(_DWORD *)&v3[4 * i + 25] >= 5u )
        exit(1);
    }
    if ( v7[5 * *(_DWORD *)&v3[25] - 41 + v4] == 49 )
      exit(1);
    if ( v7[5 * *(_DWORD *)&v3[25] - 41 + v4] == 35 )
    {
      puts("\nok, the order you enter is the flag!");
      exit(0);
    }
  }

发现有一串字符串‘*11110100001010000101111#’，还有下面的语句

当v7中的某个元素等于49时，程序停止；当这个元素等于35时，输出‘你输入的顺序就是flag’

结合ascii码，49为1，35为#，刚好与字符串相对应

再根据程序的输出内容，合理猜测这是一个迷宫

因为是25个字符，猜测是5x5迷宫，作出迷宫图

 简单处理得到顺序，即得到flag

flag{222441144222}

此题结束

10.SimpleRev

---

用exeinfo查壳，使用64位ida打开文件，找到main函数

 在主函数中有一个叫decry的函数，双击打开

unsigned __int64 Decry()
{
  char v1; // [rsp+Fh] [rbp-51h]
  int v2; // [rsp+10h] [rbp-50h]
  int v3; // [rsp+14h] [rbp-4Ch]
  int i; // [rsp+18h] [rbp-48h]
  int v5; // [rsp+1Ch] [rbp-44h]
  char src[8]; // [rsp+20h] [rbp-40h] BYREF
  __int64 v7; // [rsp+28h] [rbp-38h]
  int v8; // [rsp+30h] [rbp-30h]
  __int64 v9[2]; // [rsp+40h] [rbp-20h] BYREF
  int v10; // [rsp+50h] [rbp-10h]
  unsigned __int64 v11; // [rsp+58h] [rbp-8h]

  v11 = __readfsqword(0x28u);
  *(_QWORD *)src = 0x534C43444ELL;
  v7 = 0LL;
  v8 = 0;
  v9[0] = 0x776F646168LL;
  v9[1] = 0LL;
  v10 = 0;
  text = (char *)join(key3, v9);
  strcpy(key, key1);
  strcat(key, src);
  v2 = 0;
  v3 = 0;
  getchar();
  v5 = strlen(key);
  for ( i = 0; i < v5; ++i )
  {
    if ( key[v3 % v5] > 64 && key[v3 % v5] <= 90 )
      key[i] = key[v3 % v5] + 32;
    ++v3;
  }
  printf("Please input your flag:");
  while ( 1 )
  {
    v1 = getchar();
    if ( v1 == 10 )
      break;
    if ( v1 == 32 )
    {
      ++v2;
    }
    else
    {
      if ( v1 <= 96 || v1 > 122 )
      {
        if ( v1 > 64 && v1 <= 90 )
        {
          str2[v2] = (v1 - 39 - key[v3 % v5] + 97) % 26 + 97;
          ++v3;
        }
      }
      else
      {
        str2[v2] = (v1 - 39 - key[v3 % v5] + 97) % 26 + 97;
        ++v3;
      }
      if ( !(v3 % v5) )
        putchar(32);
      ++v2;
    }
  }
  if ( !strcmp(text, str2) )
    puts("Congratulation!\n");
  else
    puts("Try again!\n");
  return __readfsqword(0x28u) ^ v11;
}

 对代码进行分析

 注意有一个大小端储存的问题，要把src和v9两个变量进行倒转处理

 因为得知密文和加密方式，所以我们写一个脚本对密文进行还原

key='adsfkndcls'
text='killshadow'
d = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
for i in range(0,10):
    for j in d:
        if (ord(j)-39-ord(key[i % 10])+97)%26+97 == ord(text[i]):
            print(j,end='')

最后得到flag，此题结束