maze迷宫MD5

前言：该篇文章会介绍一个在ctf当中reverse方向中常见的一种迷宫题，我从攻防世界中选取了一道比较有代表性的题目，逐一讲解，并且每个思路都相当清晰透彻，借此分享，相信看完之后对于迷宫类型的题目会有更深的理解。

例题1：攻防世界-reverse_re3

第一步

首先看有无壳，直接丢到exeinfope—发现是elf文件是linux的可执行程序

1717234589796-a7e22b5b-307e-4b76-8a29-87319e857a1b.png

第二步

反手丢进ida看到main 直接F5反编译看一手

1717234604020-6b0ec156-23fb-43fd-a782-8ade83694c45.png

第三步

一个一个函数来，sub_11B4双击点开好像没啥东西，看看sub_940

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
__int64 sub_940()
{
  int v0; // eax
  int v2; // [rsp+8h] [rbp-218h]
  int v3; // [rsp+Ch] [rbp-214h]
  char v4[520]; // [rsp+10h] [rbp-210h] BYREF
  unsigned __int64 v5; // [rsp+218h] [rbp-8h]

  v5 = __readfsqword(0x28u);
  v3 = 0;
  memset(v4, 0, 0x200uLL);
  _isoc99_scanf(&unk_1278, v4, v4);
  while ( 1 )
  {
    do
    {
      v2 = 0;
      sub_86C();
      v0 = v4[v3];
      if ( v0 == 'd' )               //原题是ascii码可以对着ascii按"r"快捷键转成字符
      {
        v2 = sub_E23();
      }
      else if ( v0 > 'd' )          //wasd很明显就是游戏里常见的移动键呗
      {
        if ( v0 == 's' )
        {
          v2 = sub_C5A();
        }
        else if ( v0 == 'w' )
        {
          v2 = sub_A92();
        }
      }
      else
      {
        if ( v0 == 27 )
          return 0xFFFFFFFFLL;
        if ( v0 == 'a' )
          v2 = sub_FEC();
      }
      ++v3;
    }
    while ( v2 != 1 );
    if ( dword_202AB0 == 2 )
      break;
    ++dword_202AB0;
  }
  puts("success! the flag is flag{md5(your input)}");
  return 1LL;
}

这里留个心眼，flag是要输入的md5值

接下来分析wasd到底是怎么走的（像这种题大概率就是迷宫图，所以要明白它是怎么运动的）

先打开sub_E23康康

1717234684753-fa345f3c-fcd8-4cf2-a622-cf4e4773d23e.png

第四步

千万不要给这几个变量绕晕了

dword_202020：其实就是题目给的地图，可以双击进去看看（shift+e 提取数据）

dword_202AB0：代表哪个迷宫，此题有3个迷宫（至于为什么后文会提及）

dword_202AB4：代表行（因为15*，说明可能是一行15个数字，大胆猜测！）

dword_202AB8：代表列

225：地图尺寸15*15

这里我转换了一下不容易混淆

1717234697051-8cfd01d3-dad0-4095-9bea-505930fca360.png

第五步

第一个if！=14 是因为跟下标有关系，一行15个数字下标最大是14，我们这个函数是”d“的操作也就是向右移，所以是如果下标等于14的话就不能再”d“了
第二个if 判断当前位置右移的数字是不是1，如果是将该位置标志为3，之前的位置标志为1，其实就是暗示我们1是可以走的，而3其实是我们的起点，如果不理解后面看看迷宫就明白了，
第三个if如果右移后是4就返回1，说明4就是我们的终点

再看看上下移动的函数（下图是”s“的函数，也就是下移）——有一些题目上下移动不是单纯的往上或者往下 而是斜向下或者斜向上噢

1717234791049-81359f85-da1d-49cc-82c9-71c6c429ac94.png

第六步

每次加15说明每次加一行

注意：这里分析的是右移”d“和下移”s“的函数至于”w“ ”a“都是差不多的，这里就不过多赘述了

再回到sub_940函数

1717234822384-19edaf01-78e6-48f6-b162-16c4d2c4e14a.png

第七步

这里的dword_202AB0==2 我们在前面提到它可能是标识哪一个迷宫的，这里说==2的话就break，否则就++，说明这里会循环3次，说明会有3个迷宫，接下来我们来看看这个稍微的迷宫长什么样。

双击点开前文提到的dword_202020

第八步

这密密麻麻的数字就是它的数据啦，现在按shift+e提取数据，然后导出来

1717234857731-0367cdf8-5cb7-470d-9b2b-5c37400107d3.png
这里有个大大大坑，就是dword类型的数据是4位一组，只取第一位作为数值，也就是说100010000111 最终会变成110 ，后3位是填充的，接下来就是怎么转换成一个迷宫了，网上一堆wp却几乎没有人提到如何去把这份原始数据转换成迷宫，下面我提供了一个python脚本针对这道题目，只要运行即可得到迷宫的样子，

1717234880358-f64c4fdd-828a-4744-afa3-70004e33c2d4.png
一开始数据是这样的，先利用记事本的功能替换掉 ，和空格 以及前面的括号等等

1717234923253-2411cdf6-26ea-44fa-9a59-8bdf81c838cf.png
之后利用一下py脚本即可完成转换

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# 输入需要处理的字符串  
input_string = input("请输入需要处理的字符串：")  

# 将所有字符连起来，去掉换行符  
output_string = input_string.replace("\n", "")  
ZeK1D = output_string.replace(" ", "")    

def extract_chars(input_string):  
    # 将输入字符串分割为每四位  
    chunks = [input_string[i:i+4] for i in range(0, len(input_string), 4)]  

    # 提取每四位中的第一位字符  
    first_chars = [chunk[0] for chunk in chunks if chunk]  

    # 将字符连在一起并输出  
    output= ''.join(first_chars)  
    print(output)  


# 调用函数并输出结果  
extract_chars(ZeK1D)

之后可以将输出结果复制到word 改格式会好看一点

1717234935670-ff0486b9-6c59-471a-88ef-dc0b0655cf92.png

第九步

之后再按每15行为一个迷宫分成3个小迷宫，以3为起点4为终点进行运动，之后再md5加密即可得到flag

第一个迷宫

[1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

[1, 1, 1, 1, 1, 0, 3, 1, 1, 0, 0, 0, 0, 0, 0]

[1, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0]

[1, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0]

[1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0]

[1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0]

[1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0]

[1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0]

[1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0]

[1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0]

[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]

[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]

[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]

[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]

[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]

第二个迷宫

[1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

[1, 1, 0, 3, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0]

[1, 1, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0]

[1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0]

[1, 1, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0]

[1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0]

[1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0]

[1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0]

[1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0]

[1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0]

[1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0]

[1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0]

[1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0]

[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]

[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]

第三个迷宫

[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

[0, 3, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

[0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0]

[0, 0, 0, 1, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0]

[0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0]

[0, 1, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0]

[0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0]

[0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0]

[0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0]

[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0]

[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0]

[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0]

[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0]

[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0]

[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0]

行动轨迹为：ddsssddddsssdssdddddsssddddsssaassssdddsddssddwddssssssdddssssdddss

经过md5编码后flag是flag{aeea66fcac7fa80ed8f79f38ad5bb953}

总结：

逆向遇到迷宫题的思路大概分2点

1.弄清楚移动的方式

2.分析迷宫图的尺寸

3.手动走迷宫或写脚本走迷宫（建议BFS算法）

例题2

查壳，放ida

1721287542512-fd0e9f66-ad89-4f99-aa08-b3c5fc41d933.png

注意flag是md5（留个心眼），然后去动态调试找flag，这个createmap非常显眼

1721287626134-4c1d02ad-2ed0-48f3-a698-f92236473e44.png

先下个断点，然后开始调试

1721287763212-b4cc0f54-cc4e-41f7-8325-4895a9b743ac.png

任意输入一些，然后去search map

这里的快捷键有ctrl+T，查找下一个text

1721287799865-9ae1bc66-51e5-4083-a47e-0da39777b1ed.png

1721287879466-867a862b-99c2-4249-a32e-c3440b3ba5c8.png

找到后shift+E提取数据，然后放入我们的脚本文件

1721287938904-da7cd899-3e25-4630-8538-420efe1ccc9f.png1721287963254-d35f1b10-f2d0-4c09-b86f-a9bed5885a19.png

修改脚本中行列参数，运行脚本得到16*16的二维列表

将二维列表复制到【二.（一）】中的<脚本二：获得迷宫路径>中

1721288121231-bcb51aa9-1ef6-4e1c-801f-00a311c1fe8b.png

分析check()函数得到起点坐标为(15, 1)，且本题未给出确切终点而是在main函数中给出了路径长为54

并且用aswd键位移动

1721288538242-b466a9b5-a88a-4108-a8be-e59dfb79cd2d.png

1721288574799-f3796f86-3941-4f3e-933b-fa988c94cb86.png

这里附上最终代码

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
from collections import deque
# str为ida中使用快捷键[shift+e]提取到的数据, 如果提取的是string literal则加上引号视作字符串，如果是C array(decimal)则加上中括号视作列表
str = [

    1,   1,   1,   1,   1,   1,   1,   1,   1,   1,
    1,   1,   1,   1,   1,   1,   1,   0,   0,   0,
    0,   0,   1,   1,   1,   1,   1,   1,   0,   1,
    1,   1,   1,   0,   1,   1,   1,   0,   1,   1,
    1,   1,   1,   1,   0,   1,   1,   1,   1,   0,
    1,   1,   1,   0,   1,   1,   0,   0,   0,   1,
    0,   1,   1,   1,   1,   0,   1,   1,   1,   0,
    1,   1,   0,   1,   0,   1,   0,   1,   1,   1,
    1,   0,   1,   1,   1,   0,   0,   0,   0,   1,
    0,   1,   0,   1,   1,   1,   1,   0,   1,   1,
    1,   1,   1,   1,   0,   1,   0,   1,   0,   1,
    1,   1,   1,   0,   1,   1,   1,   1,   1,   1,
    0,   0,   0,   1,   0,   1,   1,   1,   1,   0,
    1,   1,   1,   1,   1,   1,   1,   0,   1,   1,
    0,   1,   1,   1,   1,   0,   1,   1,   1,   1,
    1,   1,   1,   0,   1,   1,   0,   1,   1,   1,
    1,   0,   0,   0,   0,   1,   1,   0,   0,   0,
    0,   1,   0,   0,   0,   1,   1,   1,   1,   1,
    0,   1,   1,   1,   1,   0,   1,   1,   0,   1,
    0,   1,   1,   1,   1,   1,   0,   1,   1,   1,
    1,   0,   1,   1,   0,   1,   0,   1,   1,   0,
    0,   0,   0,   1,   1,   1,   1,   0,   1,   1,
    0,   1,   0,   0,   1,   0,   1,   1,   1,   1,
    1,   1,   1,   0,   0,   0,   0,   1,   1,   1,
    1,   0,   1,   1,   1,   1,   1,   1,   1,   1,
    1,   1,   1,   1,   1,   1
]
s = 0  # s用作索引访问str, 供下面tmp列表取值

# 分析题目后设置迷宫的行列
row = 16 # 设置二维迷宫行数 input（）
col = 16 # 设置二维迷宫列数 input（）

maze = []
for i in range(row):
    tmp = []
    for j in range(col):
        tmp.append(str[s])
        s += 1
    maze.append(tmp)  # 凑一行添加一行到迷宫中
print(maze)
# 设置二维四向迷宫, 如果题目是多个小迷宫问题, 拆分多次调用脚本获取路径即可
path_len = 54+1  # 如果题目未给出终点坐标，则一定会指定路径的长度，在此处修改路径长度并+1，
#否则请保留path_len的极大值 0x7fffffff


# 进行BFS寻找路径
def bfs(start, end, barrier):
    directions = [(0, 1), (1, 0), (0, -1), (-1, 0)]  # 定义四个方向的移动
    for i in range(len(maze)):  # 获取起点和终点在列表中的索引
        for j in range(len(maze[i])):
            if (maze[i][j] == start):
                start = (i, j)
            if (maze[i][j] == end):
                end = (i, j)
    # 以下均是bfs算法套路
    queue = deque()
    queue.append((start, [start]))  # (当前位置, 路径)
    visited = set()
    visited.add(start)
    while queue:
        position, path = queue.popleft()
        if position == end:
            return path
        elif len(path) == path_len:
            return path
        for d in directions:
            next_position = (position[0] + d[0], position[1] + d[1])
            if 0 <= next_position[0] < len(maze) and 0 <= next_position[1] < len(maze[0]) and \
                    maze[next_position[0]][next_position[1]] != barrier and next_position not in visited:
                queue.append((next_position, path + [next_position]))
                visited.add(next_position)
    return None


# 执行BFS搜索并打印结果
if __name__ == '__main__':
    # maze[起点x坐标][起点y坐标] = 'S' 
    #如果题目给了起点终点的坐标，
    #在这里直接给起点和终点添加特征
    # maze[终点x坐标][终点y坐标] = 'E'
    maze[15][1]='S'
    path = bfs('S', 'E', 1)  # bfs函数传入参数代表起点、终点、障碍的特征(若题目给出的数据无特征, 手动添加特征即可, 通常障碍是1也有可能是0或其它字符如'#')
    print("移动路径坐标：", path)
    print("移动路径方位：", end='')
    for i in range(1, len(path)):
        x1, y1, x2, y2 = path[i - 1][0], path[i - 1][1], path[i][0], path[i][1]
        if (x1 > x2):  # 上
            print("w", end='')
        elif (x1 < x2):  # 下
            print("s", end='')
        elif (y1 > y2):  # 左
            print("a", end='')
        elif (y1 < y2):  # 右
            print("d", end='')

exp

1）

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
# str为ida中使用快捷键[shift+e]提取到的数据, 如果提取的是string literal则加上引号视作字符串，如果是C array(decimal)则加上中括号视作列表
str = [

    1,   1,   1,   1,   1,   1,   1,   1,   1,   1,
    1,   1,   1,   1,   1,   1,   1,   0,   0,   0,
    0,   0,   1,   1,   1,   1,   1,   1,   0,   1,
    1,   1,   1,   0,   1,   1,   1,   0,   1,   1,
    1,   1,   1,   1,   0,   1,   1,   1,   1,   0,
    1,   1,   1,   0,   1,   1,   0,   0,   0,   1,
    0,   1,   1,   1,   1,   0,   1,   1,   1,   0,
    1,   1,   0,   1,   0,   1,   0,   1,   1,   1,
    1,   0,   1,   1,   1,   0,   0,   0,   0,   1,
    0,   1,   0,   1,   1,   1,   1,   0,   1,   1,
    1,   1,   1,   1,   0,   1,   0,   1,   0,   1,
    1,   1,   1,   0,   1,   1,   1,   1,   1,   1,
    0,   0,   0,   1,   0,   1,   1,   1,   1,   0,
    1,   1,   1,   1,   1,   1,   1,   0,   1,   1,
    0,   1,   1,   1,   1,   0,   1,   1,   1,   1,
    1,   1,   1,   0,   1,   1,   0,   1,   1,   1,
    1,   0,   0,   0,   0,   1,   1,   0,   0,   0,
    0,   1,   0,   0,   0,   1,   1,   1,   1,   1,
    0,   1,   1,   1,   1,   0,   1,   1,   0,   1,
    0,   1,   1,   1,   1,   1,   0,   1,   1,   1,
    1,   0,   1,   1,   0,   1,   0,   1,   1,   0,
    0,   0,   0,   1,   1,   1,   1,   0,   1,   1,
    0,   1,   0,   0,   1,   0,   1,   1,   1,   1,
    1,   1,   1,   0,   0,   0,   0,   1,   1,   1,
    1,   0,   1,   1,   1,   1,   1,   1,   1,   1,
    1,   1,   1,   1,   1,   1
]#待输入的迷宫数组
s = 0  # s用作索引访问str, 供下面tmp列表取值

# 分析题目后设置迷宫的行列
row = 16 # 设置二维迷宫行数
col = 16 # 设置二维迷宫列数

maze = []
for i in range(row):
    tmp = []
    for j in range(col):
        tmp.append(str[s])
        s += 1
    maze.append(tmp)  # 凑一行添加一行到迷宫中
print(maze)

2）

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
from collections import deque

# 设置二维四向迷宫, 如果题目是多个小迷宫问题, 拆分多次调用脚本获取路径即可
maze = [] #二维列表迷宫，直接输入脚本1的二维数组
path_len = 0x7fffffff  # 如果题目未给出终点坐标，则一定会指定路径的长度，在此处修改路径长度，否则请保留path_len的极大值


# 进行BFS寻找路径
def bfs(start, end, barrier):
    directions = [(0, 1), (1, 0), (0, -1), (-1, 0)]  # 定义四个方向的移动
    for i in range(len(maze)):  # 获取起点和终点在列表中的索引
        for j in range(len(maze[i])):
            if (maze[i][j] == start):
                start = (i, j)
            if (maze[i][j] == end):
                end = (i, j)
    # 以下均是bfs算法套路
    queue = deque()
    queue.append((start, [start]))  # (当前位置, 路径)
    visited = set()
    visited.add(start)
    while queue:
        position, path = queue.popleft()
        if position == end:
            return path
        elif len(path) == path_len:
            return path
        for d in directions:
            next_position = (position[0] + d[0], position[1] + d[1])
            if 0 <= next_position[0] < len(maze) and 0 <= next_position[1] < len(maze[0]) and \
            maze[next_position[0]][next_position[1]] != barrier and next_position not in visited:
                queue.append((next_position, path + [next_position]))
                visited.add(next_position)
    return None


# 执行BFS搜索并打印结果
if __name__ == '__main__':
    # maze[起点x坐标][起点y坐标] = 'S' 
    #如果题目给了起点终点的坐标，在这里直接给起点和终点添加特征
    # maze[终点x坐标][终点y坐标] = 'E'
    
    path = bfs('S', 'E', 1)  # bfs函数传入参数代表起点、终点、障碍的特征(若题目给出的数据无特征, 手动添加特征即可, 通常障碍是1也有可能是0或其它字符如'#')
    print("移动路径坐标：", path)
    print("移动路径方位：", end='')
    for i in range(1, len(path)):
        x1, y1, x2, y2 = path[i - 1][0], path[i - 1][1], path[i][0], path[i][1]
        if (x1 > x2):  # 上
            print("w", end='')
        elif (x1 < x2):  # 下
            print("s", end='')
        elif (y1 > y2):  # 左
            print("a", end='')
        elif (y1 < y2):  # 右
            print("d", end='')

wsad可以根据题目要求更改键位

3）

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
maze = [
 [
  1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
 [
  1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1],
 [
  1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1],
 [
  1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1],
 [
  1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1],
 [
  1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1],
 [
  1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1],
 [
  1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1],
 [
  1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1],
 [
  1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1],
 [
  1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1],
 [
  1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1],
 [
  1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1],
 [
  1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1],
 [
  1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1],
 [
  1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1],
 [
  1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1],
 [
  1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1],
 [
  1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1],
 [
  1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1],
 [
  1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1],
 [
  1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1],
 [
  1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1],
 [
  1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1],
 [
  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1]]
usedmap=[[0 for i in range(len(maze))]for i in range(len(maze[0]))]
sti=0
stj=1
edi=24
edj=23
flag=''
def dfs(x,y):
    global flag
    if x==edi and y==edj:
        print(flag)
        return
    if maze[x+1][y]==0 and usedmap[x+1][y]==0:
        usedmap[x][y]=1
        flag+='s'
        dfs(x+1,y)
        flag=flag[:-1]
        usedmap[x][y]=0
    if maze[x-1][y]==0 and usedmap[x-1][y]==0:
        usedmap[x][y]=1
        flag+='w'
        dfs(x-1,y)
        flag=flag[:-1]
        usedmap[x][y]=0
    if maze[x][y+1]==0 and usedmap[x][y+1]==0:
        usedmap[x][y]=1
        flag+='d'
        dfs(x,y+1)
        flag=flag[:-1]
        usedmap[x][y]=0
    if maze[x][y-1]==0 and usedmap[x][y-1]==0:
        usedmap[x][y]=1
        flag+='a'
        dfs(x,y-1)
        flag=flag[:-1]
        usedmap[x][y]=0
dfs(sti,stj)
'''
for i in range(len(maze)):
    for j in range(len(maze[0])):
        print(maze[i][j],end='')
    print()
'''

例题3 doublegame

1722242072121-514173b5-a127-4f85-91fa-52129b918f90.png

运行

1722242096451-7bae7aa6-269c-4701-859a-9bf8c435ee54.png

ctrl F搜索gameover出现的地方，然后x查找调用函数

1722242173880-9f1c79a7-1f70-4f35-8706-f6d4ee27499f.png

（key非预期）发现有个可疑的数据，是key=13371337

1722242151448-a1d6ea37-e848-4e45-8a93-21014039a4b5.png

key正常

1722245506015-581550ac-dbac-4933-8619-58cde96fbd6d.png

发现key ^0x1DC4=13376013

1722245419058-b0588599-cd50-4ceb-b3b0-2a097b6faff0.png

静态分析发现，sub_14001136B函数是第二关，将去第二关路上的 if的字节码全部修改为相反的， 然后patch，重新调试 （记得备份）

或者找到迷宫，

1722243985629-a34c7275-0cfd-4e95-9704-018fccdc19d7.png

先拿出迷宫

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
maze=''' strcpy(Buffer, "000000000000000000000");
  strcpy(v4, "0 0 0 0     0     0 0");
  strcpy(&v4[22], "0 0 0 00000 00000 0 0");
  strcpy(v5, "0 0               0 0");
  strcpy(&v5[22], "0 000 000 0 000 0 0 0");
  strcpy(v6, "0 0     0 0 0   0 0 0");
  strcpy(&v6[22], "0 0 0 00000 000 000 0");
  strcpy(v7, "0 0 0     0   0 0    ");
  strcpy(&v7[22], "0 000 0 0 000 0 0 0 0");
  strcpy(v8, "0     0 0 0 0 0 0 0 0");
  strcpy(&v8[22], "0 00000 000 000 0 0 0");
  strcpy(v9, "0     0       0   0 0");
  strcpy(&v9[22], "000 0 0 0 000 0 0 0 0");
  strcpy(v10, "0 0 0 0 0 0 * 0 0 0 0");
  strcpy(&v10[22], "0 0000000 0 000 00000");
  strcpy(v11, "@   0   0 0         0");
  strcpy(&v11[22], "0 0 0 0 0 00000000000");
  strcpy(v12, "0 0 0 0             0");
  strcpy(&v12[22], "000 0 00000 0 000 000");
  strcpy(v13, "0         0 0   0   0");
  strcpy(&v13[22], "000000000000000000000");'''
maze=[(i[-24:-3]) for i in maze.split('\n')]
for i in maze:
    print(i)

1722244218163-08dabf4d-3780-49fb-93dc-32b77155a0fd.png

然后运行脚本

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
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
maze=''' strcpy(Buffer, "000000000000000000000");
  strcpy(v4, "0 0 0 0     0     0 0");
  strcpy(&v4[22], "0 0 0 00000 00000 0 0");
  strcpy(v5, "0 0               0 0");
  strcpy(&v5[22], "0 000 000 0 000 0 0 0");
  strcpy(v6, "0 0     0 0 0   0 0 0");
  strcpy(&v6[22], "0 0 0 00000 000 000 0");
  strcpy(v7, "0 0 0     0   0 0    ");
  strcpy(&v7[22], "0 000 0 0 000 0 0 0 0");
  strcpy(v8, "0     0 0 0 0 0 0 0 0");
  strcpy(&v8[22], "0 00000 000 000 0 0 0");
  strcpy(v9, "0     0       0   0 0");
  strcpy(&v9[22], "000 0 0 0 000 0 0 0 0");
  strcpy(v10, "0 0 0 0 0 0 * 0 0 0 0");
  strcpy(&v10[22], "0 0000000 0 000 00000");
  strcpy(v11, "@   0   0 0         0");
  strcpy(&v11[22], "0 0 0 0 0 00000000000");
  strcpy(v12, "0 0 0 0             0");
  strcpy(&v12[22], "000 0 00000 0 000 000");
  strcpy(v13, "0         0 0   0   0");
  strcpy(&v13[22], "000000000000000000000");'''
maze=[(i[-24:-3]) for i in maze.split('\n')]


for i in maze:
    print(i)
# print(len(maze),(len(maze[0])))
from hashlib import md5
def finda(d):
    x,y=d[0],d[1]-1
    return (x,y,'a')
def findw(d):
    x,y=d[0]-1,d[1]
    return (x,y,'w')
def finds(d):
    x,y=d[0]+1,d[1]
    return (x,y,'s')
def findd(d):
    x,y=d[0],d[1]+1
    return (x,y,'d')
def find0(d,row,column):
    if d[0]==0:
        t=[finda(d),findd(d),finds(d)]
    elif d[0]==row-1:
        t=[findw(d),finda(d),findd(d)]
    elif d[1]==0:
        t=[findw(d),findd(d),finds(d)]
    elif d[1]==column-1:
        t=[findw(d),finda(d),finds(d)]
    else: t=[findw(d),finda(d),finds(d),findd(d)]
    tmp=[]
    for x,y,r in t:
        if maze[x][y]==' 'or maze[x][y]=='*' :
            tmp.append((x,y,r))
    return tmp

def get(o,O,row,column):#起点，终点，行，列
    SUM=[]
    Road = [('', o)]
    while True:
        road=[]
        for (r_pre,d) in Road:
            if d==O:#终点
                SUM.append((len(r_pre),r_pre,))
                print(r_pre.encode())
                print('NSSCTF{'+md5(r_pre.encode()).hexdigest()+'13371337'+'}')
                exit()
                # exit()
            next=find0(d,row,column)
            for x,y,r in next:
                if len(r_pre)>=1:
                    if 'ws'in r_pre[-1]+r or 'sw' in r_pre[-1]+r:
                        continue
                    if 'ad' in r_pre[-1] + r or 'da' in r_pre[-1] + r:
                        continue
                road.append((r_pre+r,(x,y)))
        # print(road)
        Road=road

row,column=21,21
get((15,0),(7,20),row,column)

1722245042043-0f1e8bb4-abac-453b-b0d7-b2c448126fbb.png

更新: 2024-07-29 17:33:02
原文: https://www.yuque.com/chaye-apqbl/vsc85q/qpt77zl7ce0pzudz

http://example.com/2026/01/19/RE/其他/maze迷宫MD5/
Author
chaye
Posted on
January 19, 2026
Licensed under