nssctf-reverse-[CISCN 2021初赛]babybc

原创 已于 2023-10-14 18:42:42 修改 · 441 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#网络安全 #学习 #笔记

于 2023-08-03 12:46:18 首次发布
文章讲述了如何处理.bc格式的LLVMIR位码文件，通过`clang`转换为可执行文件，然后用IDA反编译，解析fill_number和docheck函数，最终解出隐藏的数独并进行MD5加密获取flag。

babybc

.bc文件

下载附件后发现是.bc文件有点迷茫，网上查找资料后了解到.bc文件是LLVM Bitcode格式，Bitcode是LLVM IR的不可读二进制形式。

LLVM IR

在LLVM中，IR有三种表示，一种是可读的IR，类似于汇编代码，但其实它介于高等语言和汇编之间，这种表示就是给人看的，磁盘文件后缀为.ll；第二种是不可读的二进制IR，被称作位码（bitcode），磁盘文件后缀为.bc；第三种表示是一种内存格式，只保存在内存中，所以谈不上文件格式和文件后缀，这种格式是LLVM之所以编译快的一个原因，它不像gcc，每个阶段结束会生成一些中间过程文件，它编译的中间数据都是这第三种表示的IR。三种格式是完全等价的，我们可以在Clang/LLVM工具的参数中指定生成这些文件（默认不生成，对于非编译器开发人员来说，也没必要生成），可以通过llvm-as和llvm-dis来在前两种文件之间做转换。

（这是我看一位大佬的文章了解到的，附上链接： LLVM基本概念入门_P2Tree的博客-优快云博客）

writeup

查看文件类型发现是LLVM IR bitcode 的二进制文件，需要转换成可执行文件后再用IDA反编译。

使用命令：

clang baby.bc -o baby

将生成的可执行文件用IDA打开，查看main函数。

在这里插入图片描述

接着查看fill_number和docheck两个判断函数。

#fill_number
__int64 __fastcall fill_number(__int64 a1)
{
  char v2; // [rsp+1h] [rbp-69h]
  char v3; // [rsp+11h] [rbp-59h]
  char v4; // [rsp+21h] [rbp-49h]
  char v5; // [rsp+31h] [rbp-39h]
  char v6; // [rsp+40h] [rbp-2Ah]
  char v7; // [rsp+41h] [rbp-29h]
  __int64 v8; // [rsp+4Ah] [rbp-20h]
  __int64 v9; // [rsp+52h] [rbp-18h]
  __int64 v10; // [rsp+5Ah] [rbp-10h]

  v10 = 0LL;
  do
  {
    v9 = v10;
    v8 = 5 * v10;
    v7 = *(_BYTE *)(a1 + 5 * v10);
    if ( map[5 * v10] )
    {
      v6 = 0;
      if ( v7 != 48 )
        return v6 & 1;
    }
    else
    {
      map[5 * v10] = v7 - 48;
    }
    v5 = *(_BYTE *)(a1 + v8 + 1);
    if ( map[5 * v10 + 1] )
    {
      v6 = 0;
      if ( v5 != 48 )
        return v6 & 1;
    }
    else
    {
      map[5 * v10 + 1] = v5 - 48;
    }
    v4 = *(_BYTE *)(a1 + v8 + 2);
    if ( map[5 * v10 + 2] )
    {
      v6 = 0;
      if ( v4 != 48 )
        return v6 & 1;
    }
    else
    {
      map[5 * v10 + 2] = v4 - 48;
    }
    v3 = *(_BYTE *)(a1 + v8 + 3);
    if ( map[5 * v10 + 3] )
    {
      v6 = 0;
      if ( v3 != 48 )
        return v6 & 1;
    }
    else
    {
      map[5 * v10 + 3] = v3 - 48;
    }
    v2 = *(_BYTE *)(a1 + v8 + 4);
    if ( map[5 * v10 + 4] )
    {
      v6 = 0;
      if ( v2 != 48 )
        return v6 & 1;
    }
    else
    {
      map[5 * v10 + 4] = v2 - 48;
    }
    ++v10;
    v6 = 1;
  }
  while ( v9 + 1 < 5 );		// 5次循环,每次循环中检验一行的5个元素是否遵循
    			// (如果map数组中对应的位置不为空,我们输入的字符就必须为0,如果为空,那么就用我们输入字符-'0'之后填入对应位置)
    			//所以应该是要填写一个数独
  return v6 & 1;
}

五个字符一循环，分别判断其每一行的1~5位的数字。map[]不为0时，当前的输入字符必须是’0’；如果map[]为0，当前的map字符为输入字符的ASCII码减去48。

map[]是一个二维数组，查看它的值为：

0,0,0,0,0,
0,0,0,0,0,
0,4,0,0,0,
0,0,0,3,0,
0,0,0,0,0,

#docheck
__int64 docheck()
{
  char v1; // [rsp+2Eh] [rbp-9Ah]
  __int64 v2; // [rsp+30h] [rbp-98h]
  __int64 v3; // [rsp+40h] [rbp-88h]
  __int64 v4; // [rsp+50h] [rbp-78h]
  __int64 v5; // [rsp+58h] [rbp-70h]
  char *v6; // [rsp+68h] [rbp-60h]
  __int64 v7; // [rsp+70h] [rbp-58h]
  char v8; // [rsp+7Fh] [rbp-49h]
  char *v9; // [rsp+88h] [rbp-40h]
  __int64 v10; // [rsp+90h] [rbp-38h]
  __int64 v11; // [rsp+98h] [rbp-30h]
  __int64 v12; // [rsp+A8h] [rbp-20h]
  char v13[6]; // [rsp+BCh] [rbp-Ch] BYREF
  char v14[6]; // [rsp+C2h] [rbp-6h] BYREF

  v12 = 0LL;
  do
  {
    v10 = v12;
    memset(v14, 0, sizeof(v14));
    v9 = &v14[(unsigned __int8)map[5 * v12]];
    if ( *v9
      || (*v9 = 1, v14[(unsigned __int8)map[5 * v12 + 1]])
      || (v14[(unsigned __int8)map[5 * v12 + 1]] = 1, v14[(unsigned __int8)map[5 * v12 + 2]])
      || (v14[(unsigned __int8)map[5 * v12 + 2]] = 1, v14[(unsigned __int8)map[5 * v12 + 3]])
      || (v14[(unsigned __int8)map[5 * v12 + 3]] = 1, v14[(unsigned __int8)map[5 * v12 + 4]]) )
    {
      v8 = 0;
      return v8 & 1;
    }
    ++v12;
  }
  while ( v10 + 1 < 5 );
  v11 = 0LL;
  while ( 1 )
  {
    v7 = v11;
    memset(v13, 0, sizeof(v13));
    v6 = &v13[(unsigned __int8)map[v11]];
    if ( *v6 )
      break;
    *v6 = 1;
    if ( v13[(unsigned __int8)byte_405055[v11]] )
      break;
    v13[(unsigned __int8)byte_405055[v11]] = 1;
    if ( v13[(unsigned __int8)byte_40505A[v11]] )
      break;
    v13[(unsigned __int8)byte_40505A[v11]] = 1;
    if ( v13[(unsigned __int8)byte_40505F[v11]] )
      break;
    v13[(unsigned __int8)byte_40505F[v11]] = 1;
    if ( v13[(unsigned __int8)byte_405064[v11]] )
      break;
    ++v11;
    if ( v7 + 1 >= 5 )
    {
      v5 = 0LL;
      while ( 1 )
      {
        v4 = v5;
        if ( row[4 * v5] == 1 )
        {
          if ( (unsigned __int8)map[5 * v5] < (unsigned __int8)map[5 * v5 + 1] )
            goto LABEL_27;
        }
        else if ( row[4 * v5] == 2 && (unsigned __int8)map[5 * v5] > (unsigned __int8)map[5 * v5 + 1] )
        {
LABEL_27:
          v8 = 0;
          return v8 & 1;
        }
        if ( byte_405071[4 * v5] == 1 )
        {
          if ( (unsigned __int8)map[5 * v5 + 1] < (unsigned __int8)map[5 * v5 + 2] )
            goto LABEL_27;
        }
        else if ( byte_405071[4 * v5] == 2 && (unsigned __int8)map[5 * v5 + 1] > (unsigned __int8)map[5 * v5 + 2] )
        {
          goto LABEL_27;
        }
        if ( byte_405072[4 * v5] == 1 )
        {
          if ( (unsigned __int8)map[5 * v5 + 2] < (unsigned __int8)map[5 * v5 + 3] )
            goto LABEL_27;
        }
        else if ( byte_405072[4 * v5] == 2 && (unsigned __int8)map[5 * v5 + 2] > (unsigned __int8)map[5 * v5 + 3] )
        {
          goto LABEL_27;
        }
        if ( byte_405073[4 * v5] == 1 )
        {
          if ( (unsigned __int8)map[5 * v5 + 3] < (unsigned __int8)map[5 * v5 + 4] )
            goto LABEL_27;
        }
        else if ( byte_405073[4 * v5] == 2 && (unsigned __int8)map[5 * v5 + 3] > (unsigned __int8)map[5 * v5 + 4] )
        {
          goto LABEL_27;
        }
        ++v5;
        if ( v4 + 1 >= 5 )
        {
          v3 = 0LL;
          while ( 1 )
          {
            v2 = v3 + 1;
            if ( col[5 * v3] == 1 )
            {
              v1 = 0;
              if ( (unsigned __int8)map[5 * v3] > (unsigned __int8)map[5 * v2] )
                goto LABEL_26;
            }
            else if ( col[5 * v3] == 2 )
            {
              v1 = 0;
              if ( (unsigned __int8)map[5 * v3] < (unsigned __int8)map[5 * v2] )
              {
LABEL_26:
                v8 = v1;
                return v8 & 1;
              }
            }
            if ( byte_405091[5 * v3] == 1 )
            {
              v1 = 0;
              if ( (unsigned __int8)map[5 * v3 + 1] > (unsigned __int8)map[5 * v2 + 1] )
                goto LABEL_26;
            }
            else if ( byte_405091[5 * v3] == 2 )
            {
              v1 = 0;
              if ( (unsigned __int8)map[5 * v3 + 1] < (unsigned __int8)map[5 * v2 + 1] )
                goto LABEL_26;
            }
            if ( byte_405092[5 * v3] == 1 )
            {
              v1 = 0;
              if ( (unsigned __int8)map[5 * v3 + 2] > (unsigned __int8)map[5 * v2 + 2] )
                goto LABEL_26;
            }
            else if ( byte_405092[5 * v3] == 2 )
            {
              v1 = 0;
              if ( (unsigned __int8)map[5 * v3 + 2] < (unsigned __int8)map[5 * v2 + 2] )
                goto LABEL_26;
            }
            if ( byte_405093[5 * v3] == 1 )
            {
              v1 = 0;
              if ( (unsigned __int8)map[5 * v3 + 3] > (unsigned __int8)map[5 * v2 + 3] )
                goto LABEL_26;
            }
            else if ( byte_405093[5 * v3] == 2 )
            {
              v1 = 0;
              if ( (unsigned __int8)map[5 * v3 + 3] < (unsigned __int8)map[5 * v2 + 3] )
                goto LABEL_26;
            }
            if ( byte_405094[5 * v3] == 1 )
            {
              v1 = 0;
              if ( (unsigned __int8)map[5 * v3 + 4] > (unsigned __int8)map[5 * v2 + 4] )
                goto LABEL_26;
            }
            else if ( byte_405094[5 * v3] == 2 )
            {
              v1 = 0;
              if ( (unsigned __int8)map[5 * v3 + 4] < (unsigned __int8)map[5 * v2 + 4] )
                goto LABEL_26;
            }
            ++v3;
            v1 = 1;
            if ( v2 >= 4 )
              goto LABEL_26;
          }
        }
      }
    }
  }
  v8 = 0;
  return v8 & 1;
}

row:							col:
0 0 0 1							0 0 2 0 2
1 0 0 0							0 0 0 0 0
2 0 0 1							0 0 0 1 0
0 0 0 0							0 1 0 0 1
1 0 1 0

img

所以最后的数独图应该是这样的：

在这里插入图片描述

解出数独：

在这里插入图片描述

再将红色的4和3替换为0，最后得到输入字符串为：1425353142350212150442315

再对其进行MD5加密：

在这里插入图片描述

得到最后的flag为：NSSCTF{8a04b4597ad08b83211d3adfa1f61431}

L1ngYu-
关注
[使用Z3解方程组/数独][CISCN 2021初赛]babybc
yjh_fnu_ltn的博客
02-29 1231
3)、根据分析，提取出map，row，col三个数组后编写脚本，利用。第一个if来保证输入在字符"1"~"5"的范围内。发现其将输入的flag，每5个一组进行判断，上为1时，则要求map数组左边大于右边。上位2时，则要求map数组右边大于左边。上为1时，则要求map数组下面大于上面。上位2时，则要求map数组下面小于上面。时，要求输入的flag必须为 "0"。# 添加条件: 填的数字为1-5。# 添加条件: 一行中不能有相同。# 添加条件: 一列中不能有相同。# 添加条件: 有两个位置已知。
2021CISCN-Re-baby.bc
m0_51713041的博客
06-19 497
baby.bc 1. Ready 先判断其文件类型： [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-t7JSTYOi-1624085083834) 显然这个一个二进制的字节码文件,我们可以将它转化为.s的汇编文件，然后再转化成可执行文件拖入IDA进行分析 llc baby1.bc -o baby.s //得到IR汇编 as baby.s //转化为可执行文件 在对应文件夹中会出现一个a.out的可执行文件 2
【CISCN2021】第十四届全国大学生信息安全竞赛初赛-writeup
../../../../../../../
05-17 5006
这一次比赛分为三张“卷子”，我就直接归在一起吧 场景实操Misctiny trafficrunning_pixel Misc tiny traffic 打开流量包 根据文件和题目描述，我们直接导出http对象 可以看到，列表里面含有gzip和br文件，Gzip是一种压缩文件格式并且也是一个在类 Unix 上的一种文件解压缩的软件，BR文件是使用Brotli（一种开源数据压缩算法）压缩的文件 导出来后对这几个gzip和br文件解压缩，先看看flag_wrapper 并没有啥实质性的内容 看看test和se
linux命令
sdaujsj1的博客
03-20 518
cd usr //进入该文件夹内 mkdir xiepanpan//创建xiepanpan文件夹 pwd //显示所在的路径位置 echo Hello &amp;amp;gt;file1 //把echo 后的内容输入文件file1中，大于号表示输出，若文件存在直接输入到文件中，不存在 先创建文件再输入到文件中 echo world! &amp;amp;gt;file2 //同上 把world...
2021全国大学生信息安全竞赛初赛部分Write up
zhy_27的博客
05-21 1922
全国大学生信息安全竞赛初赛部分Write up 纯队友做出来的就不写了，只写一下我参与解题的。(不会WEB，不会PWN，我打个锤子的ctf) Misc tiny traffic 流量题，直接过滤http包，在末尾发现两个GET请求，分别获取了test和secret的br包。 使用python对br包进行解压，发现test是proto3的源码，secret是一串字节型数据。 <!-- /test.protp --> syntax = "proto3"; message PBResponse {
2023ciscn初赛reverse wp
DD5001的博客
02-18 1397
2023ciscn初赛reverse wp
【CTF题解NO.00009】CISCN2021-初赛-pwn write up by arttnba3
arttnba3的博客
05-21 933
【CTF题解NO.00009】CISCN2021-初赛-pwn write up by arttnba3[GITHUB BLOG ADDR](https://arttnba3.cn/2021/05/15/CTF-0X04-CISCN2021-PRELIMINARY/)0x00.绪论0x01.场景实操 开场卷pwny | Donelonelywolf | Donechannel0x02.场景实操 二阶卷silverwolf | Donegame0x03.场景实操 冲刺卷satool GITHUB BLOG A
[CISCN2021] 初赛 easy_source
fightte的博客
05-21 591
[CISCN2021] 初赛 easy_source 国赛，很有经历和意义，希望继续挑战 国赛和大家做的一道题，国赛比较难，只有现在有时间回过去看看： 进去后，界面大概如上图， 提示如上图： 猜测备份文件，实际上当时没扫描出来，试了.svn .swp .swo等，后来别个提示才发现： 实际上前面要加一个点，也就是.index.php.swo 现在看来应该去考虑php的原生类反序列化，是一个典型题目： 使用[反射类]new ReflectionClass("类名")，获得这个类的信息 参考：http
CISCN2021初赛WriteUp
Hellsegamosken
05-19 1228
第一次打 ctf，啥也没学，赛前一道题没做过，了解了下 IDA 的使用就上了。 glass 200 分 reverse，安卓逆向，.apk 改 .zip 解压，classes.dex 转 classes.jar 后打开，找到 MainActivity 开始读代码。 发现调用了 public native boolean checkFlag(String paramString); 这样一个函数，但这个函数并没有写出来。搜了一下 native 关键字，发现是用来调用本地 C 代码的。然后在 glass\li
全国大学生信息安全竞赛(CISCN)-reverse-复现（部分）
ookami6497的博客
06-06 1260
CISCN
ciscn2021 ctf线上赛baby.bc wp（#超详细，带逆向新手走过一个又一个小坑）
漫小牛的博客
05-17 2178
文章目录学习目标：引言第一步、分析文件类型1.可执行文件判断2.继续分析文件类型3.解决第一个坑-前奏4.reverse题的输入可能是什么？5.继续解决第一个坑第二步、明确分析的对象1.确定“开始干”的优先级2.LLVM环境及代码转换第四步、IDA静态分析1.main函数2.fill_number函数3.docheck函数第五步、数独的确定 学习目标： 1）不同ida版本的反编译差异； 2）进程创建和进程间通信； 3）upx壳和脱壳； 4）查看进程id； 5）gdb调试父子进程； 6）静态分析的方法； 7）
一文解读，网络安全行业人才需求情况《网络安全产业人才发展报告》
weixin_59086772的博客
10-18 8834
随着近几天国家网络安全宣传周在全国各地开展活动，网络安全再一次成为热门话题。网络安全不再缩在小小的安全圈子里，惠及面越来越广。不少对网络安全颇有兴趣的朋友非常关心行业前景如何？该怎么提升自我能力，更快地加入网安行列。 今天雨笋君就10月13日在网络安全宣传周上发布的《2021网络安全人才报告》进行一个简单的行业前景分析。 一、网络安全行业市场发展情况 网络时代生活越来越离不开网络，与此同时发生的网络安全攻击事件、非法入侵等等一系列事件都威胁着普通人的生活。没有网络安全保障，个人和企业等重.
【AI学习-comfyUI学习-第十二节-FLUX局部重绘工作流-各个部分学习-第十二节】
qq_22146161的博客
12-02 846
最近，学习comfyUI，这也是AI的一部分，想将相关学习到的东西尽可能记录下来。加载图像这就是上传的那张桥墩照片没问题这也算各一个开始吧，我也在学习摸索中。
【PCIe 总线及设备入门学习专栏 5.4 -- Linux EP driver iommu 与 DMA】
最新发布
CodingCos的博客
12-04 27
本文介绍了IOMMU在Linux系统中的应用场景及关键概念。IOMMU主要用于PCIe设备DMA访问时的地址转换(IOVA→PA)、提供安全隔离以及支持虚拟化场景。文章对比了启用/关闭IOMMU的差异，详细说明了IOVA的使用时机，并列举了内核态地址转换的相关API，包括虚拟地址转物理地址(virt_to_phys)、用户态地址转换(get_user_pages)以及IOMMU相关转换(iommu_iova_to_phys)。特别指出CPU访问BAR时不经过IOMMU，只有PCIe设备DMA时才需要IOMM
vite学习
qq_41549657的博客
12-04 447
核心优势极速开发启动：开发阶段不打包，直接让浏览器加载原生ESM,配合ebuild预购建第三方依赖，启动时间从webpack的秒级变为毫秒级热更新（HMR）快:只更新修改的模块，而非全量重建，大型项目热更新耗时<10ms按需编译：开发阶段仅编译当前请求的模块，而非全量打包内置对Typescript、JSX、CSS、静态资源的支持，无需复杂配置生产环境优化：基于Rollup打包，输出高度优化的静态资源，兼顾开发销量和生产性能<docs>Vite 处理.vue。
C++基础：Stanford CS106L学习笔记 1 类型与结构
WM2101的博客
12-02 319
本文介绍了C++的类型系统和结构体特性。在类型系统方面，C++采用静态类型，变量类型一旦确定不可更改，与Python的动态类型形成对比。静态类型能提高效率并减少运行时错误。文章还介绍了using类型别名、auto类型推断以及函数重载等现代类型特性。在结构体方面，展示了如何定义和使用结构体，以及使用std::pair模板简化多值返回的实现方式。通过对比Python和C++的代码示例，突出了C++在类型安全性和编译时检查方面的优势。
Lua学习记录（5） --- Lua中的协同程序 也称线程Coroutine的介绍
FAREWELL00075的博客
12-01 905
本文介绍了Lua中协程的基本概念和使用方法。主要内容包括：1）Lua协程需要通过创建、激活才能执行，不同于C#的自动执行；2）协程的两种创建方式（create和wrap）及其对应的调用方法；3）协程的四种状态（suspended、running、dead、normal）；4）协程可持续执行的特点，通过yield挂起和resume恢复实现分段执行。文章还比较了Lua与C#协程的区别，并提供了详细的代码示例说明协程的创建、调用和执行过程。
音视频开发方向从入门到商业落地详细学习线路
ZouZou的专栏
12-01 1046
本学习线路专为大学生设计，以“C/C++为根基、FFmpeg为核心工具”，从基础理论到工程实践再到商业落地，分三阶段递进，兼顾知识系统性与实战导向，全程抛开具体应用框架，聚焦音视频开发核心能力构建。
【Prompt学习技能树地图】LangChain原理及应用操作指南
致力于成为一名data scientist 的奋斗者
12-03 566
基础层主要解决两个核心问题：模型调用的统一化和数据存储的标准化。通过抽象接口设计，为上层应用提供了稳定、可预测的编程模型。表3.2：基础层核心组件概览组件类别核心功能解决的关键问题典型实现模型抽象统一模型调用接口屏蔽不同模型API差异存储抽象统一数据访问方式标准化各类存储系统操作文档处理多格式文档加载与转换统一文档处理流程PDF、HTML、Markdown解析接口规范定义标准化调用契约确保组件间兼容性BaseLLM、VectorStore接口。
掌握Emacs Org模式反向日期树插件org-reverse-datetree
资源摘要信息:"org-reverse-datetree是一个Emacs Org模式的扩展包，它允许用户生成一个反向的日期树，该树将文件按照日期逆序排列。在Org模式中，通常会按照时间顺序展示树形结构，最新的条目位于最顶端。然而，org-...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值