SUCTF2019-hardCPP WP

最新推荐文章于 2023-02-18 22:01:46 发布
最新推荐文章于 2023-02-18 22:01:46 发布
阅读量867 收藏
点赞数 2
分类专栏： 逆向 文章标签： SUCTF2019
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41252520/article/details/100632629
版权

前言

  • 这两天参加了 NU1LCTF 和 ByteCTF ，签了到之后发现一题都做不出来 /(ㄒoㄒ)/~~ ，很受伤。所以打算回顾一下错过的 SUCTF2019 ，多积累经验和学习更多的技术。

分析

  • IDA打开，发现程序是 LLVM 编译的，还加了花指令，导致看起来非常绕。
    在这里插入图片描述

  • 坑爹的是还不能动态调试，只能静态分析了。过程难以描述，这里就贴一下正确的执行步骤吧：

      int __cdecl main(int argc, const char **argv, const char **envp)
  {
    signed int v3; // eax
    signed int v4; // eax
    signed int v5; // ecx
    signed int v6; // eax
    signed int v7; // eax
    signed int v8; // eax
    signed int v9; // eax
    signed int v10; // eax
    char v11; // al
    char v12; // al
    char v13; // al
    char v14; // al
    char v15; // al
    signed int v16; // ecx
    signed int v17; // eax
    signed int v18; // eax
    unsigned int v19; // eax
    unsigned int v20; // eax
    unsigned int v21; // eax
    signed int v22; // ecx
    char v24; // al
    char v25; // al
    char v26; // al
    char v27; // al
    signed int v28; // [rsp+9Ch] [rbp-94h]
    char v29; // [rsp+A0h] [rbp-90h]
    char v30; // [rsp+A8h] [rbp-88h]
    char v31; // [rsp+B0h] [rbp-80h]
    char v32; // [rsp+B8h] [rbp-78h]
    char v33; // [rsp+C0h] [rbp-70h]
    char v34; // [rsp+C8h] [rbp-68h]
    char v35; // [rsp+CFh] [rbp-61h]
    int v36; // [rsp+D0h] [rbp-60h]
    int input_len; // [rsp+D4h] [rbp-5Ch]
    int v38; // [rsp+D8h] [rbp-58h]
    int v39; // [rsp+DCh] [rbp-54h]
    char input[24]; // [rsp+E0h] [rbp-50h]
    char v41; // [rsp+F8h] [rbp-38h]
    char v42; // [rsp+100h] [rbp-30h]
    char v43; // [rsp+108h] [rbp-28h]
    char v44; // [rsp+110h] [rbp-20h]
    int v45; // [rsp+114h] [rbp-1Ch]
    const char **v46; // [rsp+118h] [rbp-18h]
    int v47; // [rsp+120h] [rbp-10h]
    int v48; // [rsp+124h] [rbp-Ch]
    int v49; // [rsp+128h] [rbp-8h]
    bool v50; // [rsp+12Eh] [rbp-2h]
    bool v51; // [rsp+12Fh] [rbp-1h]
  
    v48 = 0;
    v47 = argc;
    v46 = argv;
    v45 = time(0LL);
    puts("func(?)=\"01abfc750a0c942167651c40d088531d\"?");
    input[0] = getchar();
    fgets(&input[1], 21, stdin);
    v39 = time(0LL);
    v38 = v39 - v45;
    v49 = v39 - v45;
    v28 = 0x703FF685;
    while ( 1 )
    {
      while ( 1 )
      {
        while ( 1 )
        {
          while ( 1 )
          {
            while ( 1 )
            {
              while ( 1 )
              {
                while ( 1 )
                {
                  while ( 1 )
                  {
                    while ( 1 )
                    {
                      while ( 1 )
                      {
                        while ( 1 )
                        {
                          while ( 1 )
                          {
                            while ( 1 )
                            {
                              while ( 1 )
                              {
                                while ( v28 == 0x8364E2E6 )
                                {
                                  v35 = v38 ^ input[v36];// v35=input[v36]
                                  v34 = GetChar((__int64)&v43, v35);// v34=v35
                                  v33 = Get_Char_3((__int64)&v41, input[v38 - 1 + v36]);// v33=input[v36-1]
                                  v11 = Mod(&v33, 7);
                                  v35 = Add((__int64)&v34, v11);
                                  v32 = Get_Char_2((__int64)&v44, v35);// v32=v35
                                  v31 = Get_Char_2((__int64)&v44, input[v38 - 1 + v36]);
                                  v12 = Xor(&v31, 18);
                                  v30 = Get_Char_4((__int64)&v42, v12);
                                  v13 = Mult(&v30, 3);
                                  v29 = GetChar((__int64)&v43, v13);
                                  v14 = Add((__int64)&v29, 2);
                                  v15 = Xor(&v32, v14);
                                  v16 = 0x4D79419D;
                                  v35 = v15;
                                  v51 = enc[v36 - 1] != v15;
                                  if ( y < 10 || (((_BYTE)x - 1) * (_BYTE)x & 1) == 0 )
                                    v16 = 0xE6B1C47D;
                                  v28 = v16;
                                }
                                if ( v28 != 0x8B56CD07 )
                                  break;
                                v28 = 0x5E980F0E;
                              }
                              if ( v28 != 0x8FAFE559 )
                                break;
                              v28 = 0xC54B2616;
                              puts("You win");
                            }
                            if ( v28 != 0x918FF00C )
                              break;
                            v18 = 0x51FB290B;
                            if ( y < 10 || (((_BYTE)x - 1) * (_BYTE)x & 1) == 0 )
                              v18 = 1154698238;
                            v28 = v18;
                          }
                          if ( v28 != 0xB743BDDC )
                            break;
                          v21 = 0x8FAFE559;
                          if ( y < 10 || (((_BYTE)x - 1) * (_BYTE)x & 1) == 0 )
                            v21 = 0xC54B2616;
                          v28 = v21;
                        }
                        if ( v28 != 0xC54B2616 )
                          break;
                        puts("You win");
                        v22 = 0x8FAFE559;
                        if ( y < 10 || (((_BYTE)x - 1) * (_BYTE)x & 1) == 0 )
                          v22 = 0x1B327C95;
                        v28 = v22;
                      }
                      if ( v28 != 0xCB553B5C )
                        break;
  LABEL_70:
                      v19 = 0xEB1FA22E;
                      if ( y < 10 || (((_BYTE)x - 1) * (_BYTE)x & 1) == 0 )
                        v19 = 0xFCB084AC;
                      v28 = v19;
                    }
                    if ( v28 != 0xD3E10A81 )
                      break;
                    v4 = 0x7F611913;              // (3)
                    if ( y < 10 || (((_BYTE)x - 1) * (_BYTE)x & 1) == 0 )
                      v4 = 0x2C0D2A04;            // (4)
                    v28 = v4;                     // v28=0x2C0D2A04
                  }
                  if ( v28 == 0xE4A1C025 )
                    exit(0);
                  if ( v28 != 0xE6B1C47D )
                    break;
                  v17 = 0x6EAC82CB;
                  if ( v51 )
                    v17 = 0x918FF00C;
                  v28 = v17;
                }
                if ( v28 != 0xEB1FA22E )
                  break;
                v28 = 0xFCB084AC;
              }
              if ( v28 != 0xEE73C818 )
                break;
              v6 = 0x66996259;                    // (8)
              if ( v50 )
                v6 = 0xE4A1C025;
              v28 = v6;                           // v28=0x66996259
            }
            if ( v28 != 0xF28568CF )
              break;
            v28 = 0x16FA3CE;
          }
          if ( v28 != 0xFCB084AC )
            break;
          v20 = 0xEB1FA22E;
          if ( y < 10 || (((_BYTE)x - 1) * (_BYTE)x & 1) == 0 )
            v20 = 0xF28568CF;
          v28 = v20;
        }
        if ( v28 != 0x16FA3CE )
          break;
        ++v36;
        v28 = 0x5E980F0E;
      }
      if ( v28 == 0x1B327C95 )
        return 0;
      if ( v28 == 0x1E2AAEDE )
      {
        puts("Let the silent second hand take the place of my doubt...");
        exit(0);
      }
      if ( v28 == 0x25297AE9 )
      {
        v36 = 1;
        v28 = 0x437E1545;
      }
      else if ( v28 == 0x2C0D2A04 )
      {
        input_len = strlen(input);                // (5)
        v50 = input_len != 21;
        v5 = 0x7F611913;
        if ( y < 10 || (((_BYTE)x - 1) * (_BYTE)x & 1) == 0 )
          v5 = 0xEE73C818;                        // (6)
        v28 = v5;                                 // v28=0xEE73C818
      }
      else if ( v28 == 0x3C4B1D57 )
      {
        v10 = 0x4D79419D;
        if ( y < 10 || (((_BYTE)x - 1) * (_BYTE)x & 1) == 0 )
          v10 = 0x8364E2E6;
        v28 = v10;
      }
      else if ( v28 == 0x437E1545 )
      {
        v8 = 0x25297AE9;
        v36 = 1;
        if ( y < 10 || (((_BYTE)x - 1) * (_BYTE)x & 1) == 0 )
          v8 = 0x8B56CD07;
        v28 = v8;
      }
      else
      {
        if ( v28 == 0x44D34BFE )
          exit(0);
        if ( v28 == 0x4D79419D )
        {
          v35 = v38 ^ input[v36];
          v34 = GetChar((__int64)&v43, v35);
          v33 = Get_Char_3((__int64)&v41, input[v38 - 1 + v36]);
          v24 = Mod(&v33, 7);
          v35 = Add((__int64)&v34, v24);
          v32 = Get_Char_2((__int64)&v44, v35);
          v31 = Get_Char_2((__int64)&v44, input[v38 - 1 + v36]);
          v25 = Xor(&v31, 18);
          v30 = Get_Char_4((__int64)&v42, v25);
          v26 = Mult(&v30, 3);
          v29 = GetChar((__int64)&v43, v26);
          v27 = Add((__int64)&v29, 2);
          v35 = Xor(&v32, v27);
          v28 = 0x8364E2E6;
        }
        else
        {
          if ( v28 == 0x51FB290B )
            exit(0);
          switch ( v28 )
          {
            case 0x5E980F0E:                      // (10)
              v9 = 0xB743BDDC;
              if ( v36 < 21 )                     // 进行20轮变换
                v9 = 0x3C4B1D57;
              v28 = v9;
              break;
            case 0x66996259:                      // (9)
              v7 = 0x25297AE9;
              if ( y < 10 || (((_BYTE)x - 1) * (_BYTE)x & 1) == 0 )
                v7 = 0x437E1545;
              v28 = v7;
              break;
            case 0x6EAC82CB:
              goto LABEL_70;
            case 0x703FF685:                      // （1）
              v3 = 0xD3E10A81;
              if ( v49 > 0 )
                v3 = 0x1E2AAEDE;
              v28 = v3;                           // （2）v28=0xD3E10A81
              break;
            case 0x7F611913:                      // (7)
              input_len = strlen(input);
              v28 = 0x2C0D2A04;
              break;
          }
        }
      }
    }
  }

  • 标号的地方表示第 i 次执行的位置。到了第 10 次以后，我猜测程序应该是验证输入的数据了。验证的方式在：
    在这里插入图片描述

  • 原先的函数名也是没有意义的，经过分析之后被我重定义了。

  • 所以得到递推关系：

      v15=(input[v36]+(input[v36-1]%7))^((input[v36-1]^18)*3+2)
  //验证
  v15==enc[v36 - 1]

  • 所以反求 input 的关系式是：

      input[i]=(enc[i-1]^((input[i-1]^18)*3+2)&0xff)-(input[i-1]%7)

  • 但是 input[0] 需要爆破一下

脚本

enc=[0xf3,0x2e,0x18,0x36,0xe1,0x4c,0x22,0xd1,0xf9,0x8c,0x40,0x76,0xf4,0xe,0x0,0x5,0xa3,0x90,0xe,0xa5]
for k in range(128):
    out=''
    input=[]
    input.append(k)
    out+=chr(k)
    for i in range(1,21):
        ch=(enc[i-1]^((input[i-1]^18)*3+2)&0xff)-(input[i-1]%7)
        input.append(ch&0xff)
        out+=chr(ch&0xff)
    if 'flag' in out:
        print(out)
        break

#flag{mY-CurR1ed_Fns}

总结

  • 代码量不多的情况下，可以根据初始条件和输出提示，进行目标导向性的探索。猜测程序应该怎么走才会走向成功，探测路径应围绕着输入的数据进行。
飞鸿踏雪（蓝屏选手）
关注
专栏目录
[SUCTF 2019]Pythonginx
qq_43774856的博客
12-02 239
[SUCTF 2019]Pythonginx 打开链接，得到源码 @app.route('/getUrl', methods=['GET', 'POST']) def getUrl(): url = request.args.get("url") host = parse.urlparse(url).hostname if host == 'suctf.cc': return "我扌 your problem? 111" parts = list(urlsp
buuctf-web-[SUCTF 2019]EasySQL 1-wp
居上
06-22 1067
[SUCTF 2019]EasySQL 源码 网上找的源码 <?php session_start(); include_once "config.php"; $post = array(); $get = array(); global $MysqlLink; //GetPara(); $MysqlLink = mysqli_connect("localhost",$datauser,$datapass); if(!$MysqlL
[SUCTF2019]hardcpp
m0_46296905的博客
05-03 989
题目：[SUCTF2019]hardcpp 64位ELF文件 ida64中打开发现有两处控制流平坦化。 装好angr，使用基于angr的脚本deflat.py去除控制流平坦化，在deflat.py所在目录下打开cmd命令行输入 python deflat.py hardCpp 0x4007E0 #“python版本 + 脚本名 + 文件名 + 起始地址” 第二处控制流平坦化同理去除。 运行几分钟即可得到去除控制流平坦化之后的程序。 如果原版deflat.py出错，可以试试优化之后的deflat
CTF逆向-[SUCTF2019]hardcpp-使用优化过的deflat.py处理混淆的控制流并将cpp的lambda解析得到实际处理逻辑
serfend's blog
04-29 2316
CTF逆向-[SUCTF2019]hardcpp-使用优化过的deflat.py处理混淆的控制流并将cpp的lambda解析得到实际处理逻辑 来源：https://buuoj.cn/ 内容： 附件：链接：https://pan.baidu.com/s/17OePBZh7Mvv9neqnh-Sv2g?pwd=d6kg 提取码：d6kg 答案：#flag{mY-CurR1ed_Fns} 总体思路 发现混淆的执行流，使用原版的处理不太成功，处理后少了很多信息 使用优化版的进行处理得到混淆少得多的代码 逐个点开l
[buuctf.reverse] 098_[SUCTF2019]hardcpp
weixin_52640415的博客
05-19 222
手工扁平化
[SUCTF2019]hardcpp_一道混淆题，熟悉控制流平坦化
Todog的博客
05-09 841
首先用IDA打开，发现有很多while(1),大量代码混淆其中 利用defalt进行控制流平坦化去混淆 找到主函数地址 好了 开始执行 输入 python .\defalt.py hardCpp 0x4007E0 等几分钟后会执行完毕 顺便说一下符号执行的原理 符号执行大概是将内存寄存器值当成未知变量就像设一个方程当成x往下执行遇到分支保存一下尝试各种分支执行到你想要的地方后续可以约束求解 好了，我们再打开 逻辑清晰很多了 进行分析 每...
BUUCTF 逆向工程(reverse)之[SUCTF2019]SignIn
weixin_44632787的博客
08-25 601
用IDA打开 其中的大整数分解，可以利用这个网站帮助分解：http://www.factordb.com/ __int64 __fastcall main(__int64 a1, char **a2, char **a3) { char v4; // [rsp+0h] [rbp-4A0h] char v5; // [rsp+10h] [rbp-490h] char v6; // [rsp+20h] [rbp-480h] char v7; // [rsp+30h] [rbp-470h]
all-in-one-wp-migration:多合一WP迁移-无限制importexport
04-09
《全面解析多合一WP迁移插件：实现无限导入与导出》 在WordPress的世界中，数据迁移是一项常见的任务，无论是为了备份、站点迁移还是多站点管理。"All In One WP Migration" 插件正是为此而生，它为用户提供了一种...
all-in-one-wp-migration-file-extension.zip
04-07
《全面解析WordPress迁移插件：All-in-One WP Migration File Extension》 在WordPress的世界里，数据迁移是一项常见的任务，无论是为了网站备份、迁移至新的主机，还是进行开发测试，都需要高效且可靠的工具。All-...
[SUCTF 2019] web题-CheckIn
BROTHERYY的博客
07-07 585
复现环境:buuoj.cn 尝试了各种上传绕过的方法，但依然还是不行，看了下其他大佬的wp，茅塞顿开，也说明我太菜了。 写入保存将ctf.txt改为ctf.jpg auto_prepend_file 表示在php程序加载应用程序前加载指定的php文件 auto_append_file 表示在php代码执行完毕后加载指定的php文件 自定义的.user,ini先执行auto_prepend_file函数，auto_prepend_file 表示在php程序加载应用程序前加载指定的php文件，也就是先加
[SUCTF2019]REVERSE的hardcpp
沐一 · 林 的博客
03-17 814
[SUCTF2019]REVERSE的hardcpp . . 下载附件，照例扔入 exeinfope 中查看信息： . . 64 位 ELF 文件，无壳，照例运行一下查看主要回显信息： . . 照例扔入 IDA64 中查看信息，有 main 函数看 main 函数： . . 上面的变量名是被我注释过的，现在看一下那些有冗余代码运算函数的分析过程：（看到函数内有一堆大数基本都是冗余代码了） . . 所以一个 while 循环的逻辑就是： enc=((pre_single_flag%7)+
[SUCTF 2019]EasySQL
最新发布
m0sway的博客
02-18 97
BUU Web题目 [SUCTF 2019]EasySQL 的WriteUp
[suctf 2019]EasySQL
qq_62046696的博客
06-28 1306
打开感觉是一道sql注入的题，发现输入数字 非0都会返回值 使用Sql堆叠注入查看信息，先用show指令查看数据库：1;show databases; 然后查看表名， 感觉要出来了 ，直接 1; show columns from Flag; 发现flag被过滤，唉就知道没这么简单，看到Flag表，猜测flag应该在Flag中。但是用1;show columns from Flag;无法回显出flag只会回显Nonono. -->说明flag被过滤掉了（注：1;show columns from用来查询
SUCTF2019-Pythonginx
Tajang的大千世界
04-24 238
打开靶机，经典给源码 CTRL+U看起来舒服点 3个if都是一样的，但是host在变，我们需要进入第三个if 这题经大佬指点得知使用的blackhat议题里的一个点，这是blackhat PPT链接：https://i.blackhat.com/USA-19/Thursday/us-19-Birch-HostSplit-Exploitable-Antipatterns-In-Unicode-Normalization.pdf 大致意思是当URL 中出现一些特殊字符的时候，输出的结果可能不在预期 偷的脚本
[SUCTF2019]protocol
qq_45699846的博客
03-25 451
[SUCTF2019]protocol
All-in-One WP Migration Unlimited扩展实用教程
资源摘要信息: "All-in-One WP Migration Unlimited Extension是一个针对WordPress网站迁移的扩展插件，它能够帮助用户在迁移过程中绕过服务器导入大小的限制。这个插件特别适合于那些拥有大型网站，或者需要迁移...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值