2022年深信服杯四川省大学生信息安全技术大赛-CTF-Reverse复现(部分)

news2025/7/12 15:10:19

Rush B

在这里插入图片描述

开始先设置一下数字以16进制格式显示

在这里插入图片描述
在这里插入图片描述

看主函数

__int64 __fastcall main(int a1, char **a2, char **a3)
{
  int v3; // eax
  size_t v4; // rax
  int v5; // ecx
  char v6; // al
  int v7; // ecx
  int v9; // [rsp+3Ch] [rbp-404h]
  char s[1000]; // [rsp+40h] [rbp-400h] BYREF
  char **v11; // [rsp+428h] [rbp-18h]
  int v12; // [rsp+434h] [rbp-Ch]
  unsigned int v13; // [rsp+438h] [rbp-8h]
  int v14; // [rsp+43Ch] [rbp-4h]

  v13 = 0;
  v12 = a1;
  v11 = a2;
  memset(s, 0, sizeof(s));
  v14 = v12;
  v9 = 0xC1C2064A;
  while ( 1 )
  {
    while ( 1 )
    {
      while ( v9 == 0x8EA211B0 )
      {
        v6 = sub_4005A0(v11[1]);
        v7 = 0xB732FD38;
        if ( v6 )
          v7 = 0x3C9B63CE;
        v9 = v7;
      }
      if ( v9 != 0x8FD5B3CA )
        break;
      v13 = 0;
      v9 = 0xA66258D6;
    }
    if ( v9 == 0xA66258D6 )
      break;
    switch ( v9 )
    {
      case 0xB732FD38:
        printf("RUSH AGAIN!\n");
        v13 = 1;
        v9 = 0xA66258D6;
        break;
      case 0xC1C2064A:
        v3 = 0xBCCA5E6;
        if ( v14 != 2 )
          v3 = 0xB732FD38;
        v9 = v3;
        break;
      case 0xBCCA5E6:
        v4 = strlen(v11[1]);
        v5 = 0x8EA211B0;
        if ( v4 != 0x44 )
          v5 = 0xB732FD38;
        v9 = v5;
        break;
      default:
        v9 = 0x8FD5B3CA;
        printf("Congratulations! You have rushed B! Flag is flag{md5(input)}...\n");
        break;
    }
  }
  return v13;
}

分析一下初始 v9 = 0xC1C2064A; ,那么执行的就是这一段,

 case 0xC1C2064A:
        v3 = 0xBCCA5E6;
        if ( v14 != 2 )
          v3 = 0xB732FD38;
        v9 = v3;
        break;

v9=0xB732FD38 就会退出,所以初始v14就要等于2

在这里插入图片描述

这里有个算字符串长度的,输入的字符串长度要等于68 ,v11[1]中存的是字符串指针的指针

 case 0xBCCA5E6:
        v4 = strlen(v11[1]);
        v5 = 0x8EA211B0;
        if ( v4 != 0x44 )
          v5 = 0xB732FD38;
        v9 = v5;
        break;

重点就是sub_4005A0这个函数

在这里插入图片描述

一坨的while循环

在这里插入图片描述

看到这个经典的判断语句

在这里插入图片描述

经典迷宫题

在这里插入图片描述

转到16进制窗口,先提取出来,18个数据一行,把地图画出来

在这里插入图片描述

初始点位为(1,1)

在这里插入图片描述

地图

00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 
00 01 02 0B 0A 0A 09 02 0B 08 03 0B 0A 0A 0A 0A 09 00 
00 06 09 05 03 08 06 09 05 03 0C 06 09 03 0A 09 04 00 
00 01 06 0C 05 03 0A 0C 06 0E 0A 08 07 0C 01 06 09 00 
00 07 0A 0B 0D 05 02 0B 0A 0A 0A 09 06 0A 0E 09 05 00 
00 06 08 05 04 06 0A 0C 03 0B 08 06 0A 09 03 0C 05 00 
00 03 09 06 0A 0A 0B 09 05 04 03 09 03 0C 04 03 0C 00 
00 05 06 0A 09 03 0C 05 06 09 05 05 05 03 09 06 09 00 
00 05 03 09 05 05 03 0C 03 0D 05 06 0C 05 05 03 0D 00 
00 05 05 04 06 0C 06 0A 0C 05 05 01 03 0D 06 0C 05 00 
00 05 07 0A 09 03 0B 0A 08 05 05 06 0C 07 09 01 05 00 
00 05 06 08 06 0C 06 0A 0A 0C 06 0A 09 04 05 07 0C 00 
00 05 03 0A 09 03 09 03 0A 0A 0B 08 05 03 0C 05 01 00 
00 05 05 01 05 05 06 0C 03 09 06 09 06 0C 01 06 0D 00 
00 05 06 0D 05 05 01 03 0D 06 08 07 0A 0A 0E 08 05 00 
00 07 08 05 06 0C 06 0C 05 03 0A 0C 03 09 03 09 05 00 
00 06 0A 0E 0A 0A 0A 0A 0C 06 0A 0A 0C 06 0C 06 1E 00 
00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00

判断路能不能走,v14一共有4种取值,0,1,2,3

在这里插入图片描述

可以先将成立的情况列出来,byte_602040[] 的取值为0x00 - 0x0E (唯一一个0x1E就是终点),

byte_602040[] 取值v14 取值
0x00没有v14的值满足条件
0x010
0x021
0x030, 1
0x042
0x050,2
0x061,2
0x070,1,2
0x083
0x090,3
0x0A1,3
0x0B0,1,3
0x0C2,3
0x0D0,2,3
0x0E1,2,3

结束条件,要让条件成立byte_602040[] 就得大于等于0x10,满足条件的只有一个0x1E

在这里插入图片描述

如果路可以走,就变化v16和v15的值,v16是行 ,v15是列

在这里插入图片描述

这玩意麻烦就麻烦在你能走的路径是会变的,先分析前几步理一下思路,我把循环层数标了下,一共14层循环。。。

__int64 __fastcall sub_4005A0(__int64 a1)
{
  unsigned int v1; // eax
  unsigned int v2; // eax
  unsigned int v3; // eax
  int v4; // eax
  int v5; // eax
  int v6; // eax
  unsigned int v7; // eax
  unsigned int v8; // eax
  int v9; // eax
  unsigned int v10; // eax
  unsigned int v12; // [rsp+68h] [rbp-20h]
  unsigned __int8 v13; // [rsp+6Ch] [rbp-1Ch]
  unsigned __int8 v14; // [rsp+6Dh] [rbp-1Bh]
  char v15; // [rsp+6Eh] [rbp-1Ah]
  char v16; // [rsp+6Fh] [rbp-19h]
  __int64 v17; // [rsp+70h] [rbp-18h]
  __int64 v18; // [rsp+78h] [rbp-10h]
  unsigned __int8 v19; // [rsp+83h] [rbp-5h]
  int v20; // [rsp+84h] [rbp-4h]

  v18 = a1;
  v17 = 0x1010000FFFF00LL;
  v16 = 1;
  v15 = 1;
  v13 = 0;
  v12 = 0x8CF907F5;
  while ( 1 )
  {                                             // 1 
    while ( 1 )
    {                                           // 2
      while ( 1 )
      {                                         // 3
        while ( 1 )
        {                                       // 4
          while ( 1 )
          {                                     // 5
            while ( 1 )
            {                                   // 6
              while ( 1 )
              {                                 // 7
                while ( 1 )
                {                               // 8
                  while ( 1 )
                  {                             // 9
                    while ( 1 )                 // 12
                    {                           // 10
                      while ( 1 )
                      {                         // 11
                        while ( 1 )
                        {                       // 12
                          while ( 1 )          
                          {    					 // 13
                            while ( v12 == 0x803BA95E )
                            {                   // 14
                              v19 = 0;
                              v12 = 0xF4078EB1;
                            }                   // 14
                            if ( v12 != 0x8CF907F5 )
                              break;
                            v1 = 0xABC759CB;
                            if ( v13 < 0x44u )
                              v1 = 0xD87E0B66;
                            v12 = v1;
                          }                     // 13
                          if ( v12 != 0x8DA6A494 )
                            break;
                          ++v13;                
                          v12 = 0x8CF907F5;
                        }						// 12
                        if ( v12 != 0x91BFBC64 )
                          break;
                        v14 = 1;
                        v12 = 0xBB25C497;
                      }							//11
                      if ( v12 != 0x97DCB23D )
                        break;
                      v10 = 0x52BAF199;
                      if ( (byte_602040[0x12 * v16 + v15] & 0x10) != 0 )
                        v10 = 0x9F36EED5;
                      v12 = v10;
                    }							//10
                    if ( v12 != 0x990181F1 )
                      break;
                    v14 = 3;
                    v12 = 0xBB25C497;
                  }								//9
                  if ( v12 != 0x9F36EED5 )
                    break;
                  v19 = 1;
                  v12 = 0xF4078EB1;
                }						//8
                if ( v12 != 0xABC759CB )
                  break;
                v19 = 0;
                v12 = 0xF4078EB1;
              }							//7
              if ( v12 != 0xB397B4AE )
                break;
              v4 = 0x4157602D;
              if ( v20 == 0x77 )
                v4 = 0x4D29FD46;
              v12 = v4;
            }							//6
            if ( v12 != 0xBB25C497 )
              break;
            v9 = 0x1C918C9E;
            if ( ((1 << v14) & byte_602040[0x12 * v16 + v15]) != 0 )
              v9 = 0x23EDBCE0;
            v12 = v9;
          }							//5
          if ( v12 != 0xC91BB3A3 )
            break;
          v2 = 0x2C1C4A6F;
          if ( v20 < 0x73 )
            v2 = 0xE7D58653;
          v12 = v2;
        }							//4
        if ( v12 != 0xD87E0B66 )
          break;
        v20 = *(char *)(v18 + v13);
        v12 = 0xC91BB3A3;
      }							//3
      if ( v12 != 0xE7D58653 )
        break;
      v6 = 0x3EE42C64;
      if ( v20 < 0x64 )
        v6 = 0x1BB52CB7;
      v12 = v6;
    }						//2
    if ( v12 == 0xF4078EB1 )
      break;
    switch ( v12 )
    {
      case 0x1BB52CB7u:
        v8 = 0x4157602D;
        if ( v20 == 0x61 )
          v8 = 0x990181F1;
        v12 = v8;
        break;
      case 0x1C918C9Eu:
        v19 = 0;
        v12 = 0xF4078EB1;
        break;
      case 0x23EDBCE0u:
        v16 += *((_BYTE *)&v17 + 2 * (3 - v14));
        v15 += *((_BYTE *)&v17 + 2 * (3 - v14) + 1);
        v12 = 0x97DCB23D;
        break;
      case 0x2C1C4A6Fu:
        v3 = 0xB397B4AE;
        if ( v20 < 0x77 )
          v3 = 0x4495DA98;
        v12 = v3;
        break;
      case 0x39324084u:
        v14 = 0;
        v12 = 0xBB25C497;
        break;
      case 0x3EE42C64u:
        v7 = 0x4157602D;
        if ( v20 == 0x64 )
          v7 = 0x91BFBC64;
        v12 = v7;
        break;
      case 0x4157602Du:
        v12 = 0x803BA95E;
        break;
      case 0x4495DA98u:
        v5 = 0x4157602D;
        if ( v20 == 0x73 )
          v5 = 0x39324084;
        v12 = v5;
        break;
      case 0x4D29FD46u:
        v14 = 2;
        v12 = 0xBB25C497;
        break;
      default:
        v12 = 0x8DA6A494;
        break;
    }
  }				//1
  return v19;
}

初始 v12 = 0x8CF907F5; ,执行到第13层循环, v12 = 0xD87E0B66

在这里插入图片描述

然后会一直跳出到第 3层循环, 取flag的第一个字符到v20中, v12 = 0xC91BB3A3

在这里插入图片描述

然后到第4层循环, 0x73 就是 ‘s’ , 盲猜wsad控制上下左右,先假设第一步往右走即 v20 < 0x73 ,v12 = 0xE7D58653

在这里插入图片描述

到第2层循环 ,0x64 就是 ‘d’v12=0x3EE42C64

在这里插入图片描述

到第1层循环, v12 = 0x91BFBC64

在这里插入图片描述

到第11层循环, v14 = 1 , v12 = 0xBB25C497

在这里插入图片描述

到第5层循环, 此时byte_602040 = 0x01,v14 = 1 很明显不满足条件, v12 = 0x1C918C9E

在这里插入图片描述

到第1层循环,v12 = 0xF4078EB1

在这里插入图片描述

再继续就直接退出循环了

在这里插入图片描述

然后可以假设第一步是 ‘s’ 的情况,此时 byte_602040 = 0x01,v14 = 0 可以满足条件

然后推出
‘w’ ,v14 = 2 ,
‘s’ ,v14 = 0
‘a’ ,v14 = 3
‘d’ ,v14 = 1

即 当v14 = 2 时,上一步一定是 w

简单的说就是根据当前位置来推断出下一步可以走哪几个位置

比如:
byte_602040 = 0x01 v14 = 0 ,即只能往下(s)走
然后下一步
byte_602040 = 0x06 v14可以取 1,2, 即可以往右(d)或者往上(w),因为这迷宫路径肯定也不能走重复的路径,也不能走死路,那么下一步只能往右走
下一步
byte_602040= 0x09 , v14可以取0,3,即可以往下(s)或者往左(a),0x00肯定不能走,所以也只能往下走

如此反复可以把路径画出来,大概是这样,这图是第一次画的可能有错,我画了两次,第二次忘存了,懒得再画了

在这里插入图片描述

最终路径:
sdsdwwdddsdsaassddwddddsddsassawwasssssddssdwdwwawwwdssdwdsssassdsss

然后flag就是把路径md5一下就行

在这里插入图片描述

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.coloradmin.cn/o/5594.html

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈,一经查实,立即删除!

相关文章

免杀技术(详细)

恶意软件 ● 病毒、木马、蠕虫、键盘记录、僵尸程序、流氓软件、勒索软件、广告程序 ● 在用户非资源的情况下执行安装 ● 出于某种恶意的目的&#xff1a;控制、窃取、勒索、偷窥、推送、攻击。。。。。 恶意程序最重要的防护手段 ● 杀毒软件 / 防病毒软件 ● 客户端 / 服…

c# .net MAUI基础篇 环境安装、新建项目、安卓模拟器安装、项目运行

c# .net MAUI基础篇 环境安装、新建项目、安卓模拟器安装、项目运行 免费教学视频地址由趣编程ACE老师提供&#xff1a; 1..NET MAUI优势及安装和创建_哔哩哔哩_bilibili 一、介绍 .NET 多平台应用 UI (.NET MAUI) 是一个跨平台框架&#xff0c;用于使用 C# 和 XAML 创建本机移…

【面经】之小鼠喝药问题

题目 现在有 10 只小白鼠和 1000 支药水&#xff0c;1000 支药水中有且仅有一支药水有毒&#xff0c;如果小白鼠喝下毒药&#xff0c;那么毒发的时间是两小时。 现在只给你两小时的时间&#xff0c;请问如何用这 10 只小白鼠测出哪支药水有毒&#xff1f;&#xff08;忽略小白…

【Java编程进阶】标识符和关键字

在学习Java程序设计基础的时候&#xff0c;主要有标识符&#xff0c;变量&#xff0c;数据类型&#xff0c;流程控制这些主要的内容。 推荐学习专栏&#xff1a;Java 编程进阶之路【从入门到精通】 文章目录1. 标识符2. 关键字1. 标识符 什么是标识符&#xff1f; 标识符是用…

linux下的PPPOE设置

1.打开终端 #sudo pppoeconf 进入配置,输入用户名和密码. 2.建立连接 #sudo pon dsl-provider 3.断开连接 #sudo poff dsl-provider Welcome to the ADSL client setup. First, I will run some checks on your system to make sure the PPPoE client is installed properly.…

The 2022 CCPC Guangzhou Onsite M. XOR Sum(数位dp 数位背包)

题目 给定n,m,k(0<n<1e15,0<m<1e12,1<k<18)&#xff0c; 求长度为k的数组a&#xff0c;ai为[0,m]的整数&#xff0c; 满足的方案数 答案对1e97取模 题解 第一反应想起了hdu3693&#xff0c;但比对了一下&#xff0c;感觉那个题难很多&#xff0c; 两年…

一看就会的Java方法

文章目录一、方法的定义和使用&#x1f351;1、为什么引入方法&#xff1f;&#x1f351;2、方法的定义&#x1f351;3、方法调用的执行过程&#x1f351;4、实参和形参的关系二、方法重载&#x1f351;1、为什么需要方法重载&#x1f351;2、方法重载的概念和特点&#x1f351…

四旋翼无人机学习第8节--OpenMV电路分析

这里写目录标题0 前言1 openmv优秀作品介绍2 stm32单片机原理图绘制3 stm32单片机外接电容分析3 stm32单片机外接电容绘制4 stm32单片机外接晶振分析5 stm32单片机外接晶振绘制6 stm32单片机复位电路分析7 stm32单片机复位电路设计0 前言 简单的说一下&#xff0c;openmv模块是…

微信小程序 | 吐血整理的日历及日程时间管理

&#x1f4cc;个人主页&#xff1a;个人主页 ​&#x1f9c0; 推荐专栏&#xff1a;小程序开发成神之路 --【这是一个为想要入门和进阶小程序开发专门开启的精品专栏&#xff01;从个人到商业的全套开发教程&#xff0c;实打实的干货分享&#xff0c;确定不来看看&#xff1f; …

关于宝宝过敏原检测的这几点,专家达成共识啦

随着传染病发病率的下降&#xff0c;儿童过敏性疾病的发病率逐年上升&#xff0c;引起了公众和医务人员的广泛关注。四川省妇幼保健医院检验科目前可进行过敏原检测。根据超敏反应的发生机制和临床特点&#xff0c;可分为四种类型。我们所谓的过敏原检查是特异性的IgE相关的Ⅰ超…

React源码之Fiber架构

对于Fiber我们可以理解为存储在内存中的Dom 对于React15在render阶段的reconcile是不可打断的&#xff0c;如果在操作大量的dom时&#xff0c;会存在卡顿&#xff0c;因为浏览器将所有的时间都交给了js引擎线程去执行&#xff0c;此时GUI渲染线程被阻塞&#xff0c;导致页面出现…

PyTorch搭建循环神经网络(RNN)进行文本分类、预测及损失分析(对不同国家的语言单词和姓氏进行分类,附源码和数据集)

需要源码和数据集请点赞关注收藏后评论区留言~~~ 下面我们将使用循环神经网络训练来自18种起源于不同语言的数千种姓氏&#xff0c;并根据拼写方式预测名称的来源。 一、数据准备和预处理 总共有18个txt文件&#xff0c;并且对它们进行预处理&#xff0c;输出如下 部分预处理…

Windows版Ros环境的搭建以及Rviz显示激光点云信息

安装步骤&#xff1a; 1.安装visual studio 2019-2022 2.安装ROS 3.创建ROS快捷终端 4.运行测试效果 一、安装Visual Studio 2022 需要利用vs编译ROS代码&#xff0c;所以需要安装Visual Studio 2022 这里注意要使用vs2022&#xff0c;ROS wiki给的教程是使用2019 1).使…

Python学习小组课程-课程大纲与Python开发环境安装

一、前言 注意&#xff1a;此为内部小组学习资料&#xff0c;非售卖品&#xff0c;仅供学习参考。 为提升项目落地的逻辑思维能力&#xff0c;以及通过自我创造工具来提升工作效率&#xff0c;特成立Python学习小组。计划每周花一个小时进行在线会议直播学习&#xff0c;面向…

力扣21 - 合并两个有序链表【归并排序思维】

链式铠甲——合体一、题目描述二、思路分析三、代码详解way1【不带头结点】way2【带头结点】四、整体代码展示【需要自取】方法一&#xff1a;不带哨兵位【无头结点】方法二&#xff1a;带哨兵位【有头结点】五、总结与提炼一、题目描述 原题传送门&#x1f6aa; 将两个升序链…

vs2019编译ffmpeg4.4为静态库或动态库

参考文章&#xff1a;vs2019编译ffmpeg源码为静态库动态库【完整步骤、亲测可行】 文章目录编译测试编译 直接把博主的项目下下来 我打开里面FFmpeg文件发现它貌似是4.4版本 然后照着他给的步骤执行命令 先找到vs2019的命令行工具 然后执行两个脚本 执行以上两个脚本后&…

快速排序和归并排序非递归的详解

在经过主页中《八大排序》&#xff08;下&#xff09;的学习&#xff0c;我们了解了快速排序和归并排序且都是递归的思想&#xff0c;但是如果递归的深度很深呢&#xff1f;这一节我们就引出用非递归的思想解决这个问题。&#x1f635;&#x1f635;&#x1f635; 快速排序非递…

根据给定数组,创建形状相同的数组并且采用不同方式填充full_like()

【小白从小学Python、C、Java】 【计算机等级考试500强双证书】 【Python-数据分析】 根据给定数组&#xff0c;创建形状相同的数组 并且采用不同方式填充 full_like() [太阳]选择题 对下面代码中full_like函数结果描述错误的选项为&#xff1f; import numpy as np print(&q…

谷粒学院——Day05【后台系统前端项目创建、讲师管理模块前端开发】

后台系统前端项目创建 一、vue-element-admin 简介 vue-element-admin 是基于 element-ui 的一套后台管理系统集成方案。 功能&#xff1a;https://panjiachen.github.io/vue-element-admin-site/zh/guide/#功能 GitHub地址&#xff1a;https://github.com/PanJiaChen/vue-ele…

分布式锁_Redis分布式锁+Redisson分布式锁+Zookeeper分布式锁+Mysql分布式锁(原版)

分布式锁_Redis分布式锁Redisson分布式锁Zookeeper分布式锁Mysql分布式锁&#xff08;原版&#xff09; 文章目录分布式锁_Redis分布式锁Redisson分布式锁Zookeeper分布式锁Mysql分布式锁&#xff08;原版&#xff09;1. 传统锁回顾1.1. 从减库存聊起1.2. 环境准备1.3. 简单实现…