[MRCTF2020]EasyCpp

最新推荐文章于 2023-11-25 17:08:40 发布
最新推荐文章于 2023-11-25 17:08:40 发布
阅读量952 收藏 3
点赞数 2
分类专栏： CTF-RE 文章标签： c++ 指针 python 安全
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46296905/article/details/115904045
版权

题目：[MRCTF2020]EasyCpp

这题是一个用g++编译的C++逆向题，第一次碰到这种类型，边做边学习吧。
因为是初次接触C++逆向，如有不足，欢迎评论区指正。

一、main

IDA64查看main函数的伪代码如下，各个反汇编后伪代码的注释也已经给出，仅供参考：

int __cdecl main(int argc, const char **argv, const char **envp)
{
  __int64 v3; // rax
  __int64 v4; // rbx
  __int64 v5; // rax
  char v6; // bl
  __int64 v7; // rax
  __int64 v8; // rax
  __int64 v9; // rax
  __int64 v10; // rax
  __int64 v11; // rax
  __int64 v12; // rax
  char v14[40]; // [rsp+0h] [rbp-140h] BYREF
  __int64 v15; // [rsp+28h] [rbp-118h] BYREF
  __int64 v16; // [rsp+30h] [rbp-110h] BYREF
  int v17; // [rsp+3Ch] [rbp-104h] BYREF
  char v18[32]; // [rsp+40h] [rbp-100h] BYREF
  char v19[48]; // [rsp+60h] [rbp-E0h] BYREF
  char v20[31]; // [rsp+90h] [rbp-B0h] BYREF
  char v21; // [rsp+AFh] [rbp-91h] BYREF
  char v22[47]; // [rsp+B0h] [rbp-90h] BYREF
  char v23; // [rsp+DFh] [rbp-61h] BYREF
  char v24[36]; // [rsp+E0h] [rbp-60h] BYREF
  int v25; // [rsp+104h] [rbp-3Ch]
  char *v26; // [rsp+108h] [rbp-38h]
  int *v27; // [rsp+110h] [rbp-30h]
  _DWORD *v28; // [rsp+118h] [rbp-28h]
  int *v29; // [rsp+120h] [rbp-20h]
  int i; // [rsp+128h] [rbp-18h]
  unsigned int v31; // [rsp+12Ch] [rbp-14h]

  v31 = 0;
  
  /*创建一个int型容器*/
  std::vector<int>::vector(v20, argv, envp);  
  
  /*创建一个bool型容器*/  
  std::vector<bool>::vector(v19);    
             
  /*构建一个字符串变量*/
  std::allocator<char>::allocator(&v21);        
  std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::basic_string(v18, &unk_500E, &v21);
  // 构造函数，中间那个basic_string<char,std::char_traits<char>,std::allocator<char>>是类模板，后面那个basic_string函数名表明这个函数是构造函数。
  std::allocator<char>::~allocator(&v21);
  
  /*输出字符串"give me your key!\n"*/
  v3 = std::operator<<<std::char_traits<char>>(&std::cout, "give me your key!");
  std::ostream::operator<<(v3, &std::endl<char,std::char_traits<char>>);
  
  /*输入的数据存入keys[]数组*/
  for ( i = 0; i <= 8; ++i )
  {
    std::istream::operator>>(&std::cin, &keys[i]);
    //调用string头文件里的to_string全局函数，把输入的数据转为字符的形式存到v22中
    std::__cxx11::to_string(v22, keys[i]);
    //调用string头文件里basic_string类模板中的operator+函数把输入的数据存入v18
    std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::operator+=(v18, v22);
    //调用string头文件里basic_string类模板中的析构函数
    std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::~basic_string(v22);
  }
  
  v28 = keys;
  v29 = keys;
  v27 = &unk_83E4;
  while ( v29 != v27 )
  {
    v17 = *v29;
    //将输入的压入v20容器
    std::vector<int>::push_back(v20, &v17);
    ++v29;
  }
  
  /*获取容器尾指针*/
  v4 = std::vector<int>::end(v20);
  
  /*获取容器头指针*/
  v5 = std::vector<int>::begin(v20);

  /*调用for_each函数模板对从头指针到尾指针的每一项执行lambda函数*/
  std::for_each<__gnu_cxx::__normal_iterator<int *,std::vector<int>>,main::{lambda(int &)#1}>(v5, v4);

  /*这里是一样的获取头尾指针*/
  v26 = v20;
  v16 = std::vector<int>::begin(v20);
  v15 = std::vector<int>::end(v26);

  //while循环的条件用的是gcc编译器的使用的C++库中定义的命名空间__gnu_cxx，其实是判断头尾指针是否相同。
  while ( __gnu_cxx::operator!=<int *,std::vector<int>>(&v16, &v15) )
  {
    //取v16指向的地址中的值存入v25
    v25 = *__gnu_cxx::__normal_iterator<int *,std::vector<int>>::operator*(&v16);
   
    /*创建字符串变量v14*/
    std::allocator<char>::allocator(&v23);
    std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::basic_string(v14, &unk_500E, &v23);
    std::allocator<char>::~allocator(&v23);
  
    //加密后结果放到v14中
    depart(v25, v14);
  
    {lambda(std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>> &)#1}::operator()(&func, v14);
    
    std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::basic_string(v24, v14);
    v6 = {lambda(std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>,int)#2}::operator()(
           &check,
           v24,
           v31) ^ 1;
    std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::~basic_string(v24);
    
    if ( v6 )
    {
      v7 = std::operator<<<std::char_traits<char>>(&std::cout, "Wrong password!");
      std::ostream::operator<<(v7, &std::endl<char,std::char_traits<char>>);
      system("pause");
      exit(0);
    }
    ++v31;
    std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::~basic_string(v14);
    __gnu_cxx::__normal_iterator<int *,std::vector<int>>::operator++(&v16);
  }

  /*下面就是告诉我们md5加密（32位大写）后的v18就是flag*/
  v8 = std::operator<<<std::char_traits<char>>(&std::cout, "right!");
  std::ostream::operator<<(v8, &std::endl<char,std::char_traits<char>>);
  v9 = std::operator<<<std::char_traits<char>>(&std::cout, "flag:MRCTF{md5(");
  v10 = std::operator<<<char>(v9, v18);
  v11 = std::operator<<<std::char_traits<char>>(v10, ")}");
  std::ostream::operator<<(v11, &std::endl<char,std::char_traits<char>>);
  v12 = std::operator<<<std::char_traits<char>>(
          &std::cout,
          "md5()->{32/upper case/put the string into the function and transform into md5 hash}");
  std::ostream::operator<<(v12, &std::endl<char,std::char_traits<char>>);
  system("pause");
  std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::~basic_string(v18);
  std::vector<bool>::~vector(v19);
  std::vector<int>::~vector(v20);
  return 0;
}

二、depart

接下来看一下depart函数的伪代码。
其实看到这个函数的第一个循环我就想到了之前大一学C语言的时候学到的素数判断的算法，利用的数学原理如下：

待测试的数num只需要界于2到num的平方根之间的所有数，看它们是否可以整除num。

  • 如果可以整除，说明输入的数不是素数；
  • 如果不可整除，说明输入的数是素数。

就这个函数而言，可以发现，每找到一个因数就把除过后的数再进入depart找一次因数，可以看出是对数据的分解，把一个数分解成素因子的乘积，各因子间用空格分隔组合成字符串。

__int64 __fastcall depart(int a1, __int64 a2)
{
  char v3[32]; // [rsp+20h] [rbp-60h] BYREF
  char v4[40]; // [rsp+40h] [rbp-40h] BYREF
  int i; // [rsp+68h] [rbp-18h]
  int v6; // [rsp+6Ch] [rbp-14h]

  /*分解成素因数*/
  v6 = a1;
  for ( i = 2; std::sqrt<int>(a1) >= i; ++i )
  {
    if ( !(a1 % i) )
    {
      v6 = i;
      depart(a1 / i, a2);
      break;
    }
  }
  
  //运算后转换成字符串v4
  std::__cxx11::to_string(v4, v6);
  
  //合并&unk_500C（空格）和v4
  std::operator+<char>(v3, &unk_500C, v4);
  
  std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::operator+=(a2, v3);
  std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::~basic_string(v3);
  return std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::~basic_string(v4);
}

三、3个lambda

我们接下来对下面这三个lambda函数进行分析。
在这里插入图片描述

（一）

__int64 __fastcall std::for_each<__gnu_cxx::__normal_iterator<int *,std::vector<int>>,main::{lambda(int &)#1}>(__int64 a1, __int64 a2)
{
  unsigned int v2; // ebx
  __int64 v3; // rax
  char v5; // [rsp+Fh] [rbp-21h] BYREF
  __int64 v6; // [rsp+10h] [rbp-20h] BYREF
  __int64 v7[3]; // [rsp+18h] [rbp-18h] BYREF

  v7[0] = a1;
  v6 = a2;
  //循环条件是利用重载运算符判断两个是否相等
  while ( __gnu_cxx::operator!=<int *,std::vector<int>>(v7, &v6) )
  {
  //取头指针v7的值
    v3 = __gnu_cxx::__normal_iterator<int *,std::vector<int>>::operator*(v7);
    
    main::{lambda(int &)#1}::operator()(&v5, v3);
    
    //头指针移动
    __gnu_cxx::__normal_iterator<int *,std::vector<int>>::operator++(v7);
  }
  return v2;
}

里面还嵌套了一个lambda函数：

_DWORD *__fastcall main::{lambda(int &)#1}::operator()(__int64 a1, _DWORD *a2)
{
  _DWORD *result; // rax

  result = a2;
  *a2 ^= 1u;
  return result;
}

可以看出是对每一项进行与1异或的操作。

（二）

进入第二个lambda函数，看着像是替换。

__int64 __fastcall {lambda(std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>> &)#1}::operator()(__int64 a1, __int64 a2)
{
  __int64 v2; // rbx
  __int64 v3; // rax
  __int64 v4; // rbx
  __int64 v5; // rax
  __int64 v6; // rbx
  __int64 v7; // rax
  __int64 v8; // rbx
  __int64 v9; // rax
  __int64 v10; // rbx
  __int64 v11; // rax
  __int64 v12; // rbx
  __int64 v13; // rax
  __int64 v14; // rbx
  __int64 v15; // rax
  __int64 v16; // rbx
  __int64 v17; // rax
  __int64 v18; // rbx
  __int64 v19; // rax
  __int64 v20; // rbx
  __int64 v21; // rax
  __int64 v22; // rbx
  __int64 v23; // rax
  char v25; // [rsp+1Ah] [rbp-26h] BYREF
  char v26; // [rsp+1Bh] [rbp-25h] BYREF
  char v27; // [rsp+1Ch] [rbp-24h] BYREF
  char v28; // [rsp+1Dh] [rbp-23h] BYREF
  char v29; // [rsp+1Eh] [rbp-22h] BYREF
  char v30; // [rsp+1Fh] [rbp-21h] BYREF
  char v31; // [rsp+20h] [rbp-20h] BYREF
  char v32; // [rsp+21h] [rbp-1Fh] BYREF
  char v33; // [rsp+22h] [rbp-1Eh] BYREF
  char v34; // [rsp+23h] [rbp-1Dh] BYREF
  char v35; // [rsp+24h] [rbp-1Ch] BYREF
  char v36; // [rsp+25h] [rbp-1Bh] BYREF
  char v37; // [rsp+26h] [rbp-1Ah] BYREF
  char v38; // [rsp+27h] [rbp-19h] BYREF
  char v39; // [rsp+28h] [rbp-18h] BYREF
  char v40; // [rsp+29h] [rbp-17h] BYREF
  char v41; // [rsp+2Ah] [rbp-16h] BYREF
  char v42; // [rsp+2Bh] [rbp-15h] BYREF
  char v43; // [rsp+2Ch] [rbp-14h] BYREF
  char v44; // [rsp+2Dh] [rbp-13h] BYREF
  char v45; // [rsp+2Eh] [rbp-12h] BYREF
  char v46[17]; // [rsp+2Fh] [rbp-11h] BYREF

  v25 = 'O';
  v26 = '0';
  v2 = std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::end(a2);
  v3 = std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::begin(a2);
  std::replace<__gnu_cxx::__normal_iterator<char *,std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>>,char>(
    v3,
    v2,
    &v26,
    &v25);
  v27 = 'l';
  v28 = '1';
  v4 = std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::end(a2);
  v5 = std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::begin(a2);
  std::replace<__gnu_cxx::__normal_iterator<char *,std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>>,char>(
    v5,
    v4,
    &v28,
    &v27);
  v29 = 'z';
  v30 = '2';
  v6 = std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::end(a2);
  v7 = std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::begin(a2);
  std::replace<__gnu_cxx::__normal_iterator<char *,std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>>,char>(
    v7,
    v6,
    &v30,
    &v29);
  v31 = 69;
  v32 = 51;
  v8 = std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::end(a2);
  v9 = std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::begin(a2);
  std::replace<__gnu_cxx::__normal_iterator<char *,std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>>,char>(
    v9,
    v8,
    &v32,
    &v31);
  v33 = 'A';
  v34 = '4';
  v10 = std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::end(a2);
  v11 = std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::begin(a2);
  std::replace<__gnu_cxx::__normal_iterator<char *,std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>>,char>(
    v11,
    v10,
    &v34,
    &v33);
  v35 = 's';
  v36 = '5';
  v12 = std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::end(a2);
  v13 = std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::begin(a2);
  std::replace<__gnu_cxx::__normal_iterator<char *,std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>>,char>(
    v13,
    v12,
    &v36,
    &v35);
  v37 = 'G';
  v38 = '6';
  v14 = std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::end(a2);
  v15 = std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::begin(a2);
  std::replace<__gnu_cxx::__normal_iterator<char *,std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>>,char>(
    v15,
    v14,
    &v38,
    &v37);
  v39 = 'T';
  v40 = '7';
  v16 = std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::end(a2);
  v17 = std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::begin(a2);
  std::replace<__gnu_cxx::__normal_iterator<char *,std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>>,char>(
    v17,
    v16,
    &v40,
    &v39);
  v41 = 'B';
  v42 = '8';
  v18 = std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::end(a2);
  v19 = std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::begin(a2);
  std::replace<__gnu_cxx::__normal_iterator<char *,std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>>,char>(
    v19,
    v18,
    &v42,
    &v41);
  v43 = 'q';
  v44 = '9';
  v20 = std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::end(a2);
  v21 = std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::begin(a2);
  std::replace<__gnu_cxx::__normal_iterator<char *,std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>>,char>(
    v21,
    v20,
    &v44,
    &v43);
  v45 = '=';
  v46[0] = ' ';
  v22 = std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::end(a2);
  v23 = std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::begin(a2);
  return std::replace<__gnu_cxx::__normal_iterator<char *,std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>>,char>(
           v23,
           v22,
           v46,
           &v45);
}

看看这个replace函数是怎么替换的。如下：

__int64 __fastcall std::replace<__gnu_cxx::__normal_iterator<char *,std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>>,char>(__int64 a1, __int64 a2, _BYTE *a3, _BYTE *a4)
{
  __int64 result; // rax
  __int64 v7; // [rsp+10h] [rbp-10h] BYREF
  __int64 v8; // [rsp+18h] [rbp-8h] BYREF

  v8 = a1;
  v7 = a2;
  while ( 1 )
  {
    result = __gnu_cxx::operator!=<char *,std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>>(
               &v8,
               &v7);
    if ( !result )
      break;
    if ( *__gnu_cxx::__normal_iterator<char *,std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>>::operator*(&v8) == *a3 )
      *__gnu_cxx::__normal_iterator<char *,std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>>::operator*(&v8) = *a4;
    __gnu_cxx::__normal_iterator<char *,std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>>::operator++(&v8);
  }
  return result;
}

原来是对应替换，比如说，如果是0就变成了O，差不多这样的意思。

（三）

紧接着的lambda是一个检查函数，把加密后的字符串与一个已知字符串ans[abi:cxx11]做对比。

_BOOL8 __fastcall {lambda(std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>,int)#2}::operator()(__int64 a1, __int64 a2, int a3)
{
  const char *v3; // rbx
  const char *v4; // rax

  //调用basic_string类模板中的c_str函数把字符串转化为C语言的字符串，目的是为了接下来用strcmp函数。【兼容性考虑】
  v3 = std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::c_str(&ans[abi:cxx11] + 32 * a3);
  v4 = std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::c_str(a2);
  return strcmp(v4, v3) == 0;
}

我们现在来找这个已知字符串ans[abi:cxx11]。选中那个按X查看交叉引用，双击进入到函数。
在这里插入图片描述

int __fastcall __static_initialization_and_destruction_0(int a1, int a2)
{
  int result; // eax
  char v3; // [rsp+17h] [rbp-29h] BYREF
  char v4; // [rsp+18h] [rbp-28h] BYREF
  char v5; // [rsp+19h] [rbp-27h] BYREF
  char v6; // [rsp+1Ah] [rbp-26h] BYREF
  char v7; // [rsp+1Bh] [rbp-25h] BYREF
  char v8; // [rsp+1Ch] [rbp-24h] BYREF
  char v9; // [rsp+1Dh] [rbp-23h] BYREF
  char v10; // [rsp+1Eh] [rbp-22h] BYREF
  char v11[33]; // [rsp+1Fh] [rbp-21h] BYREF

  if ( a1 == 1 && a2 == 0xFFFF )
  {
    std::ios_base::Init::Init(&std::__ioinit);
    __cxa_atexit(&std::ios_base::Init::~Init, &std::__ioinit, &_dso_handle);
    std::allocator<char>::allocator(&v3);
    std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::basic_string(
      &ans[abi:cxx11],
      "=zqE=z=z=z",
      &v3);
    std::allocator<char>::~allocator(&v3);
    std::allocator<char>::allocator(&v4);
    std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::basic_string(
      &ans[abi:cxx11] + 32,
      "=lzzE",
      &v4);
    std::allocator<char>::~allocator(&v4);
    std::allocator<char>::allocator(&v5);
    std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::basic_string(
      &ans[abi:cxx11] + 64,
      "=ll=T=s=s=E",
      &v5);
    std::allocator<char>::~allocator(&v5);
    std::allocator<char>::allocator(&v6);
    std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::basic_string(
      &ans[abi:cxx11] + 96,
      "=zATT",
      &v6);
    std::allocator<char>::~allocator(&v6);
    std::allocator<char>::allocator(&v7);
    std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::basic_string(
      &ans[abi:cxx11] + 128,
      "=s=s=s=E=E=E",
      &v7);
    std::allocator<char>::~allocator(&v7);
    std::allocator<char>::allocator(&v8);
    std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::basic_string(
      &ans[abi:cxx11] + 160,
      "=EOll=E",
      &v8);
    std::allocator<char>::~allocator(&v8);
    std::allocator<char>::allocator(&v9);
    std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::basic_string(
      &ans[abi:cxx11] + 192,
      "=lE=T=E=E=E",
      &v9);
    std::allocator<char>::~allocator(&v9);
    std::allocator<char>::allocator(&v10);
    std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::basic_string(
      &ans[abi:cxx11] + 224,
      "=EsE=s=z",
      &v10);
    std::allocator<char>::~allocator(&v10);
    std::allocator<char>::allocator(v11);
    std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::basic_string(
      &ans[abi:cxx11] + 256,
      "=AT=lE=ll",
      v11);
    std::allocator<char>::~allocator(v11);
    result = __cxa_atexit(_tcf_0, 0LL, &_dso_handle);
  }
  return result;
}

都是很简单的初始化操作。很容易得到ans[abi:cxx11]。
分析完毕，梳理一下，对输入的9个数据先每项与1异或，然后遍历每项分解成素因子，排布，变成字符串之后（比如0 -> ‘0’）做替换然后与已有字符串作比较。
现在开始写Exp。

EXP

贴上我写的exp:

str1 = ["=zqE=z=z=z", "=lzzE", "=ll=T=s=s=E", "=zATT", "=s=s=s=E=E=E", "=EOll=E","=lE=T=E=E=E", "=EsE=s=z", "=AT=lE=ll"]
flagdata = [1,1,1,1,1,1,1,1,1]
flag=""
for i in range(len(str1)):
    k = -1
    str1[i] = str1[i].replace("O", "0")
    str1[i] = str1[i].replace("l", "1")
    str1[i] = str1[i].replace("z", "2")
    str1[i] = str1[i].replace("E", "3")
    str1[i] = str1[i].replace("A", "4")
    str1[i] = str1[i].replace("s", "5")
    str1[i] = str1[i].replace("G", "6")
    str1[i] = str1[i].replace("T", "7")
    str1[i] = str1[i].replace("B", "8")
    str1[i] = str1[i].replace("q", "9")
    str1[i] = str1[i].replace("=", " ")
    str1[i] += ' '
    a = []
    x = 0
    for j in str1[i]:
        if j == ' ':
            a.append(x)
            k += 1
            x = 0
            continue
        x = 10 * x + int(j)
    for b in range(1,len(a)):
        flagdata[i] *= a[b]
for i in range(len(flagdata)):
    flag+=str(flagdata[i] ^ 1)
print(flag)

别的博主的exp:

strs=["=zqE=z=z=z","=lzzE","=ll=T=s=s=E","=zATT","=s=s=s=E=E=E","=EOll=E","=lE=T=E=E=E","=EsE=s=z","=AT=lE=ll"]
def replacediy(str):
    str=str.replace("O","0")
    str=str.replace("l","1")
    str=str.replace("z","2")
    str=str.replace("E","3")
    str=str.replace("A","4")
    str=str.replace("s","5")
    str=str.replace("G","6")
    str=str.replace("T","7")
    str=str.replace("B","8")
    str=str.replace("q","9")
    str=str.replace("="," ")
    return str
flag=""
for i in strs:
    tmp=replacediy(i).split(" ")[1:]
    print tmp
    sum=1
    for j in range(len(tmp)):
        sum*=int(tmp[j],10)
    sum^=1
    flag+=str(sum)
print flag

用了split函数进行数值划分，这是我没想到的。。。。。

最后是md5加密，32位大写，这里我直接用模块来加密了，exp如下：

import hashlib
m=hashlib.md5()
str1="234512225774247633749032245635316720"
m.update(str1.encode('utf-8'))
print(m.hexdigest())

在这里插入图片描述
最后的flag就是

flag{4367FB5F42C6E46B2AF79BF409FB84D3}

相关参考与拓展：

1.有关注释中的知识，可以参考：

2.特别的，有关C++中c_str函数参考C++中的C_str()函数

Em0s_Er1t
关注
专栏目录
BUUCTF------mrctf2020_easyoverflow
qq_33010875的博客
10-08 391
环境：WSL2，ubuntu16.04，python2 checksec文件： 拖入ida分析： main函数中就有system(‘bin/sh’)，只要check函数的返回值为1即可执行 查看check函数： 只要a1和fake_flag相等，函数就能返回1 a1就是main函数里的v5，值为：ju3t_@_f@k3_f1@g fake_flag的值为：n0t_r3@11y_f1@g 只要将v5的值覆盖为n0t_r3@11y_f1@g即可 main函数中有get函数可用， v4： v4是var_
buu-[MRCTF2020]Xor
qaq517384的博客
03-06 374
32位无壳 执行 ida查看字符串
buu [MRCTF2020]EasyCpp
YenKoc的博客
04-17 808
上次没写出，这次认真分析了一下，发现自己的调试水平也有了上涨，也看了一些C++逆向的文章，尤其是stl，发现C++的oop还是挺复杂，这题还没考啥虚函数的还行了。 一.拖入ida，找到主函数，还是挺容易的 int __cdecl main(int argc, const char **argv, const char **envp) { double v3; // xmm0_8 __int...
CTF逆向-[MRCTF2020]EasyCpp - C++类型的逆向通用操作方法
serfend's blog
04-26 1380
CTF逆向-[MRCTF2020]EasyCpp - C++类型的逆向通用操作方法 来源：https://buuoj.cn/ 内容： 附件：链接：https://pan.baidu.com/s/1wbB31ubefyD0B4cMSZxLyQ?pwd=2qmr 提取码：2qmr 答案：flag{4367FB5F42C6E46B2AF79BF409FB84D3} 总体思路 打开发现是cpp的逆向 正常f5查看伪代码以后逐个向下分析其逻辑 发现主要加密和变换逻辑以后编写逆向逻辑的脚本 注意审题是md5+大写 此
[buuctf.reverse] 092_[MRCTF2020]EasyCpp
weixin_52640415的博客
05-14 332
c++
从零开始做题：[MRCTF2020]不眠之夜-wp
最新发布
weixin_44626085的博客
11-25 1177
从观察题目发现有121张图片，其中1张是损坏的，需要先删除查看发现每张图片的像素大小是200x100（长X高）查看相关信息发现此题涉及到gaps和montage的联合使用montage的作用是把乱序图片先按的总大小拼成一张图gaps的作用是将一张图按指定的size切割并尝试将其拼好。
[MRCTF2020]Hello_ misc
zip471642048的博客
07-28 807
把这些值转化为二进制，提取前两位，得到rar的解压密码rar-passwd0ac1fe6b77be5dbe。打开发现这个zip文件也是有密码的，trytorestoreit.png这个图片里面还有一张图片。解压flag.rar文件得到一个fffflag.zip，发现是docx文件，用pdf打开，修改字体颜色。base64多行解密，替换1为空格得到flagflag{He1Lo_mi5c~}解压第一个提取出来的zip文件,得到一个txt文件。......
[MRCTF2020]Ezpop-1|php序列化
「 虚幻私塾」
06-30 497
1、打开题目获取到源代码信息，如下： 2、我们的最终目标是获取flag.php中的flag信息，因此分析源代码信息，查看哪里可以获取到flag.php文件，发现在Modifier类中存在include($value)，因此想到可以通过php伪协议来获取flag.php的信息，所以现在我们的目的就成了调用append函数，接着往下观察，发现__invoke函数调用了append函数，因此我们只要执行了__invoke函数一样可以获得flag信息，那该怎么执行__invoke函数呢：因此，此时我们应该使用别的函
[MRCTF2020]hello_world_go-buuctf
Lenard404的博客
03-14 4378
Go语言的二进制文件，简单的明文flag，应该是Go逆向的引进门题目
mrctf2020_easyrop
z1r0的博客
04-10 401
mrctf2020_easyrop 查看保护 简单题 用hehe和byby这两个函数配合起来rop就行 from pwn import * from time import sleep context(arch='amd64', os='linux', log_level='debug') file_name = './z1r0' li = lambda x : print('\x1b[01;38;5;214m' + x + '\x1b[0m') ll = lambda x : print('\x1
MRCTF2020 Ezpop
Tajang的大千世界
07-10 581
打开靶机，哇，直接给源码 这道题的知识点是利用php魔术方法的相互关联，构造pop链，其实有的地方没太懂，群里Y1ng大佬还回复我了，好兴奋，这题他的wp也看过，接下来就按我的理解写 知道我对这道题理解多么蠢吗？简直蠢得不可理喻，我以为代码审计，读懂代码会和上次绕过一样的类型，后来证明我真的蠢，给大家看看我的代码审计 我是真得蠢。。。不说了，先来讲一波php魔术方法 __construct 当一个对象创建时被调用， __toString 当一个对象被当作一个字符串被调用。 __wakeup
XCTF easyCpp
万丈⾼楼平地起，勿在浮沙筑⾼台学艺不精的安全菜鸡，改行回家养猪了，对博客有疑问欢迎留言，看到一定回
03-18 512
查壳 无壳，64位Linux程序 放入IDA中分析 查看Main函数 这里拿加密后的用户输入和程序生成的前16个斐波那契数列进行对比 ，不相等则退出程序，相等的话则继续往下执行 所以说只需要逆推出input_encry是如何生成的，既可以得到flag 这里是把&input_begin存到&input_encry 从头开始分析&input_begin是如何生成的 这里...
[BUUCTF]PWN——mrctf2020_easyoverflow
mcmuyanga的博客
01-12 1047
mrctf2020_easyoverflow 附件 步骤： 例行检查，64位程序，保护全开 本地试运行的时候就直接一个输入，然后就没了，直接用64位ida打开 只要满足18行的条件，就能够获取shell check（） 很简单的检查，就是判断一下v5是否等于n0t_r3@11y_f1@g 看main函数可以知道，v5一开始是ju3t_@_f@k3_f1@g，之后没有对v5的操作了，然后让我们输入v4，看一下v4和v5在栈上的位置，发现v5就在v4下方不远处 v4的输入是用的gets函数，我们可以在
[BUUCTF-pwn]——mrctf2020_easyoverflow
Y_peak的博客
03-29 247
[BUUCTF-pwn]——mrctf2020_easyoverflow 题目不难这里就简单讲下思路 思路 因为check函数返回0才可以得到shell. 通过gets函数，我们可以将v5修改为我们想要的。 找到fake_flag 为n0t_r3@11y_f1@g 修改为这个就可以了。相同肯定返回0. exploit from pwn import * p = remote("node3.buuoj.cn",26609) payload = 'a'* 0x30 + "n0t_r3@11y_f1@g" p.s
BUUCTF(pwn)mrctf2020_easy_equation
半岛铁盒的博客
03-30 679
这道题是个相对简单的格式化字符串的题目, 但是做题过程中需要自己的一些debug调试查看; 计算偏移量 初看偏移量是8; 构建初始payload,EXP;payload="aa%8$n"+p64(judge) from pwn import* context.log_level='debug' p=remote('node3.buuoj.cn',27636) judge=0x60105c payload="aa%8$n"+p64(judge) p.sendline(payload) p.inter
mrctf2020_easyoverflow [write up]
m0_73756460的博客
01-14 300
buuctf 刷题 mrctf2020_easyoverflow [write up]
XCTF-攻防世界CTF平台-Reverse逆向类——53、easyCpp（Linux64位ELF文件、C++逆向）
Onlyone_1314的博客
09-25 1225
下载附件easyCpp，先查看文件信息： 是Linux下的64位ELF文件，运行程序： 是一个输入字符串然后判断是否正确的程序，错误就输入“You failed!” 之后用IDA64打开： main函数源代码及注释： int __cdecl main(int argc, const char **argv, const char **envp) { char v3; // r15 __int64 v4; // r12 __int64 v5; // rbx __int64 v6; //
攻防世界逆向高手题之easyCpp
沐一 · 林 的博客
10-06 619
攻防世界逆向高手题之easyCpp 继续开启全栈梦想之逆向之旅~ 这题是攻防世界逆向高手题的easyCpp . . 下载附件，解压缩包，照例扔入exeinfope中查看信息： . . 64位ELF文件，无壳，照例运行一下程序，看看主要回显信息： . . 一开始啥也没有，就一直乱输入，然后弹出个you failed字符串，信息够了。照例扔入IDA64中查看伪代码，有main函数看main函数：（这里我一开始分析时注释了一些代码，这并不影响） . . 一开始大致浏览了一下，发现很多的STL（标准模板库）
buuctf misc [MRCTF2020]ezmisc 1
05-16
这是一个关于MRCTF2020比赛的misc题目，题目名称为ezmisc 1。不知道你需要什么样的帮助，我可以给你一些关于此题的信息。 题目描述： There are some problems to solve! Each problem corresponds to a flag. ...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Em0s_Er1t

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

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

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

打赏作者

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

抵扣说明：

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

余额充值