[2019红帽杯]childRE

已于 2024-05-22 08:49:15 修改
阅读量948 收藏 9
点赞数 10
文章标签： 网络安全 数据结构
于 2024-05-06 11:15:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2302_79135465/article/details/138471338
版权
文章详细解析了一段C++代码，涉及字符串加密（通过MD5哈希和特定替换运算），取消函数名修饰，以及二叉树结构的动态构建过程。作者通过动态调试揭示了输入字符串的处理和内存分配策略。
摘要由CSDN通过智能技术生成 
int __cdecl main(int argc, const char **argv, const char **envp)
{
  __int64 v3; // rax
  _QWORD *v4; // rax
  const CHAR *v5; // r11
  __int64 v6; // r10
  int v7; // r9d
  const CHAR *v8; // r10
  __int64 v9; // rcx
  __int64 *v10; // rax
  unsigned int v12; // ecx
  __int64 v13; // r9
  __int128 flag[2]; // [rsp+20h] [rbp-38h] BYREF

  memset(flag, 0, sizeof(flag));
  scanf("%s");
  v3 = -1i64;
  do
    ++v3;
  while ( *((_BYTE *)flag + v3) );
  if ( v3 != 31 )
  {
    while ( 1 )
      Sleep(0x3E8u);                            // len(flag)=31
  }
  v4 = sub_7FF766461280(flag);
  v5 = name;
  if ( v4 )
  {
    sub_7FF7664615C0((unsigned __int8 *)v4[1]);
    sub_7FF7664615C0(*(unsigned __int8 **)(v6 + 16));
    v7 = dword_7FF7664657E0;
    v5[dword_7FF7664657E0] = *v8;
    dword_7FF7664657E0 = v7 + 1;
  }
  UnDecorateSymbolName(v5, outputString, 0x100u, 0);// 将已装饰的符号名v5
                                                // 转换为未装饰的符号名outputstring
  v9 = -1i64;
  do
    ++v9;
  while ( outputString[v9] );
  if ( v9 == 62 )                               // len(outputString)=62
  {
    v12 = 0;
    v13 = 0i64;
    do
    {
      if ( a1234567890Qwer[outputString[v13] % 23] != str2[v13] )
        _exit(v12);
      if ( a1234567890Qwer[outputString[v13] / 23] != str1[v13] )
        _exit(v12 * v12);
      ++v12;
      ++v13;
    }
    while ( v12 < 62 );
    print("flag{MD5(your input)}\n");
    return 0;
  }
  else
  {
    v10 = sub_7FF7664618A0(std::cout);
    std::ostream::operator<<(v10, sub_7FF766461A60);
    return -1;
  }
}

大致只能分析出这些了。

看别人wp：

输入长度31的字符串---进行置换运算---取消修饰函数名---将未修饰函数名的商和余数与字符串比较

第一步：

根据 a/b=c......d 可以求出outputString

str1='55565653255552225565565555243466334653663544426565555525555222'
str2='(_@4620!08!6_0*0442!@186%%0@3=66!!974*3234=&0^3&1@=&0908!6_0*&'
s='''1234567890-=!@#$%^&*()_+qwertyuiop[]QWERTYUIOP{}asdfghjkl;',27h,'ASDFGHJKL:"ZXCVBNM<>?zxcvbnm,.'''
p=''
for i in range(62):
    p+=chr(s.index(str2[i])+s.index(str1[i])*23)
print(p)
# private: char * __thiscall R0Pxx::My_Aut0_PWN(unsigned char *)

然后就是看那个UnDecorateSymbolName（）函数

c, c++函数名编译符号修饰符说明_c函数 前缀修饰-CSDN博客

buu [2019红帽杯]childRE wr_2019红帽杯分数-CSDN博客

有点难懂。

根据 private: char * __thiscall R0Pxx::My_Aut0_PWN(unsigned char *)

那么 v5 = ?My_Aut0_PWN@R0Pxx@@AAE

也可以通过写一个函数来得到

#include <iostream>

class R0Pxx {
public:
    R0Pxx() {
        My_Aut0_PWN((unsigned char*)"hello");
    }
private:
    char* __thiscall My_Aut0_PWN(unsigned char*);
};

char* __thiscall R0Pxx::My_Aut0_PWN(unsigned char*) {
    std::cout << __FUNCDNAME__ << std::endl;

    return 0;
}

int main()
{
    R0Pxx A;

    system("PAUSE");
    return 0;
}

第二步：置换运算

发现是result给name的赋值，故找result的值怎么来的

用result来解的：

a = "?My_Aut0_PWN@R0Pxx@@AAEPADPAE@Z"
b = 0x50, 0x51, 0x48, 0x52, 0x53, 0x49, 0x44, 0x54, 0x55, 0x4a, 0x56, 0x57, 0x4b, 0x45, 0x42, 0x58, 0x59, 0x4c, 0x5a, 0x5b, 0x4d, 0x46, 0x5c, 0x5d, 0x4e, 0x5e, 0x5f, 0x4f, 0x47, 0x43, 0x41 
c = list(a)
for i in range(0,len(a)):
    c[b[i]-0x41] = a[i]
a = ''.join(c)
print(a)

/*

我传入的v14=“abcdefghijklmnopqrstuvwxyz12345”,第一次的时候它给name[0]赋值成了p，对应我输入的字符串的下标是15，我调试了多次，发现每次都是这样，而且最后的name里存放的是打乱了顺序的输入的字符串，动调它给name赋值的过程，记录下对应的下标
最后得到的赋值顺序下标是[15, 16, 7, 17, 18, 8, 3, 19, 20, 9, 21, 22, 10, 4, 1, 23, 24, 11, 25, 26, 12, 5, 27, 28, 13, 29, 30, 14, 6, 2, 0]

直接说动态调试发现是固定的位置变换，直接把索引提取出来了

到这里程序逻辑就清楚了，首先输入长度为31的字符串，然后根据赋值下标的顺序打乱数据得到v2。
逆算一下输入的字符串          
原文链接：https://blog.csdn.net/mcmuyanga/article/details/115575264

*/

这个动调的思路需要学学

import hashlib
ops = '?My_Aut0_PWN@R0Pxx@@AAEPADPAE@Z'
result = [''] * 31
index = [15, 16, 7, 17, 18, 8, 3, 19, 20, 9, 21, 22, 10, 4, 1, 23, 24, 11, 25, 26, 12, 5, 27, 28, 13, 29, 30, 14, 6, 2, 0]

for i in range(len(ops)):
    result[index[i]] += ops[i]
ss = ''.join(i for i in result)
print(ss)
print(hashlib.md5(ss.encode('utf-8')).hexdigest())
#63b148e750fed3a33419168ac58083f5

又细翻了一下别人wp：

_QWORD *__fastcall sub_7FF7F4FE1280(_BYTE *a1)
{
  _QWORD *v2; // r12
  _QWORD *v3; // rax
  __int64 v4; // rdx
  __int64 v5; // r8
  __int64 v6; // rcx
  char v7; // bl
  __int64 v8; // rdi
  __int64 v9; // rax
  bool v10; // zf
  __int64 v11; // r8
  int v12; // esi
  __int64 v13; // rdi
  __int64 v14; // rdx
  __int64 v15; // r8
  __int64 v16; // rcx
  char v17; // bl
  __int64 v18; // r14
  __int64 v19; // rcx
  __int64 v20; // rdx
  __int64 v21; // r8
  __int64 v22; // rcx
  char v23; // bl
  __int64 v24; // r14
  __int64 v25; // rcx
  _QWORD *v27; // [rsp+20h] [rbp-40h]
  _QWORD *v28; // [rsp+20h] [rbp-40h]
  __int128 v29; // [rsp+28h] [rbp-38h] BYREF
  __int128 v30; // [rsp+38h] [rbp-28h]
  __int64 v31; // [rsp+48h] [rbp-18h]

  v2 = operator new(0x18ui64);
  *(_BYTE *)v2 = 0;
  v2[1] = 0i64;
  v2[2] = 0i64;
  v29 = 0i64;
  v30 = 0ui64;
  v31 = 0i64;
  v3 = operator new(0x10ui64);
  v3[1] = 0i64;
  *(_QWORD *)&v29 = v3;
  *v3 = &v29;
  v4 = *((_QWORD *)&v30 + 1);
  v5 = v31;
  v6 = v30;
  if ( (((_BYTE)v31 + BYTE8(v30)) & 1) == 0 && (unsigned __int64)v30 <= (unsigned __int64)(v31 + 2) >> 1 )
  {
    sub_7FF7F4FE1AE0(&v29);
    v5 = v31;
    v4 = *((_QWORD *)&v30 + 1);
    v6 = v30;
  }
  *((_QWORD *)&v30 + 1) = (2 * v6 - 1) & v4;
  v7 = BYTE8(v30) + v5;
  v8 = 8 * (((unsigned __int64)(*((_QWORD *)&v30 + 1) + v5) >> 1) & (v6 - 1));
  v9 = *((_QWORD *)&v29 + 1);
  if ( !*(_QWORD *)(v8 + *((_QWORD *)&v29 + 1)) )
  {
    *(_QWORD *)(v8 + *((_QWORD *)&v29 + 1)) = operator new(0x10ui64);
    v9 = *((_QWORD *)&v29 + 1);
  }
  *(_QWORD *)(*(_QWORD *)(v8 + v9) + 8i64 * (v7 & 1)) = v2;
  v10 = v31 == -1;
  v11 = ++v31;
  v12 = 1;
  if ( !v10 )
  {
    do
    {
      v13 = *(_QWORD *)(*(_QWORD *)(*((_QWORD *)&v29 + 1) + 8 * ((*((_QWORD *)&v30 + 1) >> 1) & (v30 - 1)))
                      + 8i64 * (BYTE8(v30) & 1));
      v31 = v11 - 1;
      if ( v11 == 1 )
        *((_QWORD *)&v30 + 1) = 0i64;
      else
        ++*((_QWORD *)&v30 + 1);
      *(_BYTE *)v13 = *a1++;
      if ( v12 >= 31 )
      {
        v11 = v31;
      }
      else
      {
        v27 = operator new(0x18ui64);
        *(_BYTE *)v27 = 0;
        v27[1] = 0i64;
        v27[2] = 0i64;
        *(_QWORD *)(v13 + 8) = v27;
        v14 = *((_QWORD *)&v30 + 1);
        v15 = v31;
        v16 = v30;
        if ( (((_BYTE)v31 + BYTE8(v30)) & 1) == 0 && (unsigned __int64)v30 <= (unsigned __int64)(v31 + 2) >> 1 )
        {
          sub_7FF7F4FE1AE0(&v29);
          v15 = v31;
          v14 = *((_QWORD *)&v30 + 1);
          v16 = v30;
        }
        *((_QWORD *)&v30 + 1) = (2 * v16 - 1) & v14;
        v17 = BYTE8(v30) + v15;
        v18 = 8 * (((unsigned __int64)(*((_QWORD *)&v30 + 1) + v15) >> 1) & (v16 - 1));
        v19 = *((_QWORD *)&v29 + 1);
        if ( !*(_QWORD *)(v18 + *((_QWORD *)&v29 + 1)) )
        {
          *(_QWORD *)(v18 + *((_QWORD *)&v29 + 1)) = operator new(0x10ui64);
          v19 = *((_QWORD *)&v29 + 1);
        }
        *(_QWORD *)(*(_QWORD *)(v18 + v19) + 8i64 * (v17 & 1)) = *(_QWORD *)(v13 + 8);
        v11 = ++v31;
        if ( ++v12 < 31 )
        {
          v28 = operator new(0x18ui64);
          *(_BYTE *)v28 = 0;
          v28[1] = 0i64;
          v28[2] = 0i64;
          *(_QWORD *)(v13 + 16) = v28;
          v20 = *((_QWORD *)&v30 + 1);
          v21 = v31;
          v22 = v30;
          if ( (((_BYTE)v31 + BYTE8(v30)) & 1) == 0 && (unsigned __int64)v30 <= (unsigned __int64)(v31 + 2) >> 1 )
          {
            sub_7FF7F4FE1AE0(&v29);
            v21 = v31;
            v20 = *((_QWORD *)&v30 + 1);
            v22 = v30;
          }
          *((_QWORD *)&v30 + 1) = (2 * v22 - 1) & v20;
          v23 = BYTE8(v30) + v21;
          v24 = 8 * (((unsigned __int64)(*((_QWORD *)&v30 + 1) + v21) >> 1) & (v22 - 1));
          v25 = *((_QWORD *)&v29 + 1);
          if ( !*(_QWORD *)(v24 + *((_QWORD *)&v29 + 1)) )
          {
            *(_QWORD *)(v24 + *((_QWORD *)&v29 + 1)) = operator new(0x10ui64);
            v25 = *((_QWORD *)&v29 + 1);
          }
          *(_QWORD *)(*(_QWORD *)(v24 + v25) + 8i64 * (v23 & 1)) = *(_QWORD *)(v13 + 16);
          v11 = ++v31;
          ++v12;
        }
      }
    }
    while ( v11 );
  }
  sub_7FF7F4FE17D0(&v29);
  return v2;
}

注意传入的是byte，操作也是 input+8 , input+16 

 __int128 input[2]; // [rsp+20h] [rbp-38h] BYREF      16*8=128 

这是个创建二叉树的函数

动态调试会发现，开辟的地址处有三个数据，第一个是我们输入的字符，第二个是左孩子的地址，第三个是右孩子的地址。

可以识别出是二叉树结构体。

 

发现后面题都喜欢动调让猜，需要点脑洞，还有一些数据结构的

re_halo
关注
  • 10
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
BUU [2019红帽杯]childRE1
zzqzzq11的博客
01-17 2384
这个题目比较难，一开始看了一下没有头绪。 首先用ida打开： 很长的一个程序，一步一步仔细分析。 首先是第一部分，这一部分是先进行了输入，然后判断是否是31字节，将我们的输入使用sub_14001290()函数。这个函数，我一开始以为是一个加密函数，看起来挺复杂的。通过下面的sub_1400015C0(）函数有一些提示。if(v4)下面的部分完全就是一个后序遍历嘛？所以说，这个函数可以猜测是构造二叉树的函数。(下面第二张图是后序遍历的代码)。 但是有个问题，这个sub_140001...
[羊城杯 2021]BabySmc
最新发布
2302_79135465的博客
05-31 810
运行就是输入flag不知道怎么跳过去的这个应该就是smc加密的函数了运行完这个函数才能继续往下还是有两处问题，继续调试走完了，那俩处还是有问题所以应该是需要手动修复。
BUUCTF [2019红帽杯]childRE
个人博客：http://s0rry.cn
12-26 2021
这里写自定义目录标题欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 欢迎使用Markdown编辑器 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Mar
buu [2019红帽杯]childRE wr
liuxiaohuai_的博客
12-19 1170
无论 __cdecl，__fastcall还是__stdcall调用方式，函数修饰都是以一个“?”開始，后面紧跟函数的名字。再后面是參数表的開始标识和 依照參数类型代号拼出的參数表。
[2019红帽杯]CHILDRE(c++逆向+函数调用约定+c++修饰符转换+异或+黑盒分析+爆破)
qq_54894802的博客
06-14 525
官方文档，大致可以知道这个函数的作用就是将我们的flag进行转换，转换成了c++函数模式。也就是说我们的flag就是outoutstring，这个函数的。了解之后，我们可以将未转换的outoutstring得出：?我们输入31个有序数据，12345ABCDEFGHIJKLMNOPQRSTUWXYZ，对于这一堆函数，我们进行动态调试,我们输入有序字母。通过这里，我们可以判断出我们的flag有着31位。进入这个函数，我们可以发现。
self modue和 self childre的区别.docx
09-16
self modue和 self childre的区别
styled-svg:用于SVG文件的样式化组件生成器，以在react中使用
05-02
样式的svg 生成 从SVG文件这是什么？ 该实用程序使用styled.svg函数生成React组件。 只需将.svg放到项目中的某个位置，运行该工具，并开始将您的svg文件用作 ，并具有所有React和styled-components美感。... childre
Lovitt, Thomas C. 尽管我很抗拒，但我还是从孩子们那里学到了东西。 哥伦布俄亥俄州：Charles E. Merrill，1977 年，225 页。[美元]5.50
06-29
Childre 那里想出来的？？。 哥伦布 OH：Charles E. Merrill，1977 年，225 页，5.50 美元。 本书是作者多年研究的成果，面向教师。 正如他指出的那样，尽管在过去 25 年里收集了大量扎实的教育研究，但对常见的教学...
Python3 把一个列表按指定数目分成多个列表的方式
12-23
如果我们需要将一个列表按指定数目分成多个列表：比如[1,2,3,4,5,6,7,8,9,10]分成[1,2,3][4,5,6][7,8,9][10]，我们可以建立一个列表分割的函数split_list.py。... count = len(init_list) % childre
关键数学诊断算术测验对青少年学习障碍学生的效用
06-30
The utility of the key math diagnostic arithmetic test for adolescent learning disabled students WISC-WISC-R Comparison 275 REFERENCES BI.:HKY, K....RRI.;TS, H....GIASSISR, A....Childre
re学习笔记（24）BUUCTF-re-[2019红帽杯]childRE
逆向随笔
01-11 882
[2019红帽杯]childRE 新手一枚，如有错误（不足）请指正，谢谢！！ 题目链接：BUUCTF-re-[2019红帽杯]childRE 题目下载：点击下载 参考资料： UnDecorateSymbolName c/c++函数名修饰规则 IDA64位载入 F5伪代码 倒着分析 可知挨个取outputString字符串的字符，然后对23取余和除数分别在str3中找到对应位置，，，必须与st...
[2019红帽杯]childRE 分析与拓展
Tokameine的博客
07-01 531
十分特殊也有趣的一题，特此记录。流程并非难以理解，但有些需要注意的点。 无壳，可以直接用IDA分析，但由于存在一些动态变量，一旦开始动调，代码将会变得更难理解，因此目前只用静态调试来审计 int __cdecl main(int argc, const char **argv, const char **envp) { __int64 v3; // rax __int64 v4; // rax const CHAR *v5; // r11 __int64...
第45天：红帽杯2019-childRE（一）
S1lenc3的博客
12-15 430
1.上午考四级，来年再战。 2.下午出去玩了，没学习。 3.放弃学习是不可能的，今天待在实验室了。 今天打算复现一下childRE，直接拖到IDA，代码好长，我好害怕。 搜索关键字符串定位函数。 三处Sleep，直接patch，推荐一个IDA的patch插件，之前的博客也提到过， 然后，这TM是啥。。。。对我这个菜鸡来说，只有自闭了。 这是STL，我压根不会。。。。 没办法...
buu刷题 [2019红帽杯]childRE wp
苗_的博客
08-18 821
此题可以分为三大块来解 考点：二叉树（动态调试）、C++函数名修饰 1. 首先f5反编译，首先我们要求出outputString（长度为62），逆分析可以知道取outputString字符串的字符，然后对23取余和除数分别在a1234567890Qwer中找到对应位置，其值必须与str1和str2对应位置的值相等 上这一段脚本： str1 = "(_@4620!08!6_0*0442!@186%%0@3=66!!974*3234=&0^3&1@=&0908!6_0*&a
第46天：红帽杯2019-childRE（二）
S1lenc3的博客
12-15 381
昨天说到处理完输入了，今天把这道题干掉了，一定要有耐心，慢慢调试。 把输入的三个数设为x，y，z。 断到这里， 注释都标注了，自己分析一下。 在这里，发现goto到label_47就直接到运行结束了，没有flag，所以就不让他跳转，就要满足x<z 类似的，也要满足y<x。继续单步，来到一堆计算的地方。 这里是计算位数的。 这都是一步一步分析的，没什么说...
C语言自定义函数作为函数的参数
今晚看星星的博客
11-21 2435
文章目录函数作为参数函数作为参数的使用 函数作为参数 函数作为参数的时候，需要声明函数的结构 一般的形式为: func(T (*func)(V args)) 使用的时候，直接使用对应参数类型的函数名即可 函数的名字就是指向内存函数开始执行时的指针，因此可以直接进行赋值 函数作为参数的使用 #include<iostream> using namespace std; void fun(int* a, int *b) { int tmp = *a; *a = *b;
BUUCTF Reverse/[2019红帽杯]childRE
ookami6497的博客
09-11 327
C++的类成员函数（其调用方式是thiscall）。函数的名字修饰与非成员的C++函数稍有不同，首先就是在函数名字和參数表之间插入以“@”字 符引导的类名。可以先写脚本将outputstring中的值给求出来。感觉像个二叉树遍历，试了下还原二叉树但是咋搞都不对。然后就是这个函数了，可以参考。来分割，对应关系如下。直接在输入的时候使用。刚好对应每个数的下标。
TJCTF之 Tilted Troop
NoOneGroup
08-30 388
博客已经转移 https://noone-hub.github.io/ 倒不是说这题目有多难，是我太菜，从中学到了点东西，发出来理清下思路，记录下 先贴上主函数代码 int __cdecl main(int argc, const char **argv, const char **envp) { __gid_t rgid; // ST04_4@1 char *v4; // rb...
qobject: cannot create childre
03-16
n for parent QObject (x), parent is nullptr 这个错误是因为在创建一个QObject对象的时候，没有指定它的父对象。QObject对象必须有一个父对象，否则它就成为了一个孤儿对象，无法被管理和销毁。 解决方法是在创建QObject对象时，指定它的父对象。例如： QObject *obj = new QObject(parent); 其中parent是一个已经存在的QObject对象，或者是nullptr，表示没有父对象。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值