reverse复现之攻防世界新手区

[toc]

菜鸡最近开始学二进制了，先做几道简单的逆向题练练手(12道)

0x01 simple-unpack

看看有没有壳

image-20210108223404332

有壳，还提示我去用 upx -d 命令来脱壳

那我就恭敬不如从命

image-20210108223456948

然后再用ida打开看看

Shift + F12

image-20210108223602154

不要太简单

0x02 insanity

32位的，拖入IDA，Shift + F12

看到flag

0x03 python-trade

一个pyc文件

反编译了

image-20210108225147600

看看

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import base64

def encode(message):
    s = ''
    for i in message:
        x = ord(i) ^ 32
        x = x + 16
        s += chr(x)

    return base64.b64encode(s)


correct = 'XlNkVmtUI1MgXWBZXCFeKY+AaXNt'
flag = ''
print 'Input flag:'
flag = raw_input()
if encode(flag) == correct:
    print 'correct'
else:
    print 'wrong'

猜测这个correct 与 flag有关，要让encode(flag) == correct

分析一波

image-20210108232651938

在python3 和 python2 中，base64.b64decode返回的东西是不一样的，python2 ，返回的是str，而python3 返回的是bytes，一般为了操作上的方便，用python2会比较好

image-20210108232535640

写脚本，用python2执行，得到flag

1
2
3
4
5
6
7
8
9
10
11
12
13
import base64
def decode(c):
    s = ""
    c = base64.b64decode(c)
    print(type(c))
    for i in c:
        a = ord(i)
        a = a - 16
        a = a ^ 32
        s += chr(a)
    return s

decode('XlNkVmtUI1MgXWBZXCFeKY+AaXNt')

0x04 re1

image-20210108232909648

PE看一看，32位的程序，vsc++写的，没有壳

跑跑看

image-20210108233116816

IDA看看

读读程序（逆向分析）

image-20210108234538077

从终端输入v9

和 v5比较，目的是打印aFlag

看到会打印 aFlag ，推测存在程序里面

直接notepad++打开，关键字搜索

image-20210108235526990

找到flag

0x05 game

image-20210109000232500

32位的，没有壳

IDA看看

1
sub_45A7BE

这个函数是打印用的

找到可能打印flag的地方

image-20210114160545303

这里有打印东西的函数

image-20210114160614798

说明这个 v3所代表的字符串就会是我们的 flag

分析一下，v1到v59，和v60到v116这些变量是连着的，即应该用一个两个数组分开装

如果直接复制下来当做C直接跑，那么变量定义的时候就不会有这样连着的结构

image-20210114165040790

本来是v5的位置，装着v58

写个 python脚本

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
v60 = 18 
v61 = 64 
v62 = 98 
v63 = 5 
v64 = 2 
v65 = 4 
v66 = 6 
v67 = 3 
v68 = 6 
v69 = 48 
v70 = 49 
v71 = 65 
v72 = 32 
v73 = 12 
v74 = 48 
v75 = 65 
v76 = 31 
v77 = 78 
v78 = 62 
v79 = 32 
v80 = 49 
v81 = 32 
v82 = 1 
v83 = 57 
v84 = 96 
v85 = 3 
v86 = 21 
v87 = 9 
v88 = 4 
v89 = 62 
v90 = 3 
v91 = 5 
v92 = 4 
v93 = 1 
v94 = 2 
v95 = 3 
v96 = 44 
v97 = 65 
v98 = 78 
v99 = 32 
v100 = 16 
v101 = 97 
v102 = 54 
v103 = 16 
v104 = 44 
v105 = 52 
v106 = 32 
v107 = 64 
v108 = 89 
v109 = 45 
v110 = 32 
v111 = 65 
v112 = 15 
v113 = 34 
v114 = 18 
v115 = 16 
v116 = 0 
v3 = 123 
v4 = 32 
v5 = 18 
v6 = 98 
v7 = 119 
v8 = 108 
v9 = 65 
v10 = 41 
v11 = 124 
v12 = 80 
v13 = 125 
v14 = 38 
v15 = 124 
v16 = 111 
v17 = 74 
v18 = 49 
v19 = 83 
v20 = 108 
v21 = 94 
v22 = 108 
v23 = 84 
v24 = 6 
v25 = 96 
v26 = 83 
v27 = 44 
v28 = 121 
v29 = 104 
v30 = 110 
v31 = 32 
v32 = 95 
v33 = 117 
v34 = 101 
v35 = 99 
v36 = 123 
v37 = 127 
v38 = 119 
v39 = 96 
v40 = 48 
v41 = 107 
v42 = 71 
v43 = 92 
v44 = 29 
v45 = 81 
v46 = 107 
v47 = 90 
v48 = 85 
v49 = 64 
v50 = 12 
v51 = 43 
v52 = 76 
v53 = 86 
v54 = 13 
v55 = 114 
v56 = 1 
v57 = 117 
v58 = 126 
v59 = 0 
for i in range(56):
    locals()["v"+str(3 + i)] ^= locals()["v"+str(60 + i)]
    locals()["v"+str(3 + i)] ^= 0x13 
    print(chr(locals()["v"+str(3 + i)]),end="")

print("hello")

image-20210114171141654 
1
zsctf{T9is_tOpic_1s_v5ry_int7resting_b6t_others_are_n0t}

0x06 getit

image-20210114171412002

  • elf文件格式

  • 64bit

IDA打开看看

image-20210114174546968

像极了flag，点开看看

image-20210114174626868

有一个全局变量t，t的内容为

1
0x53+harifCTF{????????????????????????????????}+0x00

看看t在哪里

image-20210114174905052

分析一下

1
2
3
4
5
6
7
8
9
while ( (signed int)v5 < strlen(s) )
  {
    if ( v5 & 1 )
      v3 = 1;
    else
      v3 = -1;
    *(&t + (signed int)v5 + 10) = s[(signed int)v5] + v3;
    LODWORD(v5) = v5 + 1;
  }

这部分代码对t做了操作，估计操作完了t，t里面的值就是flag了

所以可以运行，然后操作完后看看t，也可以复制下来稍微改一改，然后把t跑出来

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include<stdio.h>
int main(int argc, char const *argv[])
{
    char v3;
    int v5;
    char t[] = "SharifCTF{????????????????????????????????}";
    char s[] = "c61b68366edeb7bdce3c6820314b7498";
    v5 = 0;
    while ( v5 < 32 )
    {
        if ( v5 & 1 )
        v3 = 1;
        else
        v3 = -1;

        *(t + v5 + 10) = s[(signed int)v5] + v3;
        v5 = v5 + 1;
    }
    printf("hello : %s\n",t);
    return 0;
}
image-20210114182653821 
1
SharifCTF{b70c59275fcfa8aebf2d5911223c6589}

0x07 Hello,CTF

image-20210114182930474
  • PE
  • 32bit
  • 没有壳
image-20210114183056163

跑一跑

用IDA打开，先看看String，没有flag，但是看到个success，猜测和flag有关

image-20210114183252904

定位一下看看

image-20210114183403848 image-20210114183420863

找到了对应的函数

分析一下

重要的代码，是一个while循环

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
strcpy(&v13, "437261636b4d654a757374466f7246756e");
while ( 1 )
{
  memset(&v10, 0, 0x20u);
  v11 = 0;
  v12 = 0;
  sub_40134B(aPleaseInputYou, v6);
  scanf(aS, v9);
  if ( strlen(v9) > 0x11 )
    break;
  v3 = 0;
  do
  {
    v4 = v9[v3];
    if ( !v4 )
      break;
    sprintf(&v8, asc_408044, v4);
    strcat(&v10, &v8);
    ++v3;
  }
  while ( v3 < 17 );
  if ( !strcmp(&v10, &v13) )
    sub_40134B(aSuccess, v7);
  else
    sub_40134B(aWrong, v7);
}
image-20210114185534729

要让v10和v13两个字符串相等，才能报成功

v13是这样的

1
v13="437261636b4d654a757374466f7246756e"

一共34位

v10最开始的时候是个32byte的空字符串，经过一个do-while循环的处理后才去和v13作比较

do-while循环

1
2
3
4
5
6
7
8
9
10
11
v3 = 0;
   do
   {
     v4 = v9[v3];
     if ( !v4 )
       break;
     sprintf(&v8, asc_408044, v4);
     strcat(&v10, &v8);
     ++v3;
   }
   while ( v3 < 17 );

v9是我们输入的东西

image-20210114185731712 
1
asc_408044 = "%x"

一共进行17回操作，每次取v9的一个字符，作为一个8bit的数字，转成一个十六进制数字，接入v10后面，而一个byte最多对应一个两位的十六进制数

v13有34位，刚好对应17个两位的十六进制数

写个脚本，进行转换

1
2
3
4
5
6
7
v13="437261636b4d654a757374466f7246756e"
r = ""
for i in range(17):
    s = v13[2*i:2*i+2]
    s = chr(int(s,16))
    r += s
r
image-20210114213813815 
1
CrackMeJustForFun

这个就是flag

0x08 open-source

是个c文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
#include <stdio.h>
#include <string.h>

int main(int argc, char *argv[]) {
    if (argc != 4) {
    	printf("what?\n");
    	exit(1);
    }

    unsigned int first = atoi(argv[1]);
    if (first != 0xcafe) {
    	printf("you are wrong, sorry.\n");
    	exit(2);
    }

    unsigned int second = atoi(argv[2]);
    if (second % 5 == 3 || second % 17 != 8) {
    	printf("ha, you won't get it!\n");
    	exit(3);
    }

    if (strcmp("h4cky0u", argv[3])) {
    	printf("so close, dude!\n");
    	exit(4);
    }

    printf("Brr wrrr grr\n");

    unsigned int hash = first * 31337 + (second % 17) * 11 + strlen(argv[3]) - 1615810207;

    printf("Get your key: ");
    printf("%x\n", hash);
    return 0;
}
image-20210114223116010 image-20210114223201111

flag 就是 c0ffee

0x09 logmein

基本信息

image-20210114223347082
  • elf
  • 64bit
  • 没有壳

跑一跑看

image-20210114223547117

猜测，输入的guess就是flag

IDA看一下

找成功标志

image-20210114223727163

找到对应的位置

image-20210114223815169

看看哪个函数调用了这个函数

先看看main

image-20210114224220820

分析一下

改写一下重要的代码

1
2
3
4
5
6
7
8
9
10
11
12
13
void a()
{
  strcpy(v8, ":\"AL_RT^L*.?+6/46");
  v7 = 28537194573619560LL;
  v6 = 7;
  __isoc99_scanf("%32s", s);//len(s)>=17
  for ( i = 0; i < strlen(s); ++i )
  {
    if ( s[i] != (char)(*((_BYTE *)&v7 + i % v6) ^ v8[i]) )
      fail();
  }
  succeed();
}

v8的长度是17，输入的s 长度要大于等于17，而i的取值为[0,len(s)]，有一个v8[i]要取，所以len(s)<=17，因此，len(s)==17

v7是一个64bit，即8个byte的数据，v7的每个byte轮流和v8的各个字符进行 ^ 操作，最后得到数字化成char，连起来就是s应有的样子

看看v7各个byte

image-20210114230914729 
1
v7 = [0x65,0x62,0x6d,0x61,0x72,0x61,0x68]

写c程序跑出来flag

1
2
3
4
5
6
7
8
9
10
11
12
13
14
void decode(){
  char v8[20] = ":\"AL_RT^L*.?+6/46";
  long long v7 = 28537194573619560;
  char s[20] = {};
  for(int i = 0; i < 17; i++){
    s[i] = (char)(*((char*)&v7 + i % 7) ^ v8[i]);
  }
  printf("%s",s);
}
int main(int argc, char const *argv[])
{
    decode();
    return 0;
}
image-20210114232134871 
1
RC3-2016-XORISGUD

0x0a no-strings-attached

基本信息

image-20210115110405143
  • elf
  • 32bit
  • 没有壳

IDA打开看看

image-20210115110912605

没什么特殊的string

看看main函数

image-20210115151931993

setlocale调用了一个链接来的函数，一般和flag无关

banner，打印了一些字符，也没什么用

prompt_authentication 也是打印了一些字符，也没用

所以说，如果在这个程序里面有flag的踪迹，那必然是在 authenticate 中

image-20210115160218566

如果ws，即输入的东西，和s2相等，就打印一个东西

image-20210115160308344

不出所料，是 Success

所以思路就很明显了，就构造个东西，让它和s2相等就好

去看看s2是什么

s2 是 decrypt函数返回的东西，看看decrypt

image-20210115160606659

最后返回了个dest，那只要在运行的时候截住dest就可以了

用gdb打开

先看看所有函数

1
info functions
image-20210115163042700

我要的是 decrypt

把 decrypt 给反汇编了，看看

1
disassemble decrypt
image-20210115163157497

在ret的地方设个断点

image-20210115163310786

然后跑

1
r
image-20210115163337572

这时候dest的值肯定是在某个寄存器里面，看看寄存器

1
info r
image-20210115163454656

一般放在eax、ebx、ecx、edx中的一个里面

回去看看汇编，猜测很可能在eax里面，而且就内容的大小而言，eax的大小最大

看看eax里面的内容

因为dest是一个 wchar_t* ，wchar_t 是一个4byte的数据，所以其对应的字符串，应该是每4个byte为一个单位，每个单位作为一个字符

1
x/sw $eax
image-20210115164339106

得到flag

1
9447{you_are_an_international_mystery}

0x0b csaw2013reversing2

基本信息

image-20210115165002691
  • PE
  • 32bit
  • 没有壳

跑跑看

image-20210115165206486

没什么，不知道这段东西是不是flag

IDA看看

image-20210115165507817

点进去看看

是main函数

image-20210115170546444

跟heap有关的都没法看到源码，猜测跟flag有关的函数肯定是 sub_401000

而且只有debug的时候会调用，而一旦debug，就最终会breakdebug

分析一下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
unsigned int __fastcall sub_401000(int a1, int a2)
{
  int v2; // esi
  unsigned int v3; // eax
  unsigned int v4; // ecx
  unsigned int result; // eax

  v2 = dword_409B38;
  v3 = a2 + 1 + strlen((const char *)(a2 + 1)) + 1;
  v4 = 0;
  result = ((v3 - (a2 + 2)) >> 2) + 1;
  if ( result )
  {
    do
      *(_DWORD *)(a2 + 4 * v4++) ^= v2;
    while ( v4 < result );
  }
  return result;
}
image-20210115171659131

a2 就是 lpMem，也就是heap的地址

在 sub_401000这个函数中，a2被操作了好多次，也就是在heap上操作了好多次，可以猜测，操作完后，heap上的值就与flag有关

只要把__debugbreak() 给无效化，调试的时候看看堆的值就能看到flag了

看看函数的 graph view

image-20210115213920819 
1
int 3

正是停止debug的指令，那只要把这个指令改成 nop，然后再把 后面 jmp指令跳转到的 函数也改一下，就万事大吉了

image-20210115214420041

把 int 3 改成了 nop

loc_4010B9 正是显示heap的内容的函数，即不在debug模式下跳转到的地方

那么修改 jmp后的标号，跳转到这里

改完后的代码

image-20210115214818429 image-20210115214832160

修改完了，打个补丁

image-20210115215046453

然后在debug模式下运行一下就好

image-20210115215235814

跑出flag来

1
flag{reversing_is_not_that_hard!}

0x0c maze

看看基本信息

image-20210115215701998
  • elf
  • 64bit
  • 没壳

跑跑看

image-20210115220522054

要输入flag，看起来挺简单

IDA打开看看

image-20210115220711472

这些string，有点意思

跳转到main函数

改成好看一点的

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
__int64 __fastcall main(__int64 a1, char **a2, char **a3)
{
  const char *v3; // rsi
  signed __int64 v4; // rbx
  signed int v5; // eax
  char v6; // bp
  char v7; // al
  const char *v8; // rdi
  __int64 v10; // [rsp+0h] [rbp-28h]
  v10 = 0LL;
  char s1[24] = "nctf{xxxxxxxxxxx}";
  //len(s1)==24;s1={nctf***********}
  v4 = 5LL;
  while ( 1 )
  {
    v5 = s1[v4];
    v6 = 0;
    if ( v5 > 78 )
    {
      if (v5 == 79 )
      {
        v7 = sub_400650((char *)&v10 + 4, v3);
      }
      if ( v5 == 111 )
      {
        v7 = sub_400660((char *)&v10 + 4, v3);
      }
    }
    else
    {
      if (v5 == 46 )
      {
        v7 = sub_400670(&v10, v3);
      }
      if ( v5 == 48 )
      {
        v7 = sub_400680(&v10, v3);
      }
    }
    v6 = v7;
    v3 = (const char *)HIDWORD(v10);
    if ( !(unsigned __int8)sub_400690(asc_601060, HIDWORD(v10), (unsigned int)v10) ) 
      fail();
    if ( ++v4 >= strlen(&s1) - 1 )
    {
      if ( v6 )
        break;
      else 
        fail();
    }
  }
  if ( asc_601060[8 * (signed int)v10 + SHIDWORD(v10)] != 35 )
    fail();
  succeed();
  return 0LL;
}

最后 v6 = v7，而v6不能等于0，所以v7肯定经过了处理，所以s1[5] 的值就是 46/79/111/48 中的一个，而s1[5]不仅决定了v7还决定了v10

这个while循环会一直进行，遍历{}中的每一个字符，而每一个字符的取值都只有4个可以选 46/79/111/48 ，否则v7就为0，导致v6就为0，然后就会提前break，

image-20210115225936798

这里因为不知名的原因 v7变为v6，v10变为v9，v5变为v4

每次操作完还有个条件要满足

image-20210115232635638 
1
asc_601060 = '  *******   *  **** * ****  * ***  *#  *** *** ***     *********'

有64位

a2 为 v9的高位，a3为v9的低位，a1为 asc_601060 的起始地址

最后还有个条件

而asc_601060[8 * (signed int)v10 + SHIDWORD(v10)]要等于35，也就是 #，而ord(' ') = 32

所以 

1
8 * (signed int)v10 + SHIDWORD(v10) = 35

79(O)OPQ

v9高位–要大于0

111(o)opq

v9高位++要小于8

46(.)

v9低位–要大于0

48(0)012

v9低位++要小于8

题目里说到走迷宫，v10的位置也总是在变，会不会64位的asc_601060就是个迷宫，而#就是迷宫的出口，每次操作后v10的值要不然是 ‘ ‘ 要不然是 ‘#’，说明’ ‘ 是通道，而* 就自然是障碍物了

用gdb看看

image-20210116004351312

还真像那么一回事

那么乘了8的变量也就是a3，对应的就是上下移动，而另外一个变量a2就是左右移动

a3对应低位，也就对应 . 和 0，其中，. 是往上，0 是往下

a2对应高位，也就对应 O 和 o，其中，O 是往左，o 是往右

要走到 0x23的地方，只能途经0x20

image-20210116011758755 
1
→↓→→↓↓←↓↓↓→→→→↑↑←←
image-20210116011900627 
1
2
3
4
5
6
7
# -*- coding: UTF-8 -*-
s = "→↓→→↓↓←↓↓↓→→→→↑↑←←"
m = {'→':'o','↓':'0','↑':'.','←':'O'}
r = ''
for c in s:
    r += m[c]
print("nctf{"+r+"}")

得到flag

1
nctf{o0oo00O000oooo..OO}
Next