[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
    评论
xctf攻防世界getit writeup
qq_42983283的博客
11-04 573
下载查看： ida64打开，f5分析： int __cdecl main(int argc, const char **argv, const char **envp) { char v3; // al@4 int result; // eax@10 __int64 v5; // rbx@10 __int64 v6; // [sp+0h] [bp-40h]@0 int i; // [sp+4h] [bp-3Ch]@7 FILE *stream; // [sp+8h] [..
[2019红帽杯]CHILDRE(c++逆向+函数调用约定+c++修饰符转换+异或+黑盒分析+爆破)
qq_54894802的博客
06-14 526
官方文档，大致可以知道这个函数的作用就是将我们的flag进行转换，转换成了c++函数模式。也就是说我们的flag就是outoutstring，这个函数的。了解之后，我们可以将未转换的outoutstring得出：?我们输入31个有序数据，12345ABCDEFGHIJKLMNOPQRSTUWXYZ，对于这一堆函数，我们进行动态调试,我们输入有序字母。通过这里，我们可以判断出我们的flag有着31位。进入这个函数，我们可以发现。
[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...
[2019红帽杯]xx
最新发布
2302_79135465的博客
05-21 314
main函数一大串，只能一点点慢慢分析。2.取前四位扩展作为XXTEA加密密钥。这个异或太多变量了，不好分析。4.将加密后字符串打乱顺序。然后就是XXTEA的解密了。1.用户输入19位字符串。6.与存储数据进行对比。
BUU [2019红帽杯]childRE1
zzqzzq11的博客
01-17 2385
这个题目比较难，一开始看了一下没有头绪。 首先用ida打开： 很长的一个程序，一步一步仔细分析。 首先是第一部分，这一部分是先进行了输入，然后判断是否是31字节，将我们的输入使用sub_14001290()函数。这个函数，我一开始以为是一个加密函数，看起来挺复杂的。通过下面的sub_1400015C0(）函数有一些提示。if(v4)下面的部分完全就是一个后序遍历嘛？所以说，这个函数可以猜测是构造二叉树的函数。(下面第二张图是后序遍历的代码)。 但是有个问题，这个sub_140001...
C语言自定义函数作为函数的参数
今晚看星星的博客
11-21 2436
文章目录函数作为参数函数作为参数的使用 函数作为参数 函数作为参数的时候，需要声明函数的结构 一般的形式为: func(T (*func)(V args)) 使用的时候，直接使用对应参数类型的函数名即可 函数的名字就是指向内存函数开始执行时的指针，因此可以直接进行赋值 函数作为参数的使用 #include<iostream> using namespace std; void fun(int* a, int *b) { int tmp = *a; *a = *b;
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
基于卷积神经网络的图像分类
weixin_36670529的博客
06-02 8486
目录 一、常用的卷积神经网络概述 二、基础的神经网络 三、卷积神经网络 四、AlexNet 五、NiN 六、VGG 七、GoogleNet 1、Inception V1 2、Inception V2 3、Inception V3 4、Inception V4 八、ResNet 九、ResNeXt 十、性能比较 十一、CNN的设计准则 一、常用的卷积神经网络概述 ...
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...
xctf攻防世界 REVERSE 薪手练习区（二）
l8947943的博客
03-22 2126
6. re1 进入环境，下载附件后发现给出的是一个exe文件，运行一下如图： 6.1 查看文件 我们用Exeinfo PE打开查看文件信息，如图： 没有加壳，丢入IDA Pro中： 6.2 反编译 对mian函数进行反编译（这个反编译好坑，一定要用IDA32位的程序打开才行，MD搞了好久） int __cdecl main(int argc, const char **argv, const char **envp) { int v3; // eax __int128 v5; // [esp+
一道简单的smc自解密题目
m0_62690279的博客
03-27 1037
一道简单的smc自解密题目 攻防RE_BABYRE 64位elf，拉入ida 打开main函数 int __cdecl main(int argc, const char **argv, const char **envp) { char s[24]; // [rsp+0h] [rbp-20h] BYREF int v5; // [rsp+18h] [rbp-8h] int i; // [rsp+1Ch] [rbp-4h] for ( i = 0; i <= 181; ++i )
逆向题解二
admin的博客
09-12 2771
MoeCTF新生赛逆向A_game step1： 先探探这个exe的底 拉到die里头。发现是个64位程序。 step2：拉到IDA64里面反编译瞅瞅源码 按F5，反编译的源码如下。 // local variable allocation has failed, the output may be wrong! int __cdecl main(int argc, const char **argv, const char **envp) { int v3; // ...
BUUCTF pwn wp 11 - 15
fa1c4的blog
08-17 416
ciscn_2019_n_8 int __cdecl main(int argc, const char **argv, const char **envp) { int v4; // [esp-14h] [ebp-20h] int v5; // [esp-10h] [ebp-1Ch] var[13] = 0; var[14] = 0; init(); puts("What's your name?"); __isoc99_scanf("%s", var, v4, v5);
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、付费专栏及课程。

余额充值