攻防世界 reverse 第二周


阅读数: 次   
字数统计: 3.8k字   |   阅读时长: 19分

re1
game
Hello, CTF
simple-unpack
no-strings-attached

@TOC

re1

题目描述：菜鸡开始学习逆向工程，首先是最简单的题目

思路

拖入ida，转伪代码

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
int __cdecl main(int argc, const char **argv, const char **envp)
{
  int v3; // eax
  __int128 v5; // [esp+0h] [ebp-44h]
  __int64 v6; // [esp+10h] [ebp-34h]
  int v7; // [esp+18h] [ebp-2Ch]
  __int16 v8; // [esp+1Ch] [ebp-28h]
  char v9; // [esp+20h] [ebp-24h]

  _mm_storeu_si128((__m128i *)&v5, _mm_loadu_si128((const __m128i *)&xmmword_413E34));
  v7 = 0;                                     //7. _mm_storeu_si128函数点不开。。但v5一定与xmmword_413E34有关
  v6 = qword_413E44;
  v8 = 0;
  printf("欢迎来到DUTCTF呦\n");
  printf("这是一道很可爱很简单的逆向题呦\n");
  printf("输入flag吧:");
  scanf("%s", &v9);
  v3 = strcmp((const char *)&v5, &v9);        //5.strcmp函数，两字符串相等返回0，大于返回正数，小于返回负数
  if ( v3 )                                   //6.v9为自己输入的字符串，所以flag==v5
    v3 = -(v3 < 0) | 1;                       //4.'|'运算符是有一个为1，值为1.所以不能进入这个if语句,还是说明v3==0
  if ( v3 )
    printf(aFlag_0);                          //1.看到flag，点进去，发现'flag不太对呦'，
  else                                        //2.但往上看unk_413E90 发现了flag get，正好和else里面的符合       
    printf((const char *)&unk_413E90);        //3.说明v3==0
  system("pause");
  return 0;
}

点开xmmword_413E34后发现是一串数字，R转成字符发现是
在这里插入图片描述

还是因为小端存储问题，db占一字节，正好是字符，所以只要倒过来就行了
或者还可以快捷键A直接转成
在这里插入图片描述
还可以找到相应地址后在16进制视图中快捷键G找到正确顺序的flag

game

题目描述：菜鸡最近迷上了玩游戏，但它总是赢不了，你可以帮他获胜吗

思路

附件是一个应用程序exe
这个题可以根据提示做对游戏得到flag（然额我就没点开，无脑拖入ida）
结果main函数有好几个，一开始点进了没flag的main函数里一直跳转，心态炸裂。找到main_0()

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
void main_0()
{
  signed int i; // [esp+DCh] [ebp-20h]
  int v1; // [esp+F4h] [ebp-8h]

  sub_45A7BE(&unk_50B110);
  sub_45A7BE(&unk_50B158);
  sub_45A7BE(&unk_50B1A0);
  sub_45A7BE(&unk_50B1E8);
  sub_45A7BE(&unk_50B230);
  sub_45A7BE(&unk_50B278);
  sub_45A7BE(&unk_50B2C0);
  sub_45A7BE(&unk_50B308);
  sub_45A7BE("二                                                     |\n");
  sub_45A7BE("|              by 0x61                                 |\n");
  sub_45A7BE("|                                                      |\n");
  sub_45A7BE("|------------------------------------------------------|\n");
  sub_45A7BE(
    "Play a game\n"
    "The n is the serial number of the lamp,and m is the state of the lamp\n"
    "If m of the Nth lamp is 1,it's on ,if not it's off\n"     //2.灯亮为1
    "At first all the lights were closed\n");
  sub_45A7BE("Now you can input n to change its state\n");
  sub_45A7BE(
    "But you should pay attention to one thing,if you change the state of the Nth lamp,the state of (N-1)th and (N+1)th w"
    "ill be changed too\n");
  sub_45A7BE("When all lamps are on,flag will appear\n");      //1.当所有灯亮的时候flag出现
  sub_45A7BE("Now,input n \n");
  while ( 1 )
  {
    while ( 1 )
    {
      sub_45A7BE("input n,n(1-8)\n");
      sub_459418();
      sub_45A7BE("n=");
      sub_4596D4("%d", &v1);
      sub_45A7BE("\n");
      if ( v1 >= 0 && v1 <= 8 )
        break;
      sub_45A7BE("sorry,n error,try again\n");
    }
    if ( v1 )
    {
      sub_4576D6(v1 - 1);
    }
    else
    {
      for ( i = 0; i < 8; ++i )
      {
        if ( (unsigned int)i >= 9 )
          j____report_rangecheckfailure();
        byte_532E28[i] = 0;
      }
    }
    j__system("CLS");
    sub_458054();
    if ( byte_532E28[0] == 1                       //3.判断如果八盏灯都为1，进入sub_457AB4()，点开sub_457AB4()。
      && byte_532E28[1] == 1
      && byte_532E28[2] == 1
      && byte_532E28[3] == 1
      && byte_532E28[4] == 1
      && byte_532E28[5] == 1
      && byte_532E28[6] == 1
      && byte_532E28[7] == 1 )
    {
      sub_457AB4();
    }
  }
}

发现 done!!! the flag is ，定义了好多个字符最后有一个

1
2
3
4
5
6
for ( i = 0; i < 56; ++i )
{
  *(&v2 + i) ^= *(&v59 + i);
  *(&v2 + i) ^= 0x13u;
}
return sub_45A7BE("%s\n");

那么for循环之后应该就是flag
然后我一开始懒省事复制粘贴

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
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
#include<iostream>
using namespace std;
int main()
{
  signed int i; // [esp+D0h] [ebp-94h]
  char v2; // [esp+DCh] [ebp-88h]
  char v3; // [esp+DDh] [ebp-87h]
  char v4; // [esp+DEh] [ebp-86h]
  char v5; // [esp+DFh] [ebp-85h]
  char v6; // [esp+E0h] [ebp-84h]
  char v7; // [esp+E1h] [ebp-83h]
  char v8; // [esp+E2h] [ebp-82h]
  char v9; // [esp+E3h] [ebp-81h]
  char v10; // [esp+E4h] [ebp-80h]
  char v11; // [esp+E5h] [ebp-7Fh]
  char v12; // [esp+E6h] [ebp-7Eh]
  char v13; // [esp+E7h] [ebp-7Dh]
  char v14; // [esp+E8h] [ebp-7Ch]
  char v15; // [esp+E9h] [ebp-7Bh]
  char v16; // [esp+EAh] [ebp-7Ah]
  char v17; // [esp+EBh] [ebp-79h]
  char v18; // [esp+ECh] [ebp-78h]
  char v19; // [esp+EDh] [ebp-77h]
  char v20; // [esp+EEh] [ebp-76h]
  char v21; // [esp+EFh] [ebp-75h]
  char v22; // [esp+F0h] [ebp-74h]
  char v23; // [esp+F1h] [ebp-73h]
  char v24; // [esp+F2h] [ebp-72h]
  char v25; // [esp+F3h] [ebp-71h]
  char v26; // [esp+F4h] [ebp-70h]
  char v27; // [esp+F5h] [ebp-6Fh]
  char v28; // [esp+F6h] [ebp-6Eh]
  char v29; // [esp+F7h] [ebp-6Dh]
  char v30; // [esp+F8h] [ebp-6Ch]
  char v31; // [esp+F9h] [ebp-6Bh]
  char v32; // [esp+FAh] [ebp-6Ah]
  char v33; // [esp+FBh] [ebp-69h]
  char v34; // [esp+FCh] [ebp-68h]
  char v35; // [esp+FDh] [ebp-67h]
  char v36; // [esp+FEh] [ebp-66h]
  char v37; // [esp+FFh] [ebp-65h]
  char v38; // [esp+100h] [ebp-64h]
  char v39; // [esp+101h] [ebp-63h]
  char v40; // [esp+102h] [ebp-62h]
  char v41; // [esp+103h] [ebp-61h]
  char v42; // [esp+104h] [ebp-60h]
  char v43; // [esp+105h] [ebp-5Fh]
  char v44; // [esp+106h] [ebp-5Eh]
  char v45; // [esp+107h] [ebp-5Dh]
  char v46; // [esp+108h] [ebp-5Ch]
  char v47; // [esp+109h] [ebp-5Bh]
  char v48; // [esp+10Ah] [ebp-5Ah]
  char v49; // [esp+10Bh] [ebp-59h]
  char v50; // [esp+10Ch] [ebp-58h]
  char v51; // [esp+10Dh] [ebp-57h]
  char v52; // [esp+10Eh] [ebp-56h]
  char v53; // [esp+10Fh] [ebp-55h]
  char v54; // [esp+110h] [ebp-54h]
  char v55; // [esp+111h] [ebp-53h]
  char v56; // [esp+112h] [ebp-52h]
  char v57; // [esp+113h] [ebp-51h]
  char v58; // [esp+114h] [ebp-50h]
  char v59; // [esp+120h] [ebp-44h]
  char v60; // [esp+121h] [ebp-43h]
  char v61; // [esp+122h] [ebp-42h]
  char v62; // [esp+123h] [ebp-41h]
  char v63; // [esp+124h] [ebp-40h]
  char v64; // [esp+125h] [ebp-3Fh]
  char v65; // [esp+126h] [ebp-3Eh]
  char v66; // [esp+127h] [ebp-3Dh]
  char v67; // [esp+128h] [ebp-3Ch]
  char v68; // [esp+129h] [ebp-3Bh]
  char v69; // [esp+12Ah] [ebp-3Ah]
  char v70; // [esp+12Bh] [ebp-39h]
  char v71; // [esp+12Ch] [ebp-38h]
  char v72; // [esp+12Dh] [ebp-37h]
  char v73; // [esp+12Eh] [ebp-36h]
  char v74; // [esp+12Fh] [ebp-35h]
  char v75; // [esp+130h] [ebp-34h]
  char v76; // [esp+131h] [ebp-33h]
  char v77; // [esp+132h] [ebp-32h]
  char v78; // [esp+133h] [ebp-31h]
  char v79; // [esp+134h] [ebp-30h]
  char v80; // [esp+135h] [ebp-2Fh]
  char v81; // [esp+136h] [ebp-2Eh]
  char v82; // [esp+137h] [ebp-2Dh]
  char v83; // [esp+138h] [ebp-2Ch]
  char v84; // [esp+139h] [ebp-2Bh]
  char v85; // [esp+13Ah] [ebp-2Ah]
  char v86; // [esp+13Bh] [ebp-29h]
  char v87; // [esp+13Ch] [ebp-28h]
  char v88; // [esp+13Dh] [ebp-27h]
  char v89; // [esp+13Eh] [ebp-26h]
  char v90; // [esp+13Fh] [ebp-25h]
  char v91; // [esp+140h] [ebp-24h]
  char v92; // [esp+141h] [ebp-23h]
  char v93; // [esp+142h] [ebp-22h]
  char v94; // [esp+143h] [ebp-21h]
  char v95; // [esp+144h] [ebp-20h]
  char v96; // [esp+145h] [ebp-1Fh]
  char v97; // [esp+146h] [ebp-1Eh]
  char v98; // [esp+147h] [ebp-1Dh]
  char v99; // [esp+148h] [ebp-1Ch]
  char v100; // [esp+149h] [ebp-1Bh]
  char v101; // [esp+14Ah] [ebp-1Ah]
  char v102; // [esp+14Bh] [ebp-19h]
  char v103; // [esp+14Ch] [ebp-18h]
  char v104; // [esp+14Dh] [ebp-17h]
  char v105; // [esp+14Eh] [ebp-16h]
  char v106; // [esp+14Fh] [ebp-15h]
  char v107; // [esp+150h] [ebp-14h]
  char v108; // [esp+151h] [ebp-13h]
  char v109; // [esp+152h] [ebp-12h]
  char v110; // [esp+153h] [ebp-11h]
  char v111; // [esp+154h] [ebp-10h]
  char v112; // [esp+155h] [ebp-Fh]
  char v113; // [esp+156h] [ebp-Eh]
  char v114; // [esp+157h] [ebp-Dh]
  char v115; // [esp+158h] [ebp-Ch]

  //sub_45A7BE("done!!! the flag is ");
  v59 = 18;
  v60 = 64;
  v61 = 98;
  v62 = 5;
  v63 = 2;
  v64 = 4;
  v65 = 6;
  v66 = 3;
  v67 = 6;
  v68 = 48;
  v69 = 49;
  v70 = 65;
  v71 = 32;
  v72 = 12;
  v73 = 48;
  v74 = 65;
  v75 = 31;
  v76 = 78;
  v77 = 62;
  v78 = 32;
  v79 = 49;
  v80 = 32;
  v81 = 1;
  v82 = 57;
  v83 = 96;
  v84 = 3;
  v85 = 21;
  v86 = 9;
  v87 = 4;
  v88 = 62;
  v89 = 3;
  v90 = 5;
  v91 = 4;
  v92 = 1;
  v93 = 2;
  v94 = 3;
  v95 = 44;
  v96 = 65;
  v97 = 78;
  v98 = 32;
  v99 = 16;
  v100 = 97;
  v101 = 54;
  v102 = 16;
  v103 = 44;
  v104 = 52;
  v105 = 32;
  v106 = 64;
  v107 = 89;
  v108 = 45;
  v109 = 32;
  v110 = 65;
  v111 = 15;
  v112 = 34;
  v113 = 18;
  v114 = 16;
  v115 = 0;
  v2 = 123;
  v3 = 32;
  v4 = 18;
  v5 = 98;
  v6 = 119;
  v7 = 108;
  v8 = 65;
  v9 = 41;
  v10 = 124;
  v11 = 80;
  v12 = 125;
  v13 = 38;
  v14 = 124;
  v15 = 111;
  v16 = 74;
  v17 = 49;
  v18 = 83;
  v19 = 108;
  v20 = 94;
  v21 = 108;
  v22 = 84;
  v23 = 6;
  v24 = 96;
  v25 = 83;
  v26 = 44;
  v27 = 121;
  v28 = 104;
  v29 = 110;
  v30 = 32;
  v31 = 95;
  v32 = 117;
  v33 = 101;
  v34 = 99;
  v35 = 123;
  v36 = 127;
  v37 = 119;
  v38 = 96;
  v39 = 48;
  v40 = 107;
  v41 = 71;
  v42 = 92;
  v43 = 29;
  v44 = 81;
  v45 = 107;
  v46 = 90;
  v47 = 85;
  v48 = 64;
  v49 = 12;
  v50 = 43;
  v51 = 76;
  v52 = 86;
  v53 = 13;
  v54 = 114;
  v55 = 1;
  v56 = 117;
  v57 = 126;
  v58 = 0;
  for ( i = 0; i < 56; ++i )
  {
    *(&v2 + i) ^= *(&v59 + i);
    *(&v2 + i) ^= 0x13u;
    cout<<*(&v2 + i);
  }

  return 0;
}

结果运行出来全是乱码，后来想想发现可能是*(&v2 + i)的问题，由于v2，v3等等是分别定义的而非定义为一个数组，所以v2，v3地址可能不是连续的。最后造成乱码（不确定）

但这样的话，定义成数组数字难到一个一个输吗？或者写个别的程序得到数字？

后来看题解找到有人说地址是递减的，要把for循环里的（地址+i）都改成（地址-i）但是这样解出来还是乱码，不知道为什么。。

从题解中找到的第二种方法
直接patch改程序（原来ida有这种操作），
1.把得到flag的条件改为灯全灭，在exe中随便打开一个灯再关掉就得到了flag
把jnz改为jz
jnz结果不为零（或不相等）则转移。
jz即零标志为1就跳转
在这里插入图片描述
2.或者在前面某个地方直接加一个call sub_45A7BE，运行程序得到flag（感觉自己可以破解游戏了hhh）在这里插入图片描述
3.好像还加一个 （jmp xxx地址） 也可以，但后面的地址不能用45A7BE，好像得用od找，目前还不会。

Hello, CTF

题目描述：菜鸡发现Flag似乎并不一定是明文比较的

思路

转伪代码

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
int __cdecl main(int argc, const char **argv, const char **envp)
{
  signed int v3; // ebx
  char v4; // al
  int result; // eax
  int v6; // [esp+0h] [ebp-70h]
  int v7; // [esp+0h] [ebp-70h]
  char v8; // [esp+12h] [ebp-5Eh]
  char v9[20]; // [esp+14h] [ebp-5Ch]
  char v10; // [esp+28h] [ebp-48h]
  __int16 v11; // [esp+48h] [ebp-28h]
  char v12; // [esp+4Ah] [ebp-26h]
  char v13; // [esp+4Ch] [ebp-24h]

  strcpy(&v13, "437261636b4d654a757374466f7246756e");
  while ( 1 )
  {
    memset(&v10, 0, 0x20u);
    v11 = 0;
    v12 = 0;
    sub_40134B((int)aPleaseInputYou, v6);
    scanf(aS, v9);                          //6.v9是自己输入的字符
    if ( strlen(v9) > 0x11 )
      break;
    v3 = 0;
    do
    {
      v4 = v9[v3];                          //5.v4是v9的单个字符，所以找到v9即可
      if ( !v4 )
        break;
      sprintf(&v8, asc_408044, v4);         //4.v8和v4有关
      strcat(&v10, &v8);                    //3.strcat函数是将v8(字符)拼接到v10(字符串)后面
      ++v3;
    }
    while ( v3 < 17 );
    if ( !strcmp(&v10, &v13) )              //2.如果v10==v13，进入，往上看v13==437261636b4d654a757374466f7246756e
      sub_40134B((int)aSuccess, v7);        //1.看到success，即满足上面的if，就得到了flag
    else
      sub_40134B((int)aWrong, v7);
  }
  sub_40134B((int)aWrong, v7);
  result = stru_408090._cnt-- - 1;
  if ( stru_408090._cnt < 0 )
    return _filbuf(&stru_408090);
  ++stru_408090._ptr;
  return result;
}

综上，只要自己输入的字符与v13相等，就是flag，将v13转为字符串，得到flag
学题解上的脚本

1
2
3
4
5
6
7
8
#!/usr/bin/env python3
s='437261636b4d654a757374466f7246756e'
t=''
i=0
while(i<len(s)):
    t+=chr(int(s[i:i+2],16))     //切片
    i+=2
print(t)

还可以在16进制视图里直接输入437261636b4d654a757374466f7246756e，得到flag

simple-unpack

题目描述：菜鸡拿到了一个被加壳的二进制文件

思路

之前虽然知道做题前要先查壳，但一直没用到过，前面的题也不需要查壳脱壳。这道题算是初步了解了查壳脱壳。
壳：负责保护软件不被非法修改或反编译的程序。分为压缩壳和加密壳。
查壳的方法：
1.windows：用exeinfope，将文件拖入查壳。（peid好像是没人维护数据库了，所以查不出来）
在这里插入图片描述
2.kali虚拟机中
file 文件名
checksec 文件名
也可以
在这里插入图片描述
脱壳方法：
看脱壳信息中或packer中 是upx壳，一种压缩壳。
可以从脱壳信息中的upx官网中下载upx（不同的壳好像需要不同的软件）
在这里插入图片描述
脱壳后拖入ida64，
进入main函数直接找到flag
在这里插入图片描述

no-strings-attached

题目描述：菜鸡听说有的程序运行就能拿Flag？

思路

从这个题了解了动态调试gdb的基础用法
b 设断点
r 运行
n 单步步过

1.查壳
在这里插入图片描述
32位程序，无壳，不可执行
2.拖入ida，找main函数生成伪代码
从下往上点进去函数
先进去authenticate()
在这里插入图片描述
stdin，输入字符串，
下面还有printf，打印，
点进去printf里面的东西，if里面的出现的是success，else里面是access denied，所以说明只要满足if，ws==s2，就success了，ws是自己输入的，所以s2即为flag
在这里插入图片描述
进入decrypt
在这里插入图片描述
3.两种方法
（1）模拟decrypt，
从题解中找到了之前的疑惑，ida中可以直接写python脚本，导出数据，不用一个一个打字
在这里插入图片描述
addr为起始的地址，range可以用（结束地址-起始地址）/想要得到数据类型的字节数（Dword是4字节，后面的addr每次加4） 来计算
函数 .append(xxx)是在末尾加上xxx
运行之后在输出窗口中显示。
找到dword_8048A90和s
在这里插入图片描述

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#!/usr/bin/env python3
a2=[5121, 5122, 5123, 5124, 5125]
dest=[5178, 5174, 5175, 5179, 5248, 5242, 5233, 5240, 5219, 5222,
      5235, 5223, 5218, 5221, 5235, 5216, 5227, 5233, 5240,
      5226, 5235, 5232, 5220, 5240, 5230, 5232, 5232, 5220, 5232, 
      5220, 5230, 5243, 5238, 5240, 5226, 5235, 5243, 5248]
i=j=0
while i< len(dest):
    j=0
    while j< len(a2) and i< len(dest):
        dest[i]-=a2[j]
        j+=1
        i+=1
s=''
for i in range(0, len(dest)):
    s+=chr(dest[i])
print(s)

在这里插入图片描述
这个是看题解后写的
其实一开始就想用分析程序模拟做的，但进入decrypt之后找不到v4的值，所以没法写，不知道题解中怎么知道v4就等于0的

(2)gdb动态调试
因为文件时32位linux程序
将文件拖入kali虚拟机中
使用gdb
设断点 b decrypt
在这里插入图片描述
运行到decrypt，单步步过，光标在s2处看到下面的地址为8048725
在这里插入图片描述
在ida中找到该地址，发现调用decrypt后，把eax赋值给ebp+s2，说明eax存储了decrypt的返回值
在这里插入图片描述
x表示查看寄存器内容，s是字符串表示，w是四字节（题解中也有用x/200wx $eax的，但之后还要16进制转字符串）

在这里插入图片描述



-------------本文结束感谢您的阅读-------------



赏

谢谢你请我吃糖果

扫一扫，分享到微信

微信分享二维码
本站总访问量次 本站访客数人次

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

朱登榜，来自河南郑州，河南大学学生，倘若文章有错误，望提醒修正，感谢！<br>qq:879322660<br>微信:z15981855791