攻防世界 easy_Maze

最新推荐文章于 2022-06-02 14:35:02 发布
最新推荐文章于 2022-06-02 14:35:02 发布
阅读量469 收藏 2
点赞数 1
分类专栏： CTF 文章标签： 算法 python 安全 安全架构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/P_Bloomberg/article/details/119706403
版权

工具：IDA、pwndbg

看到maze就知道又要走迷宫

静态分析

附件拖进IDA中分析主函数

int __cdecl main(int argc, const char **argv, const char **envp)
{
  __int64 v3; // rax
  int v5[52]; // [rsp+0h] [rbp-270h] BYREF
  int v6[52]; // [rsp+D0h] [rbp-1A0h] BYREF
  int v7[7]; // [rsp+1A0h] [rbp-D0h] BYREF
  int v8; // [rsp+1BCh] [rbp-B4h]
  int v9; // [rsp+1C0h] [rbp-B0h]
  int v10; // [rsp+1C4h] [rbp-ACh]
  int v11; // [rsp+1C8h] [rbp-A8h]
  int v12; // [rsp+1CCh] [rbp-A4h]
  int v13; // [rsp+1D0h] [rbp-A0h]
  int v14; // [rsp+1D4h] [rbp-9Ch]
  int v15; // [rsp+1D8h] [rbp-98h]
  int v16; // [rsp+1DCh] [rbp-94h]
  int v17; // [rsp+1E0h] [rbp-90h]
  int v18; // [rsp+1E4h] [rbp-8Ch]
  int v19; // [rsp+1E8h] [rbp-88h]
  int v20; // [rsp+1ECh] [rbp-84h]
  int v21; // [rsp+1F0h] [rbp-80h]
  int v22; // [rsp+1F4h] [rbp-7Ch]
  int v23; // [rsp+1F8h] [rbp-78h]
  int v24; // [rsp+1FCh] [rbp-74h]
  int v25; // [rsp+200h] [rbp-70h]
  int v26; // [rsp+204h] [rbp-6Ch]
  int v27; // [rsp+208h] [rbp-68h]
  int v28; // [rsp+20Ch] [rbp-64h]
  int v29; // [rsp+210h] [rbp-60h]
  int v30; // [rsp+214h] [rbp-5Ch]
  int v31; // [rsp+218h] [rbp-58h]
  int v32; // [rsp+21Ch] [rbp-54h]
  int v33; // [rsp+220h] [rbp-50h]
  int v34; // [rsp+224h] [rbp-4Ch]
  int v35; // [rsp+228h] [rbp-48h]
  int v36; // [rsp+22Ch] [rbp-44h]
  int v37; // [rsp+230h] [rbp-40h]
  int v38; // [rsp+234h] [rbp-3Ch]
  int v39; // [rsp+238h] [rbp-38h]
  int v40; // [rsp+23Ch] [rbp-34h]
  int v41; // [rsp+240h] [rbp-30h]
  int v42; // [rsp+244h] [rbp-2Ch]
  int v43; // [rsp+248h] [rbp-28h]
  int v44; // [rsp+24Ch] [rbp-24h]
  int v45; // [rsp+250h] [rbp-20h]
  int v46; // [rsp+254h] [rbp-1Ch]
  int v47; // [rsp+258h] [rbp-18h]
  int v48; // [rsp+25Ch] [rbp-14h]
  int v49; // [rsp+260h] [rbp-10h]

  v7[0] = 1;
  v7[1] = 1;
  v7[2] = -1;
  v7[3] = 1;
  v7[4] = -1;
  v7[5] = 1;
  v7[6] = -1;
  v8 = 0;
  v9 = 0;
  v10 = 0;
  v11 = 0;
  v12 = 1;
  v13 = -1;
  v14 = 0;
  v15 = 0;
  v16 = 1;
  v17 = 0;
  v18 = 0;
  v19 = 1;
  v20 = 0;
  v21 = -1;
  v22 = -1;
  v23 = 0;
  v24 = 1;
  v25 = 0;
  v26 = 1;
  v27 = -1;
  v28 = 0;
  v29 = -1;
  v30 = 0;
  v31 = 0;
  v32 = 0;
  v33 = 0;
  v34 = 0;
  v35 = 1;
  v36 = -1;
  v37 = -1;
  v38 = 1;
  v39 = -1;
  v40 = 0;
  v41 = -1;
  v42 = 2;
  v43 = 1;
  v44 = -1;
  v45 = 0;
  v46 = 0;
  v47 = -1;
  v48 = 1;
  v49 = 0;
  memset(v6, 0, 0xC0uLL);
  v6[48] = 0;
  memset(v5, 0, 0xC0uLL);
  v5[48] = 0;
  Step_0((int (*)[7])v7, 7, (int (*)[7])v6);
  Step_1((int (*)[7])v6, 7, (int (*)[7])v5);
  v3 = std::operator<<<std::char_traits<char>>(&_bss_start, "Please help me out!");
  std::ostream::operator<<(v3, &std::endl<char,std::char_traits<char>>);
  Step_2((int (*)[7])v5);
  system("pause");
  return 0;
}

前面定义了一大堆变量，直接看后面，有三个关键函数Step_0、Step_1、Step_2。

__int64 __fastcall Step_0(int (*a1)[7], int a2, int (*a3)[7])
{
  __int64 result; // rax
  int j; // [rsp+20h] [rbp-8h]
  unsigned int i; // [rsp+24h] [rbp-4h]

  for ( i = 0; ; ++i )
  {
    result = i;
    if ( (int)i >= a2 )
      break;
    for ( j = 0; j < a2; ++j )
      (*a3)[7 * i + j] = (*a1)[7 * j + a2 - i - 1];
  }
  return result;
}

函数Step_0是将数组v7做变换后的结果放在v6中

__int64 __fastcall Step_1(int (*a1)[7], int a2, int (*a3)[7])
{
  int v5[7]; // [rsp+20h] [rbp-D0h] BYREF
  int v6; // [rsp+E4h] [rbp-Ch]
  int j; // [rsp+E8h] [rbp-8h]
  int i; // [rsp+ECh] [rbp-4h]

  v6 = getA(a1, a2);
  if ( !v6 )
    return 0LL;
  getAStart(a1, a2, (int (*)[7])v5);
  for ( i = 0; i < a2; ++i )
  {
    for ( j = 0; j < a2; ++j )
      (*a3)[7 * i + j] = v5[7 * i + j] / v6;
  }
  return 1LL;
}

函数Step_1是将数组v7做变换后的结果放在v5中，

__int64 __fastcall Step_2(int (*a1)[7])
{
  int v1; // eax
  __int64 v2; // rax
  __int64 v3; // rax
  __int64 result; // rax
  __int64 v5; // rax
  char v6[35]; // [rsp+10h] [rbp-30h] BYREF
  char v7; // [rsp+33h] [rbp-Dh] BYREF
  int v8; // [rsp+34h] [rbp-Ch]
  int v9; // [rsp+38h] [rbp-8h]
  int v10; // [rsp+3Ch] [rbp-4h]

  v10 = 0;
  v9 = 0;
  v8 = 0;
  while ( v8 <= 29 && (*a1)[7 * v10 + v9] == 1 )
  {
    std::operator>><char,std::char_traits<char>>(&std::cin, &v7);
    v1 = v8++;
    v6[v1] = v7;
    if ( v7 == 100 )                            // 右 'd'
    {
      ++v9;
    }
    else if ( v7 > 100 )
    {
      if ( v7 == 115 )                          // 下 's'
      {
        ++v10;
      }
      else                                      // 上 'w'
      {
        if ( v7 != 119 )
          goto LABEL_14;
        --v10;
      }
    }
    else if ( v7 == 97 )                        // 左 'a'
    {
      --v9;
    }
    else
    {
LABEL_14:
      v2 = std::operator<<<std::char_traits<char>>(&_bss_start, "include illegal words.");
      std::ostream::operator<<(v2, &std::endl<char,std::char_traits<char>>);
    }
  }
  if ( v10 == 6 && v9 == 6 )
  {
    v3 = std::operator<<<std::char_traits<char>>(&_bss_start, "Congratulations!");
    std::ostream::operator<<(v3, &std::endl<char,std::char_traits<char>>);
    output(v6, v8);
    result = 1LL;
  }
  else
  {
    v5 = std::operator<<<std::char_traits<char>>(&_bss_start, "Oh no!,Please try again~~");
    std::ostream::operator<<(v5, &std::endl<char,std::char_traits<char>>);
    result = 0LL;
  }
  return result;
}

函数Step_2是游戏的过程，每输入一个字符，就要判断一次。根据传进来的参数是v5和7可知，迷宫的起点在v5[0]。

根据while循环体判断条件

v8 <= 29 && (*a1)[7 * v10 + v9] == 1

可知最多走30步，迷宫大小是7x7且v10控制着列，v9控制着行，只能走1的位置。

根据while循环体中的几个判断语句

    if ( v7 == 100 )                            // 右 'd'
    {
      ++v9;
    }
    else if ( v7 > 100 )
    {
      if ( v7 == 115 )                          // 下 's'
      {
        ++v10;
      }
      else                                      // 上 'w'
      {
        if ( v7 != 119 )
          goto LABEL_14;
        --v10;
      }
    }
    else if ( v7 == 97 )                        // 左 'a'
    {
      --v9;
    }

输入的字符只能是‘wsad’并且分别表示上下左右。

根据

if ( v10 == 6 && v9 == 6 )
  {
    v3 = std::operator<<<std::char_traits<char>>(&_bss_start, "Congratulations!");
    std::ostream::operator<<(v3, &std::endl<char,std::char_traits<char>>);
    output(v6, v8);
    result = 1LL;
  }

可知迷宫终点在v5[6*7+6=48]处。

动态调试

因为v5是迷宫路径，而生成v5的函数Step_0和Step_1太复杂，所以直接看函数的运行结果。

由main函数中v5的定义

int v5[52]; // [rsp+0h] [rbp-270h] BYREF

可知v5存放在函数栈中，rsp指向的位置。

在pwndbg中调试此文件

$ gdb easy_Maze
.......

在Step_1函数处打上断点

pwndbg> b Step_1
Breakpoint 1 at 0x1590

运行文件

pwndbg> r
.......

在这里插入图片描述

返回主函数

pwndbg> finish
.......

此时Step_1函数已经执行完成，查看v5的内容

  • x：查看内存
  • 49：49个单元
  • d：按照10进制查看
  • w：四个字节为一个单元（int）
  • $rsp：内存地址在rsp中

在这里插入图片描述

复制下来并以7*7的样式展示

maze = [
    1, 0, 0, 1, 1, 1, 1,
    1, 0, 1, 1, 0, 0, 1,
    1, 1, 1, 0, 1, 1, 1,
    0, 0, 0, 1, 1, 0, 0,
    1, 1, 1, 1, 0, 0, 0,
    1, 0, 0, 0, 1, 1, 1,
    1, 1, 1, 1, 1, 0, 1]

根据规则 只走1，一步一步走

得到ssddwdwdddssaasasaaassddddwdds

然后运行原来的文件走就能得到flag。

也可以查看函数，然后找到成功标志"Congratulations!"的位置

在这里插入图片描述

发现了UNCTF{}

所以最后的flag为UNCTF{ssddwdwdddssaasasaaassddddwdds}

蚁小剑
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
攻防世界逆向高手题之easy_Maze
沐一 · 林 的博客
09-01 795
攻防世界逆向高手题之easy_Maze 继续开启全栈梦想之逆向之旅~ 这题是攻防世界逆向高手题的easy_Maze
攻防世界easy_Maze做法(迷宫题)
最新发布
2303_80796023的博客
06-03 343
第一个是step_0函数，对数组v6进行了赋值，然后step_1函数调用参数v6给v5进行了赋值，那么显而易见，v5为最后的地图，但是我们发现，这地图用代码逆推出来太麻烦了，里面函数好多的，所以我们采用方法，ida的远程Linux调试，因为该文件不是exe文件，所以只能Linux远程调试，具体操作方法，点进我主页，一篇文章有详解，接下来，开始动调，断点打在函数step_2左边，关键点在这边，主要是三个函数，step_0，step_1,step_2，为了方便理解，先进入函数step_2。
easy_Maze 攻防世界
re1wn
04-28 1485
easy_Maze 攻防世界
攻防世界Reverse进阶区-easy_Maze-writeup
y4ung
12-04 717
1. 介绍 本题是xctf攻防世界中Reverse的进阶区的题easy_Maze 2. 分析 $ file easy_Maze easy_Maze: ELF 64-bit LSB pie executable, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, for GNU/Linux 3.2.0, BuildID[sha1]=0cb6db3836551a104de9a42d40
Re学习之攻防世界-easy_Maze
qq_43682582的博客
09-28 309
文章目录攻防世界-easy_Maze二、步骤总结 攻防世界-easy_Maze 示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。 二、步骤 查看文件类型，拖进Ubuntu，终端file命令 ida打开，找到main函数，F5查看伪代码，发现一共三个步骤 进入到Step_0() a3为主函数中的v7，a2=7，a1是主函数中的v9。继续分析代码，看的出来一共执行了49次，这说明了v9这个数组并不是如ida翻译的那样是个长度为7的数组，它后面的那些数据也应该是v9.
C_Simple_Maze.rar_SimpleMaze
09-20
在编程世界中，迷宫游戏是一种常见的练习项目，它能帮助开发者提升逻辑思维能力和算法设计能力。本文将深入探讨一个名为"C_Simple_Maze"的简单迷宫游戏项目，该程序用C语言编写，是初学者学习编程、尤其是学习数据...
maze_Grid.zip_Maze grid_迷宫
09-21
用计算机生成迷宫是一个很有趣的任务。我们可以用 ? 道路网格(Road Grid)? ? 来表示迷宫的道路,那么 3 x 3 的 ? 道路网格? ( ? 图 -1 左? )可以对应一个 7 x 7 的 ? 渲染网格(Render Grid)?...色的,道路是白色的)
c.rar_c 语言_maze game
09-25
标题 "c.rar_c 语言_maze game" 指示我们关注的是一个使用 C 语言编写的关于迷宫游戏的项目。描述中提到，“01迷宫，输入01矩阵的行和列，输出走出迷宫的路径数，递归实现”，这表明这个程序涉及到以下几个关键知识...
LARP_ MAIN_maze_
10-04
标题"LARP_ MAIN_maze_"和描述"Meanwhile"暗示了一个基于迷宫（maze）主题的活动或游戏，可能与Live Action Role-Playing (LARP)有关。LARP是一种角色扮演游戏，参与者扮演虚构角色，在现实世界中模拟游戏世界的事件...
MAZE_TEST.zip_Java中maze_maze_maze java 迷宫_maze stack java_迷宫 jav
09-24
一个用java写的迷宫小程序，能自动生成迷宫，并使用深度优先和广度优先算法解迷宫
攻防世界eazy_MazeWP
weixin_53622248的博客
12-27 141
题目来源:https://adworld.xctf.org.cn/task/answer?type=reverse&number=4&grade=1&id=5586&page=2攻防世界eazy_Maze 拖入IDA后发现直接进入main函数，根据题目名称，得知这是一道迷宫题。迷宫题一般要求你走一段程序中的迷宫，输入一般是路径。这道题逻辑很好猜，通过赋初值和step0,step1进行了迷宫的构造，然后进行输入，再通过step2来进行check。那么进入step2 可以发现我们
CTF逆向总结（二）
沐一 · 林 的博客
10-21 5881
CTF 逆向总结 非预期行为： 指解题中出现与预想结果不符合的一系列非预期行为，这基本说明了在中间或前面存在其他自己还没分析的操作。 不同系统的特殊数： 指解题中遇到考察特定位数系统中特定的数的真实值的时候，需要辨认出对应的值才能继续解题。如：32位系统中100000000就是0了 冗余中锁定关键代码： 从后往前看，就是确定比较关键对象，从该对象开始排除其他无关变量，一步步找出与该对象有关的其它变量，最后串起找到的所有相关变量，然后开始逆向分析。 题目类型总结： 题目描述
BUU逆向刷题记录 -01
m0_48432869的博客
05-18 216
easyre 查壳，64位，ida64打开 reverse1 查壳，64位，shift+f12查看字符串，交叉引用找到关键函数 注意有个把 'o’替换成’0’的处理过程。 reverse2 与reverse1类似。 内涵的软件 找到主函数，flag就在里面 新年快乐 查壳，有个upx的壳，用工具脱壳用用ida64载入 找到flag! helloworld android逆向，用android相关工具比如android killer、APKIDE、jadx打开在Mainactivity里面就可
基于卷积神经网络的图像分类
weixin_36670529的博客
06-02 8451
目录 一、常用的卷积神经网络概述 二、基础的神经网络 三、卷积神经网络 四、AlexNet 五、NiN 六、VGG 七、GoogleNet 1、Inception V1 2、Inception V2 3、Inception V3 4、Inception V4 八、ResNet 九、ResNeXt 十、性能比较 十一、CNN的设计准则 一、常用的卷积神经网络概述 ...
攻防世界--maze
weixin_30876945的博客
09-02 262
测试文件下载：https://adworld.xctf.org.cn/media/task/attachments/fa4c78d25eea4081864918803996e615 1.准备 获得信息 64位文件 2.IDA打开 选择main函数，反编译为C代码。 1 __int64 __fastcall main(__int64 a1, cha...
攻防世界Crypto Easy-one （无脑科普向
Gm1y's Blog
08-13 2001
Easy-one 做题思路： 题目说让我们破解msg002.enc的内容，然后给了msg001 和msg001.enc还有加密代码。我们要解密就要逆用这个加密算法，从msg001.enc解密就能得到msg001。注意代码里的k[]=“”是假的，本题需要我们利用msg001和msg001.enc去得到k，然后再用k代入解密算法解密msg002.enc才能得到flag。 思路讲了，有想法的就去试一下，...
maze
怪味巧克力的博客
06-02 255
0x01 拿到题目，放到IDA中静态分析，发现main函数中就是关键代码，如图： __int64 __fastcall main(__int64 a1, char **a2, char **a3) { const char *v3; // rsi signed __int64 v4; // rbx signed int v5; // eax char v6; // bp char v7; // al const char *v8; // rdi __int64 v10; //
“std::vector<std::vector<int>> &_maze”解释一下
04-10
"std::vector<std::vector<int>> &_maze" 是一个引用类型的变量，它是一个二维向量（vector）的引用。在C++中，std::vector是一个动态数组容器，可以存储多个元素，并且可以根据需要自动调整大小。 在这个特定的情况下，_maze是一个二维向量，其中每个元素都是int类型的值。可以将_maze看作是一个迷宫的表示，其中每个元素代表迷宫中的一个位置。int类型的值可以表示不同的状态，比如墙壁、通道、起点、终点等。 使用引用类型的变量可以避免对_maze进行复制，而是直接操作原始的二维向量。这样可以提高效率并减少内存消耗。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值