2021年CISCN初赛re

最新推荐文章于 2024-06-10 18:26:28 发布
最新推荐文章于 2024-06-10 18:26:28 发布
阅读量6.3k 收藏 1
点赞数 1
CC 4.0 BY-SA版权
分类专栏： ctf
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/CSNN2019/article/details/117192531

文章目录

glass.apk

直接分析jni的函数：

在这里插入图片描述
这里的话，三个有用函数，第一个sub_FFC((int)&v7, (int)&v6, v4);是RC4算法初始化函数，第二个sub_1088((int)&v7, v3, 39);RC4算法加密函数，第三个sub_10D4((int)v3, 39, (int)&v6, v4);进行一番异或操作，也就是说，只需要分析第三个函数即可。前面的两个函数直接用工具

 for ( i = 0; i < a2; i += 3 )
  {
    v5 = result + i;
    v6 = *(_BYTE *)(result + i + 2);
    v7 = *(_BYTE *)(result + i + 1);
    v8 = *(_BYTE *)(result + i) ^ v6;
    *(_BYTE *)(result + i) = v8;
    *(_BYTE *)(v5 + 2) = v6 ^ v7;
    *(_BYTE *)(v5 + 1) = v7 ^ v8;
  }
  for ( j = 0; j < a2; j += a4 )
  {
    for ( k = 0; (a4 & ~(a4 >> 31)) != k && j + k < a2; ++k )
      *(_BYTE *)(result + k) ^= *(_BYTE *)(a3 + k);
    result += a4;
  }

baby.bc

.bc转换为可执行程序

第一次拿到.bc的文件
在这里插入图片描述
查了一下，LLVM IR bitcode，二进制文件。想办法转换成.s，然后再转成可执行文件。（windows里面无法转成elf，最后编译成elf时，需要在linux里面进行
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
由此看出input长度为25；数组元素大小可取 0 ~ 5

fill_number(__int64)input)

v1 = (char *)(a1 + 4);
  v2 = 0LL;
  do
  {
    v3 = *(v1 - 4);
    if ( map[5 * v2] )
    {
      if ( v3 != 48 )
        return 0;
    }
    else
    {
      map[5 * v2] = v3 - 48;
    }
    v4 = *(v1 - 3);
    if ( byte_601051[5 * v2] )
    {
      if ( v4 != 48 )
        return 0;
    }
    else
    {
      byte_601051[5 * v2] = v4 - 48;
    }
    v5 = *(v1 - 2);
    if ( byte_601052[5 * v2] )
    {
      if ( v5 != 48 )
        return 0;
    }
    else
    {
      byte_601052[5 * v2] = v5 - 48;
    }
    v6 = *(v1 - 1);
    if ( byte_601053[5 * v2] )
    {
      if ( v6 != 48 )
        return 0;
    }
    else
    {
      byte_601053[5 * v2] = v6 - 48;
    }
    v7 = *v1;
    if ( byte_601054[5 * v2] )
    {
      if ( v7 != 48 )
        return 0;
    }
    else
    {
      byte_601054[5 * v2] = v7 - 48;
    }
    ++v2;
    v1 += 5;
  }
  while ( v2 < 5 );
  return 1;
}

unsigned char map[] =
{
    0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
    0,   0,   4,   0,   0,   0,   0,   0,   3,   0, 
    0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
    0,   0,   0,   0,   0,   1,   1,   0,   0,   0, 
    2,   0,   0,   1,   0,   0,   0,   0,   1,   0, 
    1,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
    0,   0,   0,   0
};

这个函数的作用也正如函数名所述，用来填充map数组中的0

 if ( map[5 * v2] )
    {
      if ( v3 != '0' )
        return 0;
    }
    else
    {
      map[5 * v2] = v3 - 48;
    }

map的起始地址是0x601050， 这个也就是如果map元素为0，那么就是用v3来做相应填充，而这里的v3也就是我们所做的input。else中减掉48，是想把字符元素转换为数字元素，然后赋值于map数组

 if ( v3 != '0' )
    return 0;

这里按照逻辑我觉得是当map中的元素不为0时，那么就来判断input相应输入位置，input这个输入位置必须为字符0，否则退出

docheck(input, input)：z3约束

	v25 = 0;
    v24 = 0;
    v1 = (unsigned __int8)map[5 * v0];
    if ( *((_BYTE *)&v24 + v1) )
      break;
    *((_BYTE *)&v24 + v1) = 1;
    v2 = (unsigned __int8)byte_601051[5 * v0];
    if ( *((_BYTE *)&v24 + v2) )
      break;
    *((_BYTE *)&v24 + v2) = 1;
    v3 = (unsigned __int8)byte_601052[5 * v0];
    if ( *((_BYTE *)&v24 + v3) )
      break;
    *((_BYTE *)&v24 + v3) = 1;
    v4 = (unsigned __int8)byte_601053[5 * v0];
    if ( *((_BYTE *)&v24 + v4) )
      break;
    *((_BYTE *)&v24 + v4) = 1;
    if ( *((_BYTE *)&v24 + (unsigned __int8)byte_601054[5 * v0]) )
      break;

这里刚开始我也没看出有什么用，一调试才知道。这里的作用也就是把它所以的元素连续的五个分成五个一组，然后判断这组值中不能出现两两重复。

		v23 = 0;
        v22 = 0;
        v6 = (unsigned __int8)map[v5];
        if ( *((_BYTE *)&v22 + v6) )
          break;
        *((_BYTE *)&v22 + v6) = 1;
        v7 = (unsigned __int8)byte_601055[v5];
        if ( *((_BYTE *)&v22 + v7) )
          break;
        *((_BYTE *)&v22 + v7) = 1;
        v8 = (unsigned __int8)byte_60105A[v5];
        if ( *((_BYTE *)&v22 + v8) )
          break;
        *((_BYTE *)&v22 + v8) = 1;
        v9 = (unsigned __int8)byte_60105F[v5];
        if ( *((_BYTE *)&v22 + v9) )
          break;
        *((_BYTE *)&v22 + v9) = 1;
        if ( *((_BYTE *)&v22 + (unsigned __int8)byte_601064[v5]) )
          break;

这里的话，也就是把连续的五个元素分成一组，总共有五组，每组有五个元素，然后每组同时选出一个相同下标的元素，判断五个组所选出的五个元素不能两两重复。

unsigned char row[] =
{
    0,   0,   0,   1,   1,   0,   0,   0,   2,   0, 
    0,   1,   0,   0,   0,   0,   1,   0,   1,   0, 
    0,   0,   0,   0,   0
};

			v11 = row[4 * v10];
            if ( v11 == 2 )
            {
              if ( (unsigned __int8)map[5 * v10] > (unsigned __int8)byte_601051[5 * v10] )
                return 0;
            }
            else if ( v11 == 1 && (unsigned __int8)map[5 * v10] < (unsigned __int8)byte_601051[5 * v10] )
            {
              return 0;
            }
            v12 = byte_601071[4 * v10];
            if ( v12 == 1 )
            {
              if ( (unsigned __int8)byte_601051[5 * v10] < (unsigned __int8)byte_601052[5 * v10] )
                return 0;
            }
            else if ( v12 == 2 && (unsigned __int8)byte_601051[5 * v10] > (unsigned __int8)byte_601052[5 * v10] )
            {
              return 0;
            }
            v13 = byte_601072[4 * v10];
            if ( v13 == 2 )
            {
              if ( (unsigned __int8)byte_601052[5 * v10] > (unsigned __int8)byte_601053[5 * v10] )
                return 0;
            }
            else if ( v13 == 1 && (unsigned __int8)byte_601052[5 * v10] < (unsigned __int8)byte_601053[5 * v10] )
            {
              return 0;
            }
            v14 = byte_601073[4 * v10];
            if ( v14 == 2 )
            {
              if ( (unsigned __int8)byte_601053[5 * v10] > (unsigned __int8)byte_601054[5 * v10] )
                return 0;
            }
            else if ( v14 == 1 && (unsigned __int8)byte_601053[5 * v10] < (unsigned __int8)byte_601054[5 * v10] )
            {
              return 0;
            }

这里的话，把map数组照样分成五组，连续的五个元素为一组，然后把row作为4个元素为一组（5个元素，相邻两个相比较，只需要比较四次)，因为input长度为25，所以map也就是25，map分小组可以分为5组，那么row也就可以分为5组：

  1. row第1组的第四个元素为1；
 else if ( v14 == 1 && (unsigned __int8)byte_601053[5 * v10] < (unsigned __int8)byte_601054[5 * v10] )
            {
              return 0;
            }

这是第一组，也就代表了map[3]>map[4]；

  1. row第2组的第一个元素为1；
 else if ( v11 == 1 && (unsigned __int8)map[5 * v10] < (unsigned __int8)byte_601051[5 * v10] )
            {
              return 0;
            }

这是第二组，也就代表了map[5]>map[6]；

  1. row第3组的第一个元素为2；第四个元素为1
 if ( v11 == 2 )
            {
              if ( (unsigned __int8)map[5 * v10] > (unsigned __int8)byte_601051[5 * v10] )
                return 0;
            }



 else if ( v14 == 1 && (unsigned __int8)byte_601053[5 * v10] < (unsigned __int8)byte_601054[5 * v10] )
            {
              return 0;
            }

这是第三组，也就代表了map[10]<map[11]；map[13]>map[14]

  1. row第5组的第一个元素为1；第三个元素为1
 else if ( v11 == 1 && (unsigned __int8)map[5 * v10] < (unsigned __int8)byte_601051[5 * v10] )
            {
              return 0;
            }

 else if ( v13 == 1 && (unsigned __int8)byte_601052[5 * v10] < (unsigned __int8)byte_601053[5 * v10] )
            {
              return 0;
            }

这是第五组，也就代表了map[20]>map[21]；map[22]>map[23]

row[]约束总结为：

map[3]>map[4]；
map[5]>map[6]；
map[10]<map[11]；map[13]>map[14]；
map[20]>map[21]；map[22]>map[23]

unsigned char col[] =
{
  0, 0, 2, 0, 2, 0, 0, 0, 0, 0, 
  0, 0, 0, 1, 0, 0, 1, 0, 0, 1
};

				v17 = col[5 * v15];
                if ( v17 == 2 )
                {
                  if ( (unsigned __int8)map[5 * v15] < (unsigned __int8)byte_601055[5 * v15] )
                    return 0;
                }
                else if ( v17 == 1 && (unsigned __int8)map[5 * v15] > (unsigned __int8)byte_601055[5 * v15] )
                {
                  return 0;
                }
                v18 = byte_601091[5 * v15];
                if ( v18 == 1 )
                {
                  if ( (unsigned __int8)byte_601051[5 * v15] > (unsigned __int8)byte_601056[5 * v15] )
                    return 0;
                }
                else if ( v18 == 2 && (unsigned __int8)byte_601051[5 * v15] < (unsigned __int8)byte_601056[5 * v15] )
                {
                  return 0;
                }
                v19 = byte_601092[5 * v15];
                if ( v19 == 2 )
                {
                  if ( (unsigned __int8)byte_601052[5 * v15] < (unsigned __int8)byte_601057[5 * v15] )
                    return 0;
                }
                else if ( v19 == 1 && (unsigned __int8)byte_601052[5 * v15] > (unsigned __int8)byte_601057[5 * v15] )
                {
                  return 0;
                }
                v20 = byte_601093[5 * v15];
                if ( v20 == 2 )
                {
                  if ( (unsigned __int8)byte_601053[5 * v15] < (unsigned __int8)byte_601058[5 * v15] )
                    return 0;
                }
                else if ( v20 == 1 && (unsigned __int8)byte_601053[5 * v15] > (unsigned __int8)byte_601058[5 * v15] )
                {
                  return 0;
                }
                v21 = byte_601094[5 * v15];
                if ( v21 == 2 )
                {
                  if ( (unsigned __int8)byte_601054[5 * v15] < (unsigned __int8)byte_601059[5 * v15] )
                    return 0;
                }
                else if ( v21 == 1 && (unsigned __int8)byte_601054[5 * v15] > (unsigned __int8)byte_601059[5 * v15] )
                {
                  return 0;
                }

这里的话，把map数组照样分成五组，连续的五个元素为一组，然后把col作为5个元素为一组（5个元素，分别和对应组相比较，需要比5次)，因为input长度为25，所以map也就是25，map分小组可以分为5组，五组之间，对应元素比较，只需要比4次，那么col也就可以分为4组，每组5个元素：

  1. col第一组的第三个元素为2；第五个元素为2
if ( v19 == 2 )
                {
                  if ( (unsigned __int8)byte_601052[5 * v15] < (unsigned __int8)byte_601057[5 * v15] )
                    return 0;
                }

if ( v21 == 2 )
                {
                  if ( (unsigned __int8)byte_601054[5 * v15] < (unsigned __int8)byte_601059[5 * v15] )
                    return 0;
                }

这是第一组，也就代表了map[2]>map[7]；map[4]>map[9]

  1. col第三组的第四个元素为1；
 i else if ( v20 == 1 && (unsigned __int8)byte_601053[5 * v15] > (unsigned __int8)byte_601058[5 * v15] )
                {
                  return 0;
                }

这是第三组，也就代表了map[13]<map[18]；

  1. col第4组的第二个元素为1；第五个元素为1
 if ( v18 == 1 )
                {
                  if ( (unsigned __int8)byte_601051[5 * v15] > (unsigned __int8)byte_601056[5 * v15] )
                    return 0;
                }
                
else if ( v21 == 1 && (unsigned __int8)byte_601054[5 * v15] > (unsigned __int8)byte_601059[5 * v15] )
                {
                  return 0;
                }

这是第三组，也就代表了map[16]<map[21]；map[19]<map[24]

col[]约束总结为：

map[2]>map[7]；map[4]>map[9]
map[13]<map[18]；
map[16]<map[21]；map[19]<map[24]
2021-CISCN-线上-misc-robot
zji
05-16 675
2021-CISCN-misc-robot 一、robot 示例：这个题主要是描述是，通过分析流量pcap和机器控制，看看给机器人发生了什么指令。 flag提示md5(指令) 格式CSICN 知识点 流量包查看+TCP跟踪流+导出内容+图像点坐标画图 解题 这玩意什么都看不出来啊 看看流量包 wireshark 跟踪流 想想如果把坐标值提取出来 我们导出文档txt 然后我们在提取坐标点 import re f = open('1.txt') s=f.read() #print(strs) r
2021全国大学生信息安全竞赛初赛部分Write up
zhy_27的博客
05-21 1875
全国大学生信息安全竞赛初赛部分Write up 纯队友做出来的就不写了，只写一下我参与解题的。(不会WEB，不会PWN，我打个锤子的ctf) Misc tiny traffic 流量题，直接过滤http包，在末尾发现两个GET请求，分别获取了test和secret的br包。 使用python对br包进行解压，发现test是proto3的源码，secret是一串字节型数据。 <!-- /test.protp --> syntax = "proto3"; message PBResponse {
2021CISCN-Re-gift
m0_51713041的博客
06-20 287
gift 拿到题目之后查壳发现是go语言编写的程序 运行发现会打印出flag的前面几个字节 CISCN{4b445b324 拖入IDA进行调试，发现那几个函数(main_CISCN6666666,main_CISCN66666666,main_CISCN6666666666)都执行很慢，查看发现调用了sleep函数 写个IDAPython脚本将其patch掉 for i in range(0x000000000054A265,0x000000000054A272): ida_bytes.patch
linux命令
sdaujsj1的博客
03-20 496
cd usr //进入该文件夹内 mkdir xiepanpan//创建xiepanpan文件夹 pwd //显示所在的路径位置 echo Hello &amp;amp;gt;file1 //把echo 后的内容输入文件file1中，大于号表示输出，若文件存在直接输入到文件中，不存在 先创建文件再输入到文件中 echo world! &amp;amp;gt;file2 //同上 把world...
2021CISCN RE WP
qq_45739995的博客
05-17 504
逆向题质量太高了，菜鸡比赛只做出来两个题。 其他的题会在赛后继续复现出来。 持续更新中… glass jeb打开主函数发现调用了native层 ida打开 输入长度39位 第一个函数跟进发现调用了rc4 第二个函数用v7对flag加密（数组移位+异或） 第三个直接对flag加密（三位一组进行加密处理+异或） 大体思路：根据已有的字符串，首先逆掉第三个函数 得到用rc4数组加密后的 然后求出rc4的数组 最后在第二个函数里进行异或拿到flag (变量名用的有点乱) #include<stdio.h&
CISCN2021 Reverse--glass
whiteman2的博客
05-19 796
题目下载地址: https://pan.baidu.com/s/1yJNibfcbQR7OnEbOme3G7A 提取码:xr1r 拿到题目先用jadx查看主函数. 我们可以发现验证输入的地方主要是在checkFlag的地方。然而在apk的源码中并没有发现相关代码。因此猜测在.so文件中。 可以看到这里的确加载了一个.so文件。然后我们通过jeb提取出.so文件，拖入ida进行分析。 在左边的窗口中发现了，验证的函数。直接f5查看伪代码。 可以看到最后是跟unk_497C进行比较，判断是否正确。但是前面
2023全国大学生信息安全竞赛安徽省赛-初赛WP
qq_43647197的博客
09-27 5278
2023全国大学生信息安全竞赛安徽省赛-初赛WP
NSSCTF CRYPTO 题解（四）
2301_81105268的博客
06-03 1207
e是偶数与phi互质,可以找到e与phi的最大公因数s,然后让e除以s,再正常解rsa,只不过得到的不是m而是m的s次幂,搜索了wp才知道，是LaTeX符号，可以根据LaTeX表进行解密。已知，e，n，m1，m2 可以求出c1，c2。观察附件，题目给了n，e，以及40个c的值。题目给的n很大，直接把它放到网站上去分解。使用大佬的脚本，爆破e，并得到flag。对n进行分解，得到了15个因子。下载附件，解压打开，内容如下。代码审计，给了dp，分解n。下载附件，得到一张图片如下。下载附件，打开得到内容如下。
CISCN2021初赛（CTF360）——glass
yhfgs的博客
05-31 506
1.得到glass.apk文件，丢到JEB中，发现关键在so文件中。 2.把apk文件改扩展名，变为压缩文件（我改的zip），解压找到so文件。
2021CISCN-Re-glass
m0_51713041的博客
06-20 228
glass 将so文件拖入IDA进行分析： Java_com_ciscn_glass_MainActivity_checkFlag函数 bool __fastcall Java_com_ciscn_glass_MainActivity_checkFlag(int a1, int a2, int a3) { char *input; // r4 int key_len; // r5 char key[256]; // [sp+0h] [bp-220h] BYREF char v7[260];
第14届(2021)CISCN初赛WP（2）——Glass
InterplanetaryW的博客
06-15 478
Glass Writeup 首先使用apktool将“glass.apk”文件反编译 结果如下，提取其中Classes.dex文件 利用dex2jar工具进行反编译得到jar文件 生成jar包 使用jd-gui打开jar包，看到源码 核心判断函数如图所示 可以发现判断是利用checkFlag()函数 checkFlag为native外部函数 使用ida打开提取出的libnative-lib.so动态链接库 分析结束后可以在函数列表中很容易找到checkFlag()函数 使用F5进行反编译
全国大学生信息安全竞赛(CISCN)-reverse-复现（部分）
ookami6497的博客
06-06 1206
CISCN
[CISCN 2019 初赛]Love Math
paidx0
08-27 380
直接看题 题目禁用了一些黑名单，然后可以用一些数学函数的白名单，还正则禁用了字母数字的混合字符串。 一步一步来看 首先肯定是想办法构造这种形式 ?c=system('cat /flag') ?c=($_GET[a])($_GET[b])&a=system&b=cat /flag ?c=($_GET[acos])($_GET[pi])&acos=system&pi=cat /flag 现在关键是 $_GET 怎么利用数学函数构造 知识点 base_convert()函数
CISCN——2024——re——app-debug
Nike_name的博客
05-28 334
二进制插桩
2018 CISCN reverse
weixin_30735745的博客
05-10 158
2018 CISCN reverse 这题比赛的时候没做出来，主要是心态崩了看不下去。。赛后看了下网上的wp发现不难，是自己想复杂了。这里将我的思路和exp放出来，希望大家一起交流学习。 main函数 它首先是check了输入的前六个字符是否与“CISCN{”匹配，接着使用strtok函数将字符串以“_”分割为三部分，然后分别对这三部分check。 sub_4012DE函数 关键部分如下 将...
CISCN RE 部分wp
lucky_boyQAQ的博客
05-19 333
CISCN re 部分wp glass jeb打开，发现加密过程在so文件里面 ida看so文件 查看自己的加密函数 解密1 unsigned char flag[39]={ 0xA3, 0x1A, 0xE3, 0x69, 0x2F, 0xBB, 0x1A, 0x84, 0x65, 0xC2, 0xAD, 0xAD, 0x9E, 0x96, 0x05, 0x02, 0x1F, 0x8E, 0x36, 0x4F, 0xE1, 0xEB, 0xAF, 0xF0, 0xEA, 0xC4,
CISCN2024 初赛 wp 部分复现（Re）
Pisces50002的博客
06-10 1584
成功率比较玄学，有的版本就不行，我用nexus5x真机也是会崩溃，这里是雷电9.0模拟的OPPO 9。字符串收集信息，可以猜测是利用seed生成randint、random之类的随机数进行了处理。密文长度是56，base64是3->4，转回来flag是42个字符（猜测）借助GPT对几个关键函数进行分析，忽略一些异常处理，看一下主要的逻辑。输入的内容base64编码之后，与通过randint生成的随机数异或。首先是unidbg的环境配置，这个特别麻烦，建议使用。讲的蛮好的，就是挺麻烦，基本功要求高。
2020 ciscn 东北分区赛 re题解
Air_cat的博客
09-19 480
唉，居然没师傅出re题，悲伤 此题考点在于抓取或解密出迷宫，这里我用的原函数进行生成，改改几个定义就可以输出迷宫了： #include<stdio.h> #include<string.h> #include<windows.h> #include<string.h> #include<tchar.h> #include<stdint.h > //#+OXJ xnB1 QWT4 9cnW cGFB ZOjn yfZo ZV1m 7+/
2023 CTF国赛初赛（CISCN） re- ez_byte
qq_54894802的博客
05-30 1828
我们跳到数据区，发现这个100%下面的，yes并没有在string窗口出现，我们按下x查询交叉引用，在执行yes之前，有个jmp指令，也就是说，按照程序执行是永远不好去到yes的地方的，也就是说，一定有什么操作，然后再跳到yes中去。在前面，我们分析了，对r12的操作，并没有直接出现在代码上，操作代码被隐藏了。为此，我们可以大致猜测就是运行程序，触发一个异常，然后通过此条转到想要操作的地方，进行操作，通过题目描述，应该就是嵌入了一堆字节码。我们查看判断跳入，yes的汇编，我们可以发现，
2024CISCN初赛逆向
最新发布
01-11
### 关于2024 CISCN 初赛逆向工程题目解析 #### 逆向工程题目的背景介绍 在2024年的全国大学生信息安全竞赛(CISCN)初赛中，逆向工程作为一项重要的考察技能，在多个题目中有所体现。这类题目通常涉及对二进制文件、脚本或加密算法的理解与分析，旨在测试参赛者对于程序内部逻辑的掌握程度。 #### 解题思路概述 针对逆向工程类题目，一般采用如下方法论来解决问题： - **工具准备**：选择合适的反编译器和调试环境是成功的关键之一。常用的工具有IDA Pro、Ghidra等高级静态分析平台；以及OllyDbg这样的动态跟踪软件[^1]。 - **初步探索**：通过观察给定样本的行为模式（如启动参数、网络请求），可以获取一些线索帮助定位核心功能模块的位置[^2]。 - **深入挖掘**：利用上述提到的各种工具和技术手段逐步揭开目标应用程序的真实面目。此过程可能涉及到字符串查找、函数调用图绘制等工作[^3]。 - **验证假设**：当形成了一套完整的理论框架之后，则需设计实验加以检验其正确与否。比如尝试修改某些特定条件下的输入数据看是否会触发预期的结果变化[^4]。 #### 实际案例分享 以其中一个具体实例为例说明整个流程的应用情况。该挑战要求选手破解一个简单的加壳可执行文件并找出其中隐藏的信息。经过一系列操作后发现原生代码被混淆处理过，增加了阅读难度。不过借助强大的辅助工具还是能够还原出大致结构，并最终锁定了关键位置完成任务。 ```bash # 使用strings命令查看可能存在有用信息的地方 $ strings binary_file | grep "flag" ``` 这段shell指令展示了如何快速扫描二进制文件中的ASCII字符序列寻找潜在标志位(flag)，这是许多CTF比赛中常见的技巧之一。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

寻梦&之璐

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值