官方bilibiliWindows破解入门Android逆向入门
【网络诊断修复工具】切换到窄版

吾爱破解 - 52pojie.cn

 找回密码
 注册[Register]

QQ登录

只需一步，快速开始

吾爱破解 - 52pojie.cn»网站 › 【 软件安全 】 › 『脱壳破解区』 › [ctf]NewStarCTF2024_MazE wp
返回列表 发新帖
查看: 583|回复: 1
上一主题 下一主题
收起左侧

[CTF] [ctf]NewStarCTF2024_MazE wp

  [复制链接]
geesehoward
跳转到指定楼层
楼主
geesehoward 发表于 2026-4-10 14:13 回帖奖励
本帖最后由 geesehoward 于 2026-4-10 14:14 编辑

题目背景

这是一道迷宫题，本来想偷懒找wp看，结果没搜到，只能自己来分析了。

题目: 最终 flag 为 flag{md5(path)}，其中 md5 为 32 位小写

程序是linux 64位程序，无壳

程序分析

托入IDA，代码如下:

__int64 __fastcall main(int a1, char **a2, char **a3)
{
  size_t v4; // rax
  size_t v5; // rax
  size_t v6; // rax
  unsigned int v7; // [rsp+Ch] [rbp-3034h] BYREF
  unsigned int v8; // [rsp+10h] [rbp-3030h] BYREF
  __pid_t v9; // [rsp+14h] [rbp-302Ch]
  ssize_t v10; // [rsp+18h] [rbp-3028h]
  int pipedes[2]; // [rsp+20h] [rbp-3020h] BYREF
  int fd[2]; // [rsp+28h] [rbp-3018h] BYREF
  char s[16]; // [rsp+30h] [rbp-3010h] BYREF
  char v14[16]; // [rsp+1030h] [rbp-2010h] BYREF
  char buf[16]; // [rsp+2030h] [rbp-1010h] BYREF
  unsigned __int64 v16; // [rsp+3038h] [rbp-8h]

  v16 = __readfsqword(0x28u);
  if ( pipe(pipedes) == -1 || pipe(fd) == -1 )
  {
    perror("pipe failed");
    return 1;
  }
  else
  {
    v9 = fork();
    if ( v9 == -1 )
    {
      perror("fork failed");
      return 1;
    }
    else
    {
      if ( v9 )
      {
        close(pipedes[0]);
        close(fd[1]);
        read(fd[0], buf, 0x1000u);
        puts("This is a maze game.you need to go from the upper left corner of the maze to the lower right corner.");
        puts("The current interface only displays a 3*3 rectangular area centered on the current position.");
        puts("You can use 'w''a''s''d' on your keyboard to move");
        puts("Your flag is flag{md5(path)},and the path is the shortest path");
        puts(aHintThePathLen);
        printf("%s", buf);
        while ( 1 )
        {
          __isoc99_scanf("%s", s);
          system("clear");
          v4 = strlen(s);
          write(pipedes[1], s, v4 + 1);
          if ( !strcmp(s, "exit") )
            break;
          memset(buf, 0, 0x64u);
          read(fd[0], buf, 0x64u);
          puts(buf);
        }
        close(fd[0]);
        close(pipedes[1]);
      }
      else
      {
        close(fd[0]);
        close(pipedes[1]);
        v7 = 1;
        v8 = 1;
        sub_1469(v14, 1, 1);
        sleep(0);
        v5 = strlen(v14);
        write(fd[1], v14, v5 + 1);
        while ( 1 )
        {
          memset(buf, 0, 0x1000u);
          v10 = read(pipedes[0], buf, 0x1000u);
          if ( !strcmp(buf, "exit") )
            break;
          sub_168F(buf, (unsigned int)v10, &v7, &v8);
          memset(v14, 0, 0x1000u);
          sub_1469(v14, v7, v8);
          sleep(0);
          v6 = strlen(v14);
          write(fd[1], v14, v6 + 1);
        }
        close(pipedes[0]);
        close(fd[1]);
      }
      return 0;
    }
  }
}

程序用到了pipe和fork，父进程主要用于打印如下内容:

This is a maze game.you need to go from the upper left corner of the maze to the lower right corner.
The current interface only displays a 3*3 rectangular area centered on the current position.
You can use 'w''a''s''d' on your keyboard to move
Your flag is flag{md5(path)},and the path is the shortest path
hint:The path length is 936!!!!So don't think about doing it manually

根据提示，路径长度为936，手动肯定不行了。

前置知识

先来看看fork和pipe相关的知识点

Linux fork() 函数详解

fork() 是Unix和类Unix操作系统（如Linux）中的一个系统调用，用于创建新进程。它是一个非常重要的系统调用，是Unix进程管理的基础。

基本概念

当一个进程调用fork()时，系统会创建一个新的进程，这个新进程几乎完全复制了原进程的所有属性：

  • 程序计数器
  • 寄存器状态
  • 内存映像
  • 文件描述符表
  • 环境变量等

工作原理

  1. 调用fork()后，系统创建一个新进程，这个新进程被称为子进程。
  2. 子进程获得父进程的数据空间、堆栈和堆的副本。
  3. 返回值不同：
    • 在父进程中，fork()返回子进程的PID（正整数）
    • 在子进程中，fork()返回0
    • 如果出现错误，返回-1

示例代码

下面是一个简单的C语言示例来说明fork()的工作方式：

#include <stdio.h>
#include <unistd.h>
#include <sys/wait.h>

int main() {
    pid_t pid = fork();

    if (pid == -1) {
        perror("Fork failed");
        return 1;
    } else if (pid == 0) {
        // 子进程执行部分
        printf("这是子进程，PID: %d, 父进程PID: %d\n", getpid(), getppid());
    } else {
        // 父进程执行部分
        printf("这是父进程，PID: %d, 创建的子进程PID: %d\n", getpid(), pid);
        wait(NULL);  // 等待子进程结束
    }

    return 0;
}

特点

  1. 写时复制(Copy-on-Write)：现代Unix系统使用写时复制技术来优化fork()性能。父进程和子进程开始时共享相同的物理内存页，只有当其中一个进程试图修改内存时，系统才会创建新的内存页。

  2. 独立性：父进程和子进程是独立的，它们可以各自执行不同的代码路径。

  3. 资源继承：子进程继承了父进程的大部分属性，但有一些例外（如进程ID、父进程ID等）。

使用场景

  1. 创建新进程：最常见的用途是创建新进程来执行不同的任务
  2. 并行处理：利用多核CPU进行并行计算
  3. 守护进程：创建后台服务进程

注意事项

  1. 错误检查：总是要检查fork()的返回值，确保进程创建成功
  2. 僵尸进程：父进程需要通过wait()或waitpid()等待子进程结束，避免产生僵尸进程
  3. 资源管理：确保正确关闭文件描述符和其他资源

与其他进程创建方法的区别

  • fork()：创建一个完全相同的子进程
  • vfork()：轻量级fork()，父子进程共享内存空间
  • clone()：更通用的接口，允许更多控制参数

fork()是Unix/Linux系统编程中最重要的概念之一，理解它是掌握进程管理和并发编程的关键。

Linux管道（pipe）是一种进程间通信（IPC）机制，允许一个进程的输出直接作为另一个进程的输入。管道是Unix/Linux系统中最基本的IPC方式之一。

管道的基本概念

管道是一种半双工的通信方式，数据只能单向流动。它提供了一个无名的、驻留在内存中的缓冲区，用于连接两个相关的进程。

管道的类型

1. 匿名管道（Anonymous Pipe）

  • 用于父子进程或兄弟进程之间的通信
  • 使用pipe()系统调用创建
  • 当所有相关进程关闭管道后，管道自动销毁

2. 命名管道（Named Pipe/FIFO）

  • 通过mkfifo()系统调用创建，具有文件系统路径名
  • 可以用于不相关的进程间的通信
  • 需要手动删除

管道的工作原理

当创建一个管道时，系统会分配一个缓冲区，并返回两个文件描述符：

  • 读端（fd[0]）：用于读取数据
  • 写端（fd[1]）：用于写入数据

实际应用示例

在shell中，管道使用竖线符号（|）表示：

ls | grep ".py"     # ls命令的输出作为grep的输入
cat file.txt | wc -l    # 计算文件行数
ps aux | grep python    # 查找Python进程

在C语言中的实现

#include <unistd.h>
#include <stdio.h>
#include <sys/wait.h>

int main() {
    int pipefd[2];
    pid_t cpid;
    char buf;

    if (pipe(pipefd) == -1) {  // 创建管道
        perror("pipe");
        return 1;
    }

    cpid = fork();  // 创建子进程
    if (cpid == 0) {    // 子进程
        close(pipefd[1]);   // 关闭写端

        while (read(pipefd[0], &buf, 1) > 0)  // 从管道读取
            write(STDOUT_FILENO, &buf, 1);

        close(pipefd[0]);
        _exit(0);
    } else {    // 父进程
        close(pipefd[0]);   // 关闭读端

        write(pipefd[1], "Hello World\n", 12); // 向管道写入
        close(pipefd[1]);

        wait(NULL); // 等待子进程结束
    }

    return 0;
}

管道的特点

  1. 同步性：如果管道为空，读操作会被阻塞；如果管道满，写操作会被阻塞
  2. 顺序性：数据按写入顺序读出
  3. 大小限制：管道容量有限（通常是4KB或64KB）
  4. 一次性：数据一旦被读取就从管道中消失

管道的局限性

  1. 半双工：数据只能单向流动（虽然双向管道可以通过创建两个单向管道实现）
  2. 仅限于相关进程：匿名管道只适用于有共同祖先的进程
  3. 容量限制：管道缓冲区大小有限

高级管道概念

重定向和管道组合

command1 > file.txt | command2    # 错误语法
command1 | command2 > file.txt    # 正确语法

多级管道

cmd1 | cmd2 | cmd3 | cmd4

管道是Unix哲学的重要组成部分："做一件事并做好"，通过管道将多个简单工具连接起来完成复杂任务。

管道的实际应用场景

  1. 日志处理：tail -f /var/log/access.log | grep error | wc -l
  2. 数据过滤：find . -name "*.txt" | xargs grep "pattern"
  3. 系统监控：ps aux | grep httpd | awk '{print $2}' | xargs kill

子进程分析

  • sub_1469(v14, 1, 1); 先打印出迷宫左上角的3x3的区域
  • 然后通过pipe读取用户输入的值，最大1000个
  • sub_168F(buf, (unsigned int)v10, &v7, &v8); 根据用户输入判定迷宫是否能通行
  • 再次执行 sub_1469(v14, v7, v8); 画出新坐标点为中心的3x3迷宫

根据 sub_1469 的逻辑，走到(97, 97)为成功，可以判断迷宫加上障碍为99x99的矩阵，
同时根据 sub_1469 的逻辑，可以解密迷宫，有如下代码:

static unsigned char __fastcall decrypt_maze(unsigned char* encryptedMaze, int realPos)
{
    _BYTE Key[] = "tgrddf55";
    return encryptedMaze[realPos] ^ Key[realPos % 8];
}

static unsigned char __fastcall Calc_maze(unsigned char* encryptedMaze, int row, int col)
{
    return decrypt_maze(encryptedMaze, (99 * row + col) / 8) >> (7 - (99 * row + col) % 8) & 1;
}

static unsigned char __fastcall Set_maze(unsigned char* encryptedMaze, int row, int col)
{
    int v4; // [rsp+1Ch] [rbp-4h]

    v4 = Calc_maze(encryptedMaze, row, col);
    if (!v4)
        return 32;
    if (v4 == 1)
        return 49;
    return 101;
}

unsigned char encryptedMaze[] = { 0x8b, 0x98, 0x8d, 0x9b, 0x9b, 0x99, 0xca, 0xca, 0x8b, 0x98, 0x8d, 0x9b, 0x94, 0x22, 0x74, 0x25,
        0x70, 0x26, 0x76, 0x64, 0x74, 0x72, 0x35, 0x75, 0x63, 0xcc, 0xd9, 0xce, 0x9a, 0xcd, 0xdb, 0x8a,
        0x8e, 0x9d, 0xcd, 0xcf, 0x9e, 0xb3, 0x20, 0x20, 0x34, 0x23, 0x62, 0x35, 0x60, 0x22, 0x61, 0x71,
        0x30, 0x3d, 0xc8, 0xde, 0xcf, 0x99, 0xcf, 0xce, 0xca, 0xd9, 0xc8, 0xcf, 0x9a, 0xdd, 0x24, 0x64,
        0x31, 0x26, 0x32, 0x35, 0x65, 0x72, 0x24, 0x20, 0x30, 0x36, 0x1d, 0xce, 0x8b, 0xcd, 0x9e, 0xcf,
        0xcb, 0xc9, 0x99, 0x8a, 0xcf, 0xcd, 0x99, 0x70, 0x25, 0x73, 0x37, 0x25, 0x34, 0x72, 0x64, 0x74,
        0x60, 0x72, 0x67, 0x8f, 0xca, 0x9c, 0xce, 0x9e, 0xdf, 0x99, 0x98, 0x9f, 0x8f, 0x8c, 0x9b, 0x84,
        0x30, 0x37, 0x32, 0x71, 0x35, 0x26, 0x24, 0x74, 0x25, 0x62, 0x26, 0x32, 0x8a, 0x8c, 0xca, 0xcf,
        0xdf, 0x8c, 0x8c, 0x8f, 0xce, 0x9c, 0x8f, 0xdf, 0xb0, 0x76, 0x22, 0x65, 0x75, 0x63, 0x31, 0x24,
        0x30, 0x23, 0x22, 0x21, 0x7b, 0x9c, 0xdf, 0xca, 0xdf, 0x89, 0xcc, 0xde, 0x8f, 0x89, 0x8a, 0xcb,
        0xcf, 0x66, 0x33, 0x34, 0x71, 0x77, 0x75, 0x61, 0x25, 0x26, 0x76, 0x64, 0x34, 0x08, 0x9b, 0xdf,
        0x8e, 0x9d, 0x9d, 0xde, 0xde, 0x8c, 0xda, 0x8a, 0x9e, 0x8a, 0x66, 0x25, 0x25, 0x23, 0x64, 0x31,
        0x25, 0x23, 0x33, 0x71, 0x65, 0x33, 0x9a, 0xda, 0x9b, 0xc9, 0xd8, 0x8a, 0xcf, 0x8d, 0xda, 0x9f,
        0xdb, 0x8d, 0xc6, 0x61, 0x60, 0x72, 0x65, 0x71, 0x21, 0x66, 0x37, 0x71, 0x30, 0x77, 0x23, 0xcf,
        0xda, 0x9c, 0xd9, 0x9e, 0x8e, 0x9d, 0xdf, 0xdf, 0xde, 0x9d, 0x8c, 0xb5, 0x30, 0x26, 0x70, 0x75,
        0x35, 0x26, 0x32, 0x35, 0x30, 0x27, 0x65, 0x6f, 0xde, 0xc8, 0x88, 0x8f, 0x9b, 0x99, 0x9e, 0xdb,
        0x9a, 0x99, 0x98, 0x8f, 0x71, 0x33, 0x25, 0x64, 0x30, 0x77, 0x37, 0x21, 0x71, 0x72, 0x24, 0x30,
        0x0f, 0xdc, 0xd8, 0x9e, 0x8a, 0xdc, 0xde, 0x8f, 0xda, 0xc9, 0xdc, 0x9b, 0xc9, 0x77, 0x20, 0x71,
        0x25, 0x76, 0x66, 0x20, 0x30, 0x23, 0x71, 0x25, 0x71, 0xdc, 0xc8, 0x8e, 0xdf, 0xc9, 0x8b, 0xce,
        0xcf, 0x89, 0xd9, 0x9b, 0xcb, 0xd7, 0x65, 0x70, 0x20, 0x23, 0x63, 0x61, 0x61, 0x63, 0x20, 0x31,
        0x61, 0x20, 0xd9, 0x9a, 0xde, 0xdd, 0xce, 0x9b, 0xcb, 0xd9, 0xdc, 0xdf, 0xdf, 0xcd, 0xf1, 0x24,
        0x60, 0x33, 0x72, 0x21, 0x74, 0x72, 0x61, 0x24, 0x31, 0x62, 0x29, 0x9e, 0xca, 0xdc, 0xca, 0xde,
        0xce, 0xdd, 0x98, 0x9b, 0xcf, 0xd9, 0x9e, 0x74, 0x65, 0x62, 0x32, 0x71, 0x70, 0x32, 0x64, 0x64,
        0x70, 0x27, 0x63, 0x0f, 0xdb, 0x88, 0x9a, 0xcf, 0xce, 0xdd, 0x98, 0xce, 0xcf, 0x98, 0xcf, 0xd8,
        0x65, 0x62, 0x27, 0x64, 0x20, 0x32, 0x70, 0x20, 0x21, 0x67, 0x22, 0x35, 0xdf, 0xc9, 0x9f, 0x8a,
        0xcb, 0x89, 0xcc, 0xcf, 0xce, 0xd9, 0x9f, 0xce, 0xc0, 0x73, 0x63, 0x30, 0x74, 0x22, 0x74, 0x60,
        0x61, 0x33, 0x76, 0x30, 0x22, 0xd8, 0xce, 0xdf, 0xcf, 0x8d, 0xdd, 0xce, 0x9e, 0xcd, 0x8a, 0xcf,
        0xcf, 0xb3, 0x62, 0x65, 0x60, 0x23, 0x61, 0x60, 0x34, 0x32, 0x77, 0x64, 0x70, 0x7c, 0x9f, 0xca,
        0x9b, 0x9d, 0xd8, 0x8e, 0xcb, 0x9c, 0x8a, 0x9a, 0x8a, 0x9c, 0x67, 0x74, 0x65, 0x76, 0x64, 0x64,
        0x71, 0x76, 0x23, 0x75, 0x60, 0x22, 0x4b, 0xcb, 0x8b, 0x89, 0x89, 0x8a, 0x9a, 0xcc, 0x9f, 0x9b,
        0x9e, 0x89, 0xce, 0x75, 0x74, 0x23, 0x24, 0x31, 0x65, 0x76, 0x67, 0x30, 0x75, 0x23, 0x24, 0x8b,
        0xdb, 0xdd, 0xdc, 0xde, 0x9a, 0xc9, 0xcb, 0x9b, 0x9b, 0x89, 0xdc, 0xd0, 0x71, 0x62, 0x71, 0x64,
        0x24, 0x76, 0x76, 0x75, 0x75, 0x63, 0x20, 0x23, 0x8f, 0xcc, 0xcc, 0x8e, 0xce, 0x99, 0xdb, 0x8e,
        0x9a, 0x9d, 0xdc, 0xca, 0xa5, 0x63, 0x21, 0x64, 0x21, 0x37, 0x66, 0x21, 0x21, 0x66, 0x71, 0x60,
        0x6a, 0xdc, 0x88, 0xce, 0x9e, 0xcd, 0xcf, 0xda, 0xda, 0xd8, 0x8d, 0x8e, 0x8b, 0x77, 0x35, 0x61,
        0x25, 0x32, 0x33, 0x20, 0x20, 0x36, 0x71, 0x21, 0x34, 0x08, 0xcd, 0x9e, 0x9e, 0xdc, 0xde, 0x9e,
        0x9e, 0x8c, 0xd8, 0xde, 0xdb, 0x8a, 0x74, 0x35, 0x35, 0x76, 0x33, 0x30, 0x61, 0x22, 0x31, 0x64,
        0x31, 0x62, 0xc9, 0x8b, 0x9b, 0xd9, 0x9a, 0xdf, 0xcf, 0xc9, 0x9d, 0x9f, 0xcb, 0xcc, 0x81, 0x74,
        0x30, 0x73, 0x62, 0x21, 0x70, 0x22, 0x64, 0x31, 0x60, 0x66, 0x24, 0xdf, 0xce, 0xdc, 0xde, 0xdf,
        0xcf, 0xdc, 0x9c, 0x8a, 0x9a, 0x99, 0xdb, 0xe5, 0x30, 0x36, 0x23, 0x60, 0x35, 0x77, 0x31, 0x20,
        0x30, 0x37, 0x33, 0x7f, 0x9f, 0xdd, 0xdf, 0xce, 0x8f, 0xdc, 0xcc, 0xda, 0xca, 0xcd, 0xde, 0x9a,
        0x65, 0x26, 0x37, 0x65, 0x25, 0x62, 0x24, 0x21, 0x60, 0x22, 0x33, 0x21, 0x1a, 0xc9, 0x9f, 0x8a,
        0xcf, 0xd8, 0x89, 0xca, 0x8a, 0x89, 0x9e, 0xda, 0xd8, 0x32, 0x66, 0x24, 0x20, 0x36, 0x74, 0x60,
        0x74, 0x26, 0x67, 0x60, 0x61, 0xcc, 0x9f, 0xda, 0x9f, 0xdd, 0x99, 0xce, 0xdb, 0x89, 0x9f, 0x8b,
        0x8b, 0xd3, 0x37, 0x21, 0x65, 0x66, 0x70, 0x64, 0x65, 0x63, 0x33, 0x34, 0x25, 0x60, 0xca, 0x9b,
        0xdb, 0x88, 0x8c, 0x8f, 0x9f, 0xd8, 0xda, 0x8e, 0x9f, 0x89, 0xb3, 0x60, 0x71, 0x62, 0x31, 0x71,
        0x34, 0x73, 0x32, 0x70, 0x21, 0x27, 0x2a, 0x8a, 0x8a, 0x89, 0x8c, 0xda, 0xca, 0xd8, 0x9a, 0xcb,
        0xce, 0xcc, 0x89, 0x70, 0x64, 0x77, 0x25, 0x71, 0x60, 0x33, 0x66, 0x74, 0x74, 0x33, 0x31, 0x5f,
        0xcb, 0x89, 0x9c, 0xdf, 0xdb, 0x8c, 0x8b, 0x8f, 0x8f, 0x8d, 0xcc, 0xd9, 0x30, 0x72, 0x64, 0x61,
        0x25, 0x62, 0x26, 0x75, 0x25, 0x77, 0x65, 0x24, 0xce, 0xdd, 0x98, 0x8e, 0xde, 0xc8, 0x8f, 0x8a,
        0x9b, 0xd9, 0x89, 0x9b, 0xd5, 0x22, 0x64, 0x70, 0x34, 0x33, 0x32, 0x20, 0x60, 0x62, 0x25, 0x75,
        0x72, 0xc8, 0xc8, 0x8a, 0xcb, 0x9d, 0xda, 0xce, 0xce, 0x98, 0xc8, 0x9f, 0x9a, 0xb3, 0x31, 0x24,
        0x70, 0x27, 0x32, 0x25, 0x75, 0x26, 0x31, 0x65, 0x30, 0x3d, 0xdd, 0x9a, 0x9a, 0x8d, 0xde, 0x8e,
        0xca, 0xc8, 0x8c, 0x9f, 0xde, 0xdd, 0x70, 0x35, 0x34, 0x22, 0x63, 0x70, 0x34, 0x33, 0x30, 0x25,
        0x30, 0x33, 0x1d, 0xcb, 0xdb, 0xd8, 0xce, 0x8f, 0xcf, 0x89, 0xdc, 0xca, 0x9f, 0xdc, 0x88, 0x24,
        0x64, 0x77, 0x32, 0x20, 0x30, 0x22, 0x21, 0x64, 0x24, 0x33, 0x27, 0xce, 0x8e, 0x99, 0xda, 0xce,
        0xca, 0xcd, 0x8d, 0xde, 0x8e, 0x9c, 0x8f, 0x80, 0x35, 0x27, 0x76, 0x75, 0x20, 0x73, 0x71, 0x31,
        0x25, 0x26, 0x63, 0x72, 0xdb, 0x88, 0x8b, 0xcf, 0xcf, 0xd8, 0xd9, 0xdb, 0xce, 0xcd, 0x8b, 0xdb,
        0xa4, 0x66, 0x66, 0x21, 0x74, 0x22, 0x24, 0x34, 0x61, 0x72, 0x26, 0x20, 0x3f, 0xd9, 0xca, 0x9b,
        0xcb, 0x9c, 0xc9, 0xdb, 0x8e, 0xc8, 0x9f, 0x9b, 0x9f, 0x73, 0x66, 0x20, 0x70, 0x67, 0x30, 0x25,
        0x25, 0x32, 0x66, 0x30, 0x61, 0x1c, 0x8f, 0x9e, 0x9a, 0xd9, 0xcd, 0xdf, 0x8e, 0x8d, 0x9b, 0xcf,
        0xcb, 0xcb, 0x36, 0x30, 0x25, 0x66, 0x61, 0x34, 0x61, 0x32, 0x76, 0x24, 0x30, 0x63, 0x8a, 0xdf,
        0x8f, 0x98, 0x89, 0xdb, 0xde, 0xcc, 0x8a, 0xca, 0x8f, 0xd8, 0xc2, 0x60, 0x30, 0x26, 0x31, 0x75,
        0x65, 0x26, 0x62, 0x74, 0x60, 0x62, 0x32, 0xcb, 0x9e, 0xdd, 0x8c, 0xdf, 0x9f, 0xc8, 0xce, 0xcf,
        0x8a, 0xd8, 0xcd, 0xa4, 0x75, 0x22, 0x64, 0x24, 0x35, 0x22, 0x63, 0x25, 0x34, 0x76, 0x24, 0x2e,
        0x8a, 0x89, 0x88, 0xcb, 0xcf, 0xdd, 0x8b, 0x9a, 0xde, 0x9c, 0x88, 0xcf, 0x74, 0x22, 0x75, 0x61,
        0x65, 0x76, 0x62, 0x71, 0x60, 0x22, 0x74, 0x24, 0x0e, 0x98, 0x9d, 0x9a, 0x9f, 0x9d, 0x8e, 0xcb,
        0xdb, 0x99, 0x98, 0x9a, 0x99, 0x76, 0x24, 0x35, 0x24, 0x26, 0x62, 0x70, 0x20, 0x27, 0x30, 0x65,
        0x65, 0xdd, 0x88, 0x9b, 0xce, 0x9c, 0x8e, 0xcf, 0xdb, 0x8c, 0xcc, 0xde, 0x9a, 0xd7, 0x74, 0x25,
        0x60, 0x37, 0x22, 0x34, 0x20, 0x67, 0x61, 0x65, 0x31, 0x70, 0xd9, 0xda, 0x9e, 0x8d, 0xce, 0xcf,
        0x8b, 0x9c, 0x98, 0xcf, 0x9a, 0xc8, 0xf0, 0x71, 0x24, 0x76, 0x63, 0x60, 0x30, 0x67, 0x74, 0x21,
        0x34, 0x32, 0x68, 0xdf, 0x8e, 0x98, 0xcf, 0x8b, 0x9e, 0xdc, 0xd9, 0x8a, 0x8f, 0x8c, 0x9a, 0x61,
        0x34, 0x37, 0x23, 0x35, 0x61, 0x27, 0x60, 0x25, 0x65, 0x23, 0x36, 0x1e, 0xdf, 0x98, 0xdb, 0x9f,
        0xca, 0xc8, 0x98, 0xdf, 0x9a, 0x88, 0xca, 0xd9, 0x35, 0x66, 0x66, 0x75, 0x30, 0x73, 0x34, 0x74,
        0x34, 0x22, 0x72, 0x61, 0xdb, 0x89, 0x9f, 0xca, 0x9e, 0xd9, 0xc9, 0x8b, 0xce, 0x89, 0x9a, 0xcb,
        0xc4, 0x67, 0x63, 0x64, 0x65, 0x22, 0x35, 0x31, 0x70, 0x23, 0x73, 0x64, 0x63, 0x99, 0xca, 0xca,
        0x8b, 0x98, 0x8d, 0x9b, 0x9b, 0x99, 0xca, 0xca, 0x8b, 0xe7
};

_DWORD rowMask[] = { 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0 };
_DWORD colMask[] = { 0xFFFFFFFF, 0, 1, 0, 0xFFFFFFFF, 0, 1, 0, 0xFFFFFFFF, 0, 1, 0, 0, 0, 0, 0 };

static char* __fastcall Init_maze(char** maze, int row, int col)
{
    for (int i = 0; i <= 2; ++i)
        maze[row - 1][col - 1 + i] = Set_maze(encryptedMaze, rowMask[i] + row, colMask[i] + col);
    for (int j = 4; j <= 6; ++j)
        maze[row][col - 1 + j - 4] = Set_maze(encryptedMaze, rowMask[j] + row, colMask[j] + col);
    for (int k = 8; k <= 10 ; ++k)
        maze[row + 1][col - 1 + k - 8] = Set_maze(encryptedMaze, rowMask[k] + row, colMask[k] + col);
    return 0;
}

int main(void)
{
    system("chcp 65001");
    char ** maze = (char**)malloc(99 * sizeof(char*));
    if (maze)
    {
        memset(maze, 0, 99 * sizeof(char*));
        for (int i = 0; i < 99; i++)
        {
            maze[i] = (char*)malloc(100);
            if (maze[i])
            {
                memset(maze[i], 48, 100);
                maze[i][99] = 0;
            }
        }
        for (int i = 1; i < 99; i = i + 3)
        {
            for (int j = 1; j < 99; j = j + 3)
            {
                Init_maze(maze, i, j);
            }
        }
        for (int i = 0; i < 99; i++)
            printf("%s\n", maze[i]);
        for (int i = 0; i < 99; i++)
        {
            if (maze[i])
            {
                free(maze[i]);
                maze[i] = NULL;
            }
        }
        free(maze);
        maze = NULL;
    }
    return 0;

}

迷宫解法

得到迷宫数据后，编写解迷宫代码:

typedef struct _stPOS
{
    int x;
    int y;
} stPOS;

static BOOL NextW(const char** maze, stPOS start, stPOS end, char* path, int pathCnt);
static BOOL NextA(const char** maze, stPOS start, stPOS end, char* path, int pathCnt);
static BOOL NextS(const char** maze, stPOS start, stPOS end, char* path, int pathCnt);
static BOOL NextD(const char** maze, stPOS start, stPOS end, char* path, int pathCnt);

static BOOL NextW(const char** maze, stPOS start, stPOS end, char* path, int pathCnt)
{
    BOOL result = FALSE;
    path[pathCnt++] = 'w';
    start.x -= 1;
    if (start.x > 0 && maze[start.x - 1][start.y] != '1')
    {
        int ret = NextW(maze, start, end, path, pathCnt);
        result |= ret;
    }
    if (start.y > 0 && maze[start.x][start.y - 1] != '1')
    {
        int ret = NextA(maze, start, end, path, pathCnt);
        result |= ret;
    }
    if (start.y < end.y && maze[start.x][start.y + 1] != '1')
    {
        int ret = NextD(maze, start, end, path, pathCnt);
        result |= ret;
    }

    return FALSE;
}

static BOOL NextD(const char** maze, stPOS start, stPOS end, char* path, int pathCnt)
{
    BOOL result = FALSE;
    path[pathCnt++] = 'd';
    start.y += 1;
    if (start.x == end.x && start.y == end.y)
    {
        path[pathCnt] = 0;
        printf("path:%s\npathCnt:%d", path, pathCnt);
        return TRUE;
    }
    if (start.x > 0 && maze[start.x - 1][start.y] != '1')
    {
        int ret = NextW(maze, start, end, path, pathCnt);
        result |= ret;
    }
    if (start.x < end.x && maze[start.x + 1][start.y] != '1')
    {
        int ret = NextS(maze, start, end, path, pathCnt);
        result |= ret;
    }
    if (start.y < end.y && maze[start.x][start.y + 1] != '1')
    {
        int ret = NextD(maze, start, end, path, pathCnt);
        result |= ret;
    }
    return FALSE;
}

static BOOL NextA(const char** maze, stPOS start, stPOS end, char* path, int pathCnt)
{
    BOOL result = FALSE;
    path[pathCnt++] = 'a';
    start.y -= 1;

    if (start.x > 0 && maze[start.x - 1][start.y] != '1')
    {
        int ret = NextW(maze, start, end, path, pathCnt);
        result |= ret;
    }
    if (start.x < end.x && maze[start.x + 1][start.y] != '1')
    {
        int ret = NextS(maze, start, end, path, pathCnt);
        result |= ret;
    }
    if (start.y > 0 && maze[start.x][start.y - 1] != '1')
    {
        int ret = NextA(maze, start, end, path, pathCnt);
        result |= ret;
    }
    return FALSE;
}

static BOOL NextS(const char** maze, stPOS start, stPOS end, char* path, int pathCnt)
{
    BOOL result = FALSE;
    path[pathCnt++] = 's';
    start.x += 1;
    if (start.x == end.x && start.y == end.y)
    {
        path[pathCnt] = 0;
        printf("path:%s\npathCnt:%d", path, pathCnt);
        return TRUE;
    }
    if (start.x < end.x && maze[start.x + 1][start.y] != '1')
    {
        int ret = NextS(maze, start, end, path, pathCnt);
        result |= ret;
    }
    if (start.y > 0 && maze[start.x][start.y - 1] != '1')
    {
        int ret = NextA(maze, start, end, path, pathCnt);
        result |= ret;
    }
    if (start.y < end.y && maze[start.x][start.y + 1] != '1')
    {
        int ret = NextD(maze, start, end, path, pathCnt);
        result |= ret;
    }
    return FALSE;
}

static BOOL findPath(const char** maze, stPOS start, stPOS end, char* path, int pathCnt)
{
    BOOL result = FALSE;
    if (maze[start.x - 1][start.y] != '1')
    {
        int ret = NextW(maze, start, end, path, pathCnt);
        result |= ret;
    }
    if (maze[start.x + 1][start.y] != '1')
    {
        int ret = NextS(maze, start, end, path, pathCnt);
        result |= ret;
    }
    if (maze[start.x][start.y - 1] != '1')
    {
        int ret = NextA(maze, start, end, path, pathCnt);
        result |= ret;
    }
    if (maze[start.x][start.y + 1] != '1')
    {
        int ret = NextD(maze, start, end, path, pathCnt);
        result |= ret;
    }

    return 0;
}

完整代码

最后整合到main函数调用的完整代码如下:

static unsigned char __fastcall decrypt_maze(unsigned char* encryptedMaze, int realPos)
{
    _BYTE Key[] = "tgrddf55";
    return encryptedMaze[realPos] ^ Key[realPos % 8];
}

static unsigned char __fastcall Calc_maze(unsigned char* encryptedMaze, int row, int col)
{
    return decrypt_maze(encryptedMaze, (99 * row + col) / 8) >> (7 - (99 * row + col) % 8) & 1;
}

static unsigned char __fastcall Set_maze(unsigned char* encryptedMaze, int row, int col)
{
    int v4; // [rsp+1Ch] [rbp-4h]

    v4 = Calc_maze(encryptedMaze, row, col);
    if (!v4)
        return 32;
    if (v4 == 1)
        return 49;
    return 101;
}

unsigned char encryptedMaze[] = { 0x8b, 0x98, 0x8d, 0x9b, 0x9b, 0x99, 0xca, 0xca, 0x8b, 0x98, 0x8d, 0x9b, 0x94, 0x22, 0x74, 0x25,
        0x70, 0x26, 0x76, 0x64, 0x74, 0x72, 0x35, 0x75, 0x63, 0xcc, 0xd9, 0xce, 0x9a, 0xcd, 0xdb, 0x8a,
        0x8e, 0x9d, 0xcd, 0xcf, 0x9e, 0xb3, 0x20, 0x20, 0x34, 0x23, 0x62, 0x35, 0x60, 0x22, 0x61, 0x71,
        0x30, 0x3d, 0xc8, 0xde, 0xcf, 0x99, 0xcf, 0xce, 0xca, 0xd9, 0xc8, 0xcf, 0x9a, 0xdd, 0x24, 0x64,
        0x31, 0x26, 0x32, 0x35, 0x65, 0x72, 0x24, 0x20, 0x30, 0x36, 0x1d, 0xce, 0x8b, 0xcd, 0x9e, 0xcf,
        0xcb, 0xc9, 0x99, 0x8a, 0xcf, 0xcd, 0x99, 0x70, 0x25, 0x73, 0x37, 0x25, 0x34, 0x72, 0x64, 0x74,
        0x60, 0x72, 0x67, 0x8f, 0xca, 0x9c, 0xce, 0x9e, 0xdf, 0x99, 0x98, 0x9f, 0x8f, 0x8c, 0x9b, 0x84,
        0x30, 0x37, 0x32, 0x71, 0x35, 0x26, 0x24, 0x74, 0x25, 0x62, 0x26, 0x32, 0x8a, 0x8c, 0xca, 0xcf,
        0xdf, 0x8c, 0x8c, 0x8f, 0xce, 0x9c, 0x8f, 0xdf, 0xb0, 0x76, 0x22, 0x65, 0x75, 0x63, 0x31, 0x24,
        0x30, 0x23, 0x22, 0x21, 0x7b, 0x9c, 0xdf, 0xca, 0xdf, 0x89, 0xcc, 0xde, 0x8f, 0x89, 0x8a, 0xcb,
        0xcf, 0x66, 0x33, 0x34, 0x71, 0x77, 0x75, 0x61, 0x25, 0x26, 0x76, 0x64, 0x34, 0x08, 0x9b, 0xdf,
        0x8e, 0x9d, 0x9d, 0xde, 0xde, 0x8c, 0xda, 0x8a, 0x9e, 0x8a, 0x66, 0x25, 0x25, 0x23, 0x64, 0x31,
        0x25, 0x23, 0x33, 0x71, 0x65, 0x33, 0x9a, 0xda, 0x9b, 0xc9, 0xd8, 0x8a, 0xcf, 0x8d, 0xda, 0x9f,
        0xdb, 0x8d, 0xc6, 0x61, 0x60, 0x72, 0x65, 0x71, 0x21, 0x66, 0x37, 0x71, 0x30, 0x77, 0x23, 0xcf,
        0xda, 0x9c, 0xd9, 0x9e, 0x8e, 0x9d, 0xdf, 0xdf, 0xde, 0x9d, 0x8c, 0xb5, 0x30, 0x26, 0x70, 0x75,
        0x35, 0x26, 0x32, 0x35, 0x30, 0x27, 0x65, 0x6f, 0xde, 0xc8, 0x88, 0x8f, 0x9b, 0x99, 0x9e, 0xdb,
        0x9a, 0x99, 0x98, 0x8f, 0x71, 0x33, 0x25, 0x64, 0x30, 0x77, 0x37, 0x21, 0x71, 0x72, 0x24, 0x30,
        0x0f, 0xdc, 0xd8, 0x9e, 0x8a, 0xdc, 0xde, 0x8f, 0xda, 0xc9, 0xdc, 0x9b, 0xc9, 0x77, 0x20, 0x71,
        0x25, 0x76, 0x66, 0x20, 0x30, 0x23, 0x71, 0x25, 0x71, 0xdc, 0xc8, 0x8e, 0xdf, 0xc9, 0x8b, 0xce,
        0xcf, 0x89, 0xd9, 0x9b, 0xcb, 0xd7, 0x65, 0x70, 0x20, 0x23, 0x63, 0x61, 0x61, 0x63, 0x20, 0x31,
        0x61, 0x20, 0xd9, 0x9a, 0xde, 0xdd, 0xce, 0x9b, 0xcb, 0xd9, 0xdc, 0xdf, 0xdf, 0xcd, 0xf1, 0x24,
        0x60, 0x33, 0x72, 0x21, 0x74, 0x72, 0x61, 0x24, 0x31, 0x62, 0x29, 0x9e, 0xca, 0xdc, 0xca, 0xde,
        0xce, 0xdd, 0x98, 0x9b, 0xcf, 0xd9, 0x9e, 0x74, 0x65, 0x62, 0x32, 0x71, 0x70, 0x32, 0x64, 0x64,
        0x70, 0x27, 0x63, 0x0f, 0xdb, 0x88, 0x9a, 0xcf, 0xce, 0xdd, 0x98, 0xce, 0xcf, 0x98, 0xcf, 0xd8,
        0x65, 0x62, 0x27, 0x64, 0x20, 0x32, 0x70, 0x20, 0x21, 0x67, 0x22, 0x35, 0xdf, 0xc9, 0x9f, 0x8a,
        0xcb, 0x89, 0xcc, 0xcf, 0xce, 0xd9, 0x9f, 0xce, 0xc0, 0x73, 0x63, 0x30, 0x74, 0x22, 0x74, 0x60,
        0x61, 0x33, 0x76, 0x30, 0x22, 0xd8, 0xce, 0xdf, 0xcf, 0x8d, 0xdd, 0xce, 0x9e, 0xcd, 0x8a, 0xcf,
        0xcf, 0xb3, 0x62, 0x65, 0x60, 0x23, 0x61, 0x60, 0x34, 0x32, 0x77, 0x64, 0x70, 0x7c, 0x9f, 0xca,
        0x9b, 0x9d, 0xd8, 0x8e, 0xcb, 0x9c, 0x8a, 0x9a, 0x8a, 0x9c, 0x67, 0x74, 0x65, 0x76, 0x64, 0x64,
        0x71, 0x76, 0x23, 0x75, 0x60, 0x22, 0x4b, 0xcb, 0x8b, 0x89, 0x89, 0x8a, 0x9a, 0xcc, 0x9f, 0x9b,
        0x9e, 0x89, 0xce, 0x75, 0x74, 0x23, 0x24, 0x31, 0x65, 0x76, 0x67, 0x30, 0x75, 0x23, 0x24, 0x8b,
        0xdb, 0xdd, 0xdc, 0xde, 0x9a, 0xc9, 0xcb, 0x9b, 0x9b, 0x89, 0xdc, 0xd0, 0x71, 0x62, 0x71, 0x64,
        0x24, 0x76, 0x76, 0x75, 0x75, 0x63, 0x20, 0x23, 0x8f, 0xcc, 0xcc, 0x8e, 0xce, 0x99, 0xdb, 0x8e,
        0x9a, 0x9d, 0xdc, 0xca, 0xa5, 0x63, 0x21, 0x64, 0x21, 0x37, 0x66, 0x21, 0x21, 0x66, 0x71, 0x60,
        0x6a, 0xdc, 0x88, 0xce, 0x9e, 0xcd, 0xcf, 0xda, 0xda, 0xd8, 0x8d, 0x8e, 0x8b, 0x77, 0x35, 0x61,
        0x25, 0x32, 0x33, 0x20, 0x20, 0x36, 0x71, 0x21, 0x34, 0x08, 0xcd, 0x9e, 0x9e, 0xdc, 0xde, 0x9e,
        0x9e, 0x8c, 0xd8, 0xde, 0xdb, 0x8a, 0x74, 0x35, 0x35, 0x76, 0x33, 0x30, 0x61, 0x22, 0x31, 0x64,
        0x31, 0x62, 0xc9, 0x8b, 0x9b, 0xd9, 0x9a, 0xdf, 0xcf, 0xc9, 0x9d, 0x9f, 0xcb, 0xcc, 0x81, 0x74,
        0x30, 0x73, 0x62, 0x21, 0x70, 0x22, 0x64, 0x31, 0x60, 0x66, 0x24, 0xdf, 0xce, 0xdc, 0xde, 0xdf,
        0xcf, 0xdc, 0x9c, 0x8a, 0x9a, 0x99, 0xdb, 0xe5, 0x30, 0x36, 0x23, 0x60, 0x35, 0x77, 0x31, 0x20,
        0x30, 0x37, 0x33, 0x7f, 0x9f, 0xdd, 0xdf, 0xce, 0x8f, 0xdc, 0xcc, 0xda, 0xca, 0xcd, 0xde, 0x9a,
        0x65, 0x26, 0x37, 0x65, 0x25, 0x62, 0x24, 0x21, 0x60, 0x22, 0x33, 0x21, 0x1a, 0xc9, 0x9f, 0x8a,
        0xcf, 0xd8, 0x89, 0xca, 0x8a, 0x89, 0x9e, 0xda, 0xd8, 0x32, 0x66, 0x24, 0x20, 0x36, 0x74, 0x60,
        0x74, 0x26, 0x67, 0x60, 0x61, 0xcc, 0x9f, 0xda, 0x9f, 0xdd, 0x99, 0xce, 0xdb, 0x89, 0x9f, 0x8b,
        0x8b, 0xd3, 0x37, 0x21, 0x65, 0x66, 0x70, 0x64, 0x65, 0x63, 0x33, 0x34, 0x25, 0x60, 0xca, 0x9b,
        0xdb, 0x88, 0x8c, 0x8f, 0x9f, 0xd8, 0xda, 0x8e, 0x9f, 0x89, 0xb3, 0x60, 0x71, 0x62, 0x31, 0x71,
        0x34, 0x73, 0x32, 0x70, 0x21, 0x27, 0x2a, 0x8a, 0x8a, 0x89, 0x8c, 0xda, 0xca, 0xd8, 0x9a, 0xcb,
        0xce, 0xcc, 0x89, 0x70, 0x64, 0x77, 0x25, 0x71, 0x60, 0x33, 0x66, 0x74, 0x74, 0x33, 0x31, 0x5f,
        0xcb, 0x89, 0x9c, 0xdf, 0xdb, 0x8c, 0x8b, 0x8f, 0x8f, 0x8d, 0xcc, 0xd9, 0x30, 0x72, 0x64, 0x61,
        0x25, 0x62, 0x26, 0x75, 0x25, 0x77, 0x65, 0x24, 0xce, 0xdd, 0x98, 0x8e, 0xde, 0xc8, 0x8f, 0x8a,
        0x9b, 0xd9, 0x89, 0x9b, 0xd5, 0x22, 0x64, 0x70, 0x34, 0x33, 0x32, 0x20, 0x60, 0x62, 0x25, 0x75,
        0x72, 0xc8, 0xc8, 0x8a, 0xcb, 0x9d, 0xda, 0xce, 0xce, 0x98, 0xc8, 0x9f, 0x9a, 0xb3, 0x31, 0x24,
        0x70, 0x27, 0x32, 0x25, 0x75, 0x26, 0x31, 0x65, 0x30, 0x3d, 0xdd, 0x9a, 0x9a, 0x8d, 0xde, 0x8e,
        0xca, 0xc8, 0x8c, 0x9f, 0xde, 0xdd, 0x70, 0x35, 0x34, 0x22, 0x63, 0x70, 0x34, 0x33, 0x30, 0x25,
        0x30, 0x33, 0x1d, 0xcb, 0xdb, 0xd8, 0xce, 0x8f, 0xcf, 0x89, 0xdc, 0xca, 0x9f, 0xdc, 0x88, 0x24,
        0x64, 0x77, 0x32, 0x20, 0x30, 0x22, 0x21, 0x64, 0x24, 0x33, 0x27, 0xce, 0x8e, 0x99, 0xda, 0xce,
        0xca, 0xcd, 0x8d, 0xde, 0x8e, 0x9c, 0x8f, 0x80, 0x35, 0x27, 0x76, 0x75, 0x20, 0x73, 0x71, 0x31,
        0x25, 0x26, 0x63, 0x72, 0xdb, 0x88, 0x8b, 0xcf, 0xcf, 0xd8, 0xd9, 0xdb, 0xce, 0xcd, 0x8b, 0xdb,
        0xa4, 0x66, 0x66, 0x21, 0x74, 0x22, 0x24, 0x34, 0x61, 0x72, 0x26, 0x20, 0x3f, 0xd9, 0xca, 0x9b,
        0xcb, 0x9c, 0xc9, 0xdb, 0x8e, 0xc8, 0x9f, 0x9b, 0x9f, 0x73, 0x66, 0x20, 0x70, 0x67, 0x30, 0x25,
        0x25, 0x32, 0x66, 0x30, 0x61, 0x1c, 0x8f, 0x9e, 0x9a, 0xd9, 0xcd, 0xdf, 0x8e, 0x8d, 0x9b, 0xcf,
        0xcb, 0xcb, 0x36, 0x30, 0x25, 0x66, 0x61, 0x34, 0x61, 0x32, 0x76, 0x24, 0x30, 0x63, 0x8a, 0xdf,
        0x8f, 0x98, 0x89, 0xdb, 0xde, 0xcc, 0x8a, 0xca, 0x8f, 0xd8, 0xc2, 0x60, 0x30, 0x26, 0x31, 0x75,
        0x65, 0x26, 0x62, 0x74, 0x60, 0x62, 0x32, 0xcb, 0x9e, 0xdd, 0x8c, 0xdf, 0x9f, 0xc8, 0xce, 0xcf,
        0x8a, 0xd8, 0xcd, 0xa4, 0x75, 0x22, 0x64, 0x24, 0x35, 0x22, 0x63, 0x25, 0x34, 0x76, 0x24, 0x2e,
        0x8a, 0x89, 0x88, 0xcb, 0xcf, 0xdd, 0x8b, 0x9a, 0xde, 0x9c, 0x88, 0xcf, 0x74, 0x22, 0x75, 0x61,
        0x65, 0x76, 0x62, 0x71, 0x60, 0x22, 0x74, 0x24, 0x0e, 0x98, 0x9d, 0x9a, 0x9f, 0x9d, 0x8e, 0xcb,
        0xdb, 0x99, 0x98, 0x9a, 0x99, 0x76, 0x24, 0x35, 0x24, 0x26, 0x62, 0x70, 0x20, 0x27, 0x30, 0x65,
        0x65, 0xdd, 0x88, 0x9b, 0xce, 0x9c, 0x8e, 0xcf, 0xdb, 0x8c, 0xcc, 0xde, 0x9a, 0xd7, 0x74, 0x25,
        0x60, 0x37, 0x22, 0x34, 0x20, 0x67, 0x61, 0x65, 0x31, 0x70, 0xd9, 0xda, 0x9e, 0x8d, 0xce, 0xcf,
        0x8b, 0x9c, 0x98, 0xcf, 0x9a, 0xc8, 0xf0, 0x71, 0x24, 0x76, 0x63, 0x60, 0x30, 0x67, 0x74, 0x21,
        0x34, 0x32, 0x68, 0xdf, 0x8e, 0x98, 0xcf, 0x8b, 0x9e, 0xdc, 0xd9, 0x8a, 0x8f, 0x8c, 0x9a, 0x61,
        0x34, 0x37, 0x23, 0x35, 0x61, 0x27, 0x60, 0x25, 0x65, 0x23, 0x36, 0x1e, 0xdf, 0x98, 0xdb, 0x9f,
        0xca, 0xc8, 0x98, 0xdf, 0x9a, 0x88, 0xca, 0xd9, 0x35, 0x66, 0x66, 0x75, 0x30, 0x73, 0x34, 0x74,
        0x34, 0x22, 0x72, 0x61, 0xdb, 0x89, 0x9f, 0xca, 0x9e, 0xd9, 0xc9, 0x8b, 0xce, 0x89, 0x9a, 0xcb,
        0xc4, 0x67, 0x63, 0x64, 0x65, 0x22, 0x35, 0x31, 0x70, 0x23, 0x73, 0x64, 0x63, 0x99, 0xca, 0xca,
        0x8b, 0x98, 0x8d, 0x9b, 0x9b, 0x99, 0xca, 0xca, 0x8b, 0xe7
};

_DWORD rowMask[] = { 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0 };
_DWORD colMask[] = { 0xFFFFFFFF, 0, 1, 0, 0xFFFFFFFF, 0, 1, 0, 0xFFFFFFFF, 0, 1, 0, 0, 0, 0, 0 };

static char* __fastcall Init_maze(char** maze, int row, int col)
{
    int i; // [rsp+14h] [rbp-3Ch]
    int j; // [rsp+18h] [rbp-38h]
    int k; // [rsp+1Ch] [rbp-34h]

    for (i = 0; i <= 2; ++i)
        maze[row - 1][col - 1 + i] = Set_maze(encryptedMaze, rowMask[i] + row, colMask[i] + col);
    for (j = 4; j <= 6; ++j)
        maze[row][col - 1 + j - 4] = Set_maze(encryptedMaze, rowMask[j] + row, colMask[j] + col);
    for (k = 8; k <= 10 ; ++k)
        maze[row + 1][col - 1 + k - 8] = Set_maze(encryptedMaze, rowMask[k] + row, colMask[k] + col);
    return 0;
}

typedef struct _stPOS
{
    int x;
    int y;
} stPOS;

static BOOL NextW(const char** maze, stPOS start, stPOS end, char* path, int pathCnt);
static BOOL NextA(const char** maze, stPOS start, stPOS end, char* path, int pathCnt);
static BOOL NextS(const char** maze, stPOS start, stPOS end, char* path, int pathCnt);
static BOOL NextD(const char** maze, stPOS start, stPOS end, char* path, int pathCnt);

static BOOL NextW(const char** maze, stPOS start, stPOS end, char* path, int pathCnt)
{
    BOOL result = FALSE;
    path[pathCnt++] = 'w';
    start.x -= 1;
    if (start.x > 0 && maze[start.x - 1][start.y] != '1')
    {
        int ret = NextW(maze, start, end, path, pathCnt);
        result |= ret;
    }
    if (start.y > 0 && maze[start.x][start.y - 1] != '1')
    {
        int ret = NextA(maze, start, end, path, pathCnt);
        result |= ret;
    }
    if (start.y < end.y && maze[start.x][start.y + 1] != '1')
    {
        int ret = NextD(maze, start, end, path, pathCnt);
        result |= ret;
    }

    return FALSE;
}

static BOOL NextD(const char** maze, stPOS start, stPOS end, char* path, int pathCnt)
{
    BOOL result = FALSE;
    path[pathCnt++] = 'd';
    start.y += 1;
    if (start.x == end.x && start.y == end.y)
    {
        path[pathCnt] = 0;
        printf("path:%s\npathCnt:%d", path, pathCnt);
        return TRUE;
    }
    if (start.x > 0 && maze[start.x - 1][start.y] != '1')
    {
        int ret = NextW(maze, start, end, path, pathCnt);
        result |= ret;
    }
    if (start.x < end.x && maze[start.x + 1][start.y] != '1')
    {
        int ret = NextS(maze, start, end, path, pathCnt);
        result |= ret;
    }
    if (start.y < end.y && maze[start.x][start.y + 1] != '1')
    {
        int ret = NextD(maze, start, end, path, pathCnt);
        result |= ret;
    }
    return FALSE;
}

static BOOL NextA(const char** maze, stPOS start, stPOS end, char* path, int pathCnt)
{
    BOOL result = FALSE;
    path[pathCnt++] = 'a';
    start.y -= 1;

    if (start.x > 0 && maze[start.x - 1][start.y] != '1')
    {
        int ret = NextW(maze, start, end, path, pathCnt);
        result |= ret;
    }
    if (start.x < end.x && maze[start.x + 1][start.y] != '1')
    {
        int ret = NextS(maze, start, end, path, pathCnt);
        result |= ret;
    }
    if (start.y > 0 && maze[start.x][start.y - 1] != '1')
    {
        int ret = NextA(maze, start, end, path, pathCnt);
        result |= ret;
    }
    return FALSE;
}

static BOOL NextS(const char** maze, stPOS start, stPOS end, char* path, int pathCnt)
{
    BOOL result = FALSE;
    path[pathCnt++] = 's';
    start.x += 1;
    if (start.x == end.x && start.y == end.y)
    {
        path[pathCnt] = 0;
        printf("path:%s\npathCnt:%d", path, pathCnt);
        return TRUE;
    }
    if (start.x < end.x && maze[start.x + 1][start.y] != '1')
    {
        int ret = NextS(maze, start, end, path, pathCnt);
        result |= ret;
    }
    if (start.y > 0 && maze[start.x][start.y - 1] != '1')
    {
        int ret = NextA(maze, start, end, path, pathCnt);
        result |= ret;
    }
    if (start.y < end.y && maze[start.x][start.y + 1] != '1')
    {
        int ret = NextD(maze, start, end, path, pathCnt);
        result |= ret;
    }
    return FALSE;
}

static BOOL findPath(const char** maze, stPOS start, stPOS end, char* path, int pathCnt)
{
    BOOL result = FALSE;
    if (maze[start.x - 1][start.y] != '1')
    {
        int ret = NextW(maze, start, end, path, pathCnt);
        result |= ret;
    }
    if (maze[start.x + 1][start.y] != '1')
    {
        int ret = NextS(maze, start, end, path, pathCnt);
        result |= ret;
    }
    if (maze[start.x][start.y - 1] != '1')
    {
        int ret = NextA(maze, start, end, path, pathCnt);
        result |= ret;
    }
    if (maze[start.x][start.y + 1] != '1')
    {
        int ret = NextD(maze, start, end, path, pathCnt);
        result |= ret;
    }

    return 0;
}

int main(void)
{
    system("chcp 65001");
    char ** maze = (char**)malloc(99 * sizeof(char*));
    if (maze)
    {
        memset(maze, 0, 99 * sizeof(char*));
        for (int i = 0; i < 99; i++)
        {
            maze[i] = (char*)malloc(100);
            if (maze[i])
            {
                memset(maze[i], 48, 100);
                maze[i][99] = 0;
            }
        }
        for (int i = 1; i < 99; i = i + 3)
        {
            for (int j = 1; j < 99; j = j + 3)
            {
                Init_maze(maze, i, j);
            }
        }
        for (int i = 0; i < 99; i++)
            printf("%s\n", maze[i]);
        stPOS start = { 1, 1 };
        stPOS end = { 97, 97 };
        char path[97 * 97 + 1] = { 0 };
        int pathCnt = 0;
        findPath((const char**)maze, start, end, path, 0);
        for (int i = 0; i < 99; i++)
        {
            if (maze[i])
            {
                free(maze[i]);
                maze[i] = NULL;
            }
        }
        free(maze);
        maze = NULL;
    }
    return 0;
}

Python代码

另附一份python代码

import hashlib
import sys

# 加密的迷宫数据
encrypted_maze = [
    0x8b, 0x98, 0x8d, 0x9b, 0x9b, 0x99, 0xca, 0xca, 0x8b, 0x98, 0x8d, 0x9b, 0x94, 0x22, 0x74, 0x25,
    0x70, 0x26, 0x76, 0x64, 0x74, 0x72, 0x35, 0x75, 0x63, 0xcc, 0xd9, 0xce, 0x9a, 0xcd, 0xdb, 0x8a,
    0x8e, 0x9d, 0xcd, 0xcf, 0x9e, 0xb3, 0x20, 0x20, 0x34, 0x23, 0x62, 0x35, 0x60, 0x22, 0x61, 0x71,
    0x30, 0x3d, 0xc8, 0xde, 0xcf, 0x99, 0xcf, 0xce, 0xca, 0xd9, 0xc8, 0xcf, 0x9a, 0xdd, 0x24, 0x64,
    0x31, 0x26, 0x32, 0x35, 0x65, 0x72, 0x24, 0x20, 0x30, 0x36, 0x1d, 0xce, 0x8b, 0xcd, 0x9e, 0xcf,
    0xcb, 0xc9, 0x99, 0x8a, 0xcf, 0xcd, 0x99, 0x70, 0x25, 0x73, 0x37, 0x25, 0x34, 0x72, 0x64, 0x74,
    0x60, 0x72, 0x67, 0x8f, 0xca, 0x9c, 0xce, 0x9e, 0xdf, 0x99, 0x98, 0x9f, 0x8f, 0x8c, 0x9b, 0x84,
    0x30, 0x37, 0x32, 0x71, 0x35, 0x26, 0x24, 0x74, 0x25, 0x62, 0x26, 0x32, 0x8a, 0x8c, 0xca, 0xcf,
    0xdf, 0x8c, 0x8c, 0x8f, 0xce, 0x9c, 0x8f, 0xdf, 0xb0, 0x76, 0x22, 0x65, 0x75, 0x63, 0x31, 0x24,
    0x30, 0x23, 0x22, 0x21, 0x7b, 0x9c, 0xdf, 0xca, 0xdf, 0x89, 0xcc, 0xde, 0x8f, 0x89, 0x8a, 0xcb,
    0xcf, 0x66, 0x33, 0x34, 0x71, 0x77, 0x75, 0x61, 0x25, 0x26, 0x76, 0x64, 0x34, 0x08, 0x9b, 0xdf,
    0x8e, 0x9d, 0x9d, 0xde, 0xde, 0x8c, 0xda, 0x8a, 0x9e, 0x8a, 0x66, 0x25, 0x25, 0x23, 0x64, 0x31,
    0x25, 0x23, 0x33, 0x71, 0x65, 0x33, 0x9a, 0xda, 0x9b, 0xc9, 0xd8, 0x8a, 0xcf, 0x8d, 0xda, 0x9f,
    0xdb, 0x8d, 0xc6, 0x61, 0x60, 0x72, 0x65, 0x71, 0x21, 0x66, 0x37, 0x71, 0x30, 0x77, 0x23, 0xcf,
    0xda, 0x9c, 0xd9, 0x9e, 0x8e, 0x9d, 0xdf, 0xdf, 0xde, 0x9d, 0x8c, 0xb5, 0x30, 0x26, 0x70, 0x75,
    0x35, 0x26, 0x32, 0x35, 0x30, 0x27, 0x65, 0x6f, 0xde, 0xc8, 0x88, 0x8f, 0x9b, 0x99, 0x9e, 0xdb,
    0x9a, 0x99, 0x98, 0x8f, 0x71, 0x33, 0x25, 0x64, 0x30, 0x77, 0x37, 0x21, 0x71, 0x72, 0x24, 0x30,
    0x0f, 0xdc, 0xd8, 0x9e, 0x8a, 0xdc, 0xde, 0x8f, 0xda, 0xc9, 0xdc, 0x9b, 0xc9, 0x77, 0x20, 0x71,
    0x25, 0x76, 0x66, 0x20, 0x30, 0x23, 0x71, 0x25, 0x71, 0xdc, 0xc8, 0x8e, 0xdf, 0xc9, 0x8b, 0xce,
    0xcf, 0x89, 0xd9, 0x9b, 0xcb, 0xd7, 0x65, 0x70, 0x20, 0x23, 0x63, 0x61, 0x61, 0x63, 0x20, 0x31,
    0x61, 0x20, 0xd9, 0x9a, 0xde, 0xdd, 0xce, 0x9b, 0xcb, 0xd9, 0xdc, 0xdf, 0xdf, 0xcd, 0xf1, 0x24,
    0x60, 0x33, 0x72, 0x21, 0x74, 0x72, 0x61, 0x24, 0x31, 0x62, 0x29, 0x9e, 0xca, 0xdc, 0xca, 0xde,
    0xce, 0xdd, 0x98, 0x9b, 0xcf, 0xd9, 0x9e, 0x74, 0x65, 0x62, 0x32, 0x71, 0x70, 0x32, 0x64, 0x64,
    0x70, 0x27, 0x63, 0x0f, 0xdb, 0x88, 0x9a, 0xcf, 0xce, 0xdd, 0x98, 0xce, 0xcf, 0x98, 0xcf, 0xd8,
    0x65, 0x62, 0x27, 0x64, 0x20, 0x32, 0x70, 0x20, 0x21, 0x67, 0x22, 0x35, 0xdf, 0xc9, 0x9f, 0x8a,
    0xcb, 0x89, 0xcc, 0xcf, 0xce, 0xd9, 0x9f, 0xce, 0xc0, 0x73, 0x63, 0x30, 0x74, 0x22, 0x74, 0x60,
    0x61, 0x33, 0x76, 0x30, 0x22, 0xd8, 0xce, 0xdf, 0xcf, 0x8d, 0xdd, 0xce, 0x9e, 0xcd, 0x8a, 0xcf,
    0xcf, 0xb3, 0x62, 0x65, 0x60, 0x23, 0x61, 0x60, 0x34, 0x32, 0x77, 0x64, 0x70, 0x7c, 0x9f, 0xca,
    0x9b, 0x9d, 0xd8, 0x8e, 0xcb, 0x9c, 0x8a, 0x9a, 0x8a, 0x9c, 0x67, 0x74, 0x65, 0x76, 0x64, 0x64,
    0x71, 0x76, 0x23, 0x75, 0x60, 0x22, 0x4b, 0xcb, 0x8b, 0x89, 0x89, 0x8a, 0x9a, 0xcc, 0x9f, 0x9b,
    0x9e, 0x89, 0xce, 0x75, 0x74, 0x23, 0x24, 0x31, 0x65, 0x76, 0x67, 0x30, 0x75, 0x23, 0x24, 0x8b,
    0xdb, 0xdd, 0xdc, 0xde, 0x9a, 0xc9, 0xcb, 0x9b, 0x9b, 0x89, 0xdc, 0xd0, 0x71, 0x62, 0x71, 0x64,
    0x24, 0x76, 0x76, 0x75, 0x75, 0x63, 0x20, 0x23, 0x8f, 0xcc, 0xcc, 0x8e, 0xce, 0x99, 0xdb, 0x8e,
    0x9a, 0x9d, 0xdc, 0xca, 0xa5, 0x63, 0x21, 0x64, 0x21, 0x37, 0x66, 0x21, 0x21, 0x66, 0x71, 0x60,
    0x6a, 0xdc, 0x88, 0xce, 0x9e, 0xcd, 0xcf, 0xda, 0xda, 0xd8, 0x8d, 0x8e, 0x8b, 0x77, 0x35, 0x61,
    0x25, 0x32, 0x33, 0x20, 0x20, 0x36, 0x71, 0x21, 0x34, 0x08, 0xcd, 0x9e, 0x9e, 0xdc, 0xde, 0x9e,
    0x9e, 0x8c, 0xd8, 0xde, 0xdb, 0x8a, 0x74, 0x35, 0x35, 0x76, 0x33, 0x30, 0x61, 0x22, 0x31, 0x64,
    0x31, 0x62, 0xc9, 0x8b, 0x9b, 0xd9, 0x9a, 0xdf, 0xcf, 0xc9, 0x9d, 0x9f, 0xcb, 0xcc, 0x81, 0x74,
    0x30, 0x73, 0x62, 0x21, 0x70, 0x22, 0x64, 0x31, 0x60, 0x66, 0x24, 0xdf, 0xce, 0xdc, 0xde, 0xdf,
    0xcf, 0xdc, 0x9c, 0x8a, 0x9a, 0x99, 0xdb, 0xe5, 0x30, 0x36, 0x23, 0x60, 0x35, 0x77, 0x31, 0x20,
    0x30, 0x37, 0x33, 0x7f, 0x9f, 0xdd, 0xdf, 0xce, 0x8f, 0xdc, 0xcc, 0xda, 0xca, 0xcd, 0xde, 0x9a,
    0x65, 0x26, 0x37, 0x65, 0x25, 0x62, 0x24, 0x21, 0x60, 0x22, 0x33, 0x21, 0x1a, 0xc9, 0x9f, 0x8a,
    0xcf, 0xd8, 0x89, 0xca, 0x8a, 0x89, 0x9e, 0xda, 0xd8, 0x32, 0x66, 0x24, 0x20, 0x36, 0x74, 0x60,
    0x74, 0x26, 0x67, 0x60, 0x61, 0xcc, 0x9f, 0xda, 0x9f, 0xdd, 0x99, 0xce, 0xdb, 0x89, 0x9f, 0x8b,
    0x8b, 0xd3, 0x37, 0x21, 0x65, 0x66, 0x70, 0x64, 0x65, 0x63, 0x33, 0x34, 0x25, 0x60, 0xca, 0x9b,
    0xdb, 0x88, 0x8c, 0x8f, 0x9f, 0xd8, 0xda, 0x8e, 0x9f, 0x89, 0xb3, 0x60, 0x71, 0x62, 0x31, 0x71,
    0x34, 0x73, 0x32, 0x70, 0x21, 0x27, 0x2a, 0x8a, 0x8a, 0x89, 0x8c, 0xda, 0xca, 0xd8, 0x9a, 0xcb,
    0xce, 0xcc, 0x89, 0x70, 0x64, 0x77, 0x25, 0x71, 0x60, 0x33, 0x66, 0x74, 0x74, 0x33, 0x31, 0x5f,
    0xcb, 0x89, 0x9c, 0xdf, 0xdb, 0x8c, 0x8b, 0x8f, 0x8f, 0x8d, 0xcc, 0xd9, 0x30, 0x72, 0x64, 0x61,
    0x25, 0x62, 0x26, 0x75, 0x25, 0x77, 0x65, 0x24, 0xce, 0xdd, 0x98, 0x8e, 0xde, 0xc8, 0x8f, 0x8a,
    0x9b, 0xd9, 0x89, 0x9b, 0xd5, 0x22, 0x64, 0x70, 0x34, 0x33, 0x32, 0x20, 0x60, 0x62, 0x25, 0x75,
    0x72, 0xc8, 0xc8, 0x8a, 0xcb, 0x9d, 0xda, 0xce, 0xce, 0x98, 0xc8, 0x9f, 0x9a, 0xb3, 0x31, 0x24,
    0x70, 0x27, 0x32, 0x25, 0x75, 0x26, 0x31, 0x65, 0x30, 0x3d, 0xdd, 0x9a, 0x9a, 0x8d, 0xde, 0x8e,
    0xca, 0xc8, 0x8c, 0x9f, 0xde, 0xdd, 0x70, 0x35, 0x34, 0x22, 0x63, 0x70, 0x34, 0x33, 0x30, 0x25,
    0x30, 0x33, 0x1d, 0xcb, 0xdb, 0xd8, 0xce, 0x8f, 0xcf, 0x89, 0xdc, 0xca, 0x9f, 0xdc, 0x88, 0x24,
    0x64, 0x77, 0x32, 0x20, 0x30, 0x22, 0x21, 0x64, 0x24, 0x33, 0x27, 0xce, 0x8e, 0x99, 0xda, 0xce,
    0xca, 0xcd, 0x8d, 0xde, 0x8e, 0x9c, 0x8f, 0x80, 0x35, 0x27, 0x76, 0x75, 0x20, 0x73, 0x71, 0x31,
    0x25, 0x26, 0x63, 0x72, 0xdb, 0x88, 0x8b, 0xcf, 0xcf, 0xd8, 0xd9, 0xdb, 0xce, 0xcd, 0x8b, 0xdb,
    0xa4, 0x66, 0x66, 0x21, 0x74, 0x22, 0x24, 0x34, 0x61, 0x72, 0x26, 0x20, 0x3f, 0xd9, 0xca, 0x9b,
    0xcb, 0x9c, 0xc9, 0xdb, 0x8e, 0xc8, 0x9f, 0x9b, 0x9f, 0x73, 0x66, 0x20, 0x70, 0x67, 0x30, 0x25,
    0x25, 0x32, 0x66, 0x30, 0x61, 0x1c, 0x8f, 0x9e, 0x9a, 0xd9, 0xcd, 0xdf, 0x8e, 0x8d, 0x9b, 0xcf,
    0xcb, 0xcb, 0x36, 0x30, 0x25, 0x66, 0x61, 0x34, 0x61, 0x32, 0x76, 0x24, 0x30, 0x63, 0x8a, 0xdf,
    0x8f, 0x98, 0x89, 0xdb, 0xde, 0xcc, 0x8a, 0xca, 0x8f, 0xd8, 0xc2, 0x60, 0x30, 0x26, 0x31, 0x75,
    0x65, 0x26, 0x62, 0x74, 0x60, 0x62, 0x32, 0xcb, 0x9e, 0xdd, 0x8c, 0xdf, 0x9f, 0xc8, 0xce, 0xcf,
    0x8a, 0xd8, 0xcd, 0xa4, 0x75, 0x22, 0x64, 0x24, 0x35, 0x22, 0x63, 0x25, 0x34, 0x76, 0x24, 0x2e,
    0x8a, 0x89, 0x88, 0xcb, 0xcf, 0xdd, 0x8b, 0x9a, 0xde, 0x9c, 0x88, 0xcf, 0x74, 0x22, 0x75, 0x61,
    0x65, 0x76, 0x62, 0x71, 0x60, 0x22, 0x74, 0x24, 0x0e, 0x98, 0x9d, 0x9a, 0x9f, 0x9d, 0x8e, 0xcb,
    0xdb, 0x99, 0x98, 0x9a, 0x99, 0x76, 0x24, 0x35, 0x24, 0x26, 0x62, 0x70, 0x20, 0x27, 0x30, 0x65,
    0x65, 0xdd, 0x88, 0x9b, 0xce, 0x9c, 0x8e, 0xcf, 0xdb, 0x8c, 0xcc, 0xde, 0x9a, 0xd7, 0x74, 0x25,
    0x60, 0x37, 0x22, 0x34, 0x20, 0x67, 0x61, 0x65, 0x31, 0x70, 0xd9, 0xda, 0x9e, 0x8d, 0xce, 0xcf,
    0x8b, 0x9c, 0x98, 0xcf, 0x9a, 0xc8, 0xf0, 0x71, 0x24, 0x76, 0x63, 0x60, 0x30, 0x67, 0x74, 0x21,
    0x34, 0x32, 0x68, 0xdf, 0x8e, 0x98, 0xcf, 0x8b, 0x9e, 0xdc, 0xd9, 0x8a, 0x8f, 0x8c, 0x9a, 0x61,
    0x34, 0x37, 0x23, 0x35, 0x61, 0x27, 0x60, 0x25, 0x65, 0x23, 0x36, 0x1e, 0xdf, 0x98, 0xdb, 0x9f,
    0xca, 0xc8, 0x98, 0xdf, 0x9a, 0x88, 0xca, 0xd9, 0x35, 0x66, 0x66, 0x75, 0x30, 0x73, 0x34, 0x74,
    0x34, 0x22, 0x72, 0x61, 0xdb, 0x89, 0x9f, 0xca, 0x9e, 0xd9, 0xc9, 0x8b, 0xce, 0x89, 0x9a, 0xcb,
    0xc4, 0x67, 0x63, 0x64, 0x65, 0x22, 0x35, 0x31, 0x70, 0x23, 0x73, 0x64, 0x63, 0x99, 0xca, 0xca,
    0x8b, 0x98, 0x8d, 0x9b, 0x9b, 0x99, 0xca, 0xca, 0x8b, 0xe7
]

# 行和列的掩码
row_mask = [0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0]
col_mask = [0xFFFFFFFF, 0, 1, 0, 0xFFFFFFFF, 0, 1, 0, 0xFFFFFFFF, 0, 1, 0, 0, 0, 0, 0]

def decrypt_maze(encrypted_maze, real_pos):
    """解密迷宫数据"""
    key = "tgrddf55"
    return encrypted_maze[real_pos] ^ ord(key[real_pos % 8])

def calc_maze(encrypted_maze, row, col):
    """计算迷宫位置的值"""
    pos = (99 * row + col) // 8
    bit_index = (99 * row + col) % 8
    decrypted_byte = decrypt_maze(encrypted_maze, pos)
    return (decrypted_byte >> (7 - bit_index)) & 1

def set_maze(encrypted_maze, row, col):
    """根据计算结果设置迷宫字符"""
    val = calc_maze(encrypted_maze, row, col)
    if val == 0:
        return ' '
    elif val == 1:
        return '1'
    else:
        return 'e'

def init_maze(maze, row, col):
    """初始化迷宫区域"""
    # 第一行 (row-1)
    for i in range(3):
        maze[row - 1][col - 1 + i] = set_maze(encrypted_maze, (row_mask[i] + row) & 0xFFFFFFFF, (col_mask[i] + col) & 0xFFFFFFFF)

    # 第二行 (row)
    for j in range(4, 7):
        maze[row][col - 1 + j - 4] = set_maze(encrypted_maze, (row_mask[j] + row) & 0xFFFFFFFF, (col_mask[j] + col) & 0xFFFFFFFF)

    # 第三行 (row+1)
    for k in range(8, 11):
        maze[row + 1][col - 1 + k - 8] = set_maze(encrypted_maze, (row_mask[k] + row) & 0xFFFFFFFF, (col_mask[k] + col) & 0xFFFFFFFF)

def next_w(maze, startX, startY, endX, endY, path, path_cnt):
    """向上移动 (W)"""
    path[path_cnt] = 'w'
    path_str = ''.join(path)
    path_cnt += 1
    startX -= 1

    result = False
    if startX > 0 and maze[startX - 1][startY] != '1':
        result |= next_w(maze, startX, startY, endX, endY, path, path_cnt)
    if startY > 0 and maze[startX][startY - 1] != '1':
        result |= next_a(maze, startX, startY, endX, endY, path, path_cnt)
    if startY < endY and maze[startX][startY + 1] != '1':
        result |= next_d(maze, startX, startY, endX, endY, path, path_cnt)
    if not result:
        path[path_cnt] = ''
    return result

def next_d(maze, startX, startY, endX, endY, path, path_cnt):
    """向右移动 (D)"""
    path[path_cnt] = 'd'
    path_str = ''.join(path)
    path_cnt += 1
    startY += 1

    if startX == endX and startY == endY:
        path_str = ''.join(path)
        print(f"success path:{path_str}\npathCnt:{path_cnt}")
        print("flag{" + hashlib.md5(''.join(path).encode()).hexdigest() + "}")
        return True

    result = False
    if startX > 0 and maze[startX - 1][startY] != '1':
        result |= next_w(maze, startX, startY, endX, endY, path, path_cnt)
    if startX < endX and maze[startX + 1][startY] != '1':
        result |= next_s(maze, startX, startY, endX, endY,   path, path_cnt)
    if startY < endY and maze[startX][startY + 1] != '1':
        result |= next_d(maze, startX, startY, endX, endY, path, path_cnt)

    if not result:
        path[path_cnt] = ''
    return result

def next_a(maze, startX, startY, endX, endY, path, path_cnt):
    """向左移动 (A)"""
    path[path_cnt] = 'a'
    path_str = ''.join(path)
    path_cnt += 1
    startY -= 1

    result = False
    if startX > 0 and maze[startX - 1][startY] != '1':
        result |= next_w(maze, startX, startY, endX, endY, path, path_cnt)
    if startX < endX and maze[startX + 1][startY] != '1':
        result |= next_s(maze, startX, startY, endX, endY,   path, path_cnt)
    if startY > 0 and maze[startX][startY - 1] != '1':
        result |= next_a(maze, startX, startY, endX, endY, path, path_cnt)

    if not result:
        path[path_cnt] = ''
    return result

def next_s(maze, startX, startY, endX, endY, path, path_cnt):
    """向下移动 (S)"""
    path[path_cnt] = 's'
    path_str = ''.join(path)
    path_cnt += 1
    startX += 1

    if startX == endX and startY == endY:   
        path_str = ''.join(path)
        print(f"success path:{path_str}\npathCnt:{path_cnt}")
        print("flag:{" + hashlib.md5(''.join(path).encode()).hexdigest() + "}")
        return True

    result = False
    if startX < endX and maze[startX + 1][startY] != '1':
        result |= next_s(maze, startX, startY, endX, endY,   path, path_cnt)
    if startY > 0 and maze[startX][startY - 1] != '1':
        result |= next_a(maze, startX, startY, endX, endY, path, path_cnt)
    if startY < endY and maze[startX][startY + 1] != '1':
        result |= next_d(maze, startX, startY, endX, endY, path, path_cnt)

    if not result:
        path[path_cnt] = ''
    return result

def find_path(maze, startX, startY, endX, endY, path, path_cnt):
    """寻找迷宫路径"""
    result = False

    if maze[startX - 1][startY] != '1':
        result |= next_w(maze, startX, startY, endX, endY, path, path_cnt)
    if maze[startX + 1][startY] != '1':
        result |= next_s(maze, startX, startY, endX, endY, path, path_cnt)
    if maze[startX][startY - 1] != '1':
        result |= next_a(maze, startX, startY, endX, endY, path, path_cnt)
    if maze[startX][startY + 1] != '1':
        result |= next_d(maze, startX, startY, endX, endY, path, path_cnt)

    if not result:
        path[path_cnt] = ''
    return result

def main():
    """主函数"""
    # 创建99x100的迷宫
    maze = [['0' for _ in range(100)] for _ in range(99)]

    # 初始化迷宫
    for i in range(1, 99, 3):
        for j in range(1, 99, 3):
            init_maze(maze, i, j)

    # 打印迷宫
    for i in range(99):
        print(''.join(maze[i][:99]))  # 只打印前99列

    # 寻找路径
    startX = 1
    startY = 1
    endX = 97
    endY = 97

    path = [''] * 10000  # 假设路径长度不会超过1000

    find_path(maze, startX, startY, endX, endY, path, 0)

if __name__ == "__main__":
    print(f"{sys.getrecursionlimit()}")
    sys.setrecursionlimit(10 ** 5)
    print(f"{sys.getrecursionlimit()}")
    main()

发帖前要善用【论坛搜索】功能，那里可能会有你要找的答案或者已经有人发布过相同内容了，请勿重复发帖。
回复

举报

gaoxiaoao
沙发
gaoxiaoao 发表于 2026-4-11 09:06
技术过于先进，懵逼
【吾爱破解论坛总版规】 - [让你充分了解吾爱破解论坛行为规则]
回复

举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册[Register]

本版积分规则


免责声明：
吾爱破解所发布的一切破解补丁、注册机和注册信息及软件的解密分析文章仅限用于学习和研究目的；不得将上述内容用于商业或者非法用途，否则，一切后果请用户自负。本站信息来自网络，版权争议与本站无关。您必须在下载后的24个小时之内，从您的电脑中彻底删除上述内容。如果您喜欢该程序，请支持正版软件，购买注册，得到更好的正版服务。如有侵权请邮件与我们联系处理。

Mail To:Service@52pojie.cn

返回列表

RSS订阅|小黑屋|处罚记录|联系我们|吾爱破解 - 52pojie.cn ( 京ICP备16042023号 | 京公网安备 11010502030087号 )

GMT+8, 2026-4-13 01:15

Powered by Discuz!

Copyright © 2001-2020, Tencent Cloud.

快速回复 返回顶部 返回列表