[SUCTF2019]hardcpp

最新推荐文章于 2022-12-08 23:01:54 发布
最新推荐文章于 2022-12-08 23:01:54 发布
阅读量987 收藏 5
点赞数 2
分类专栏： CTF-RE 文章标签： 字符串 信息安全 windows 安全
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46296905/article/details/116358058
版权

题目：[SUCTF2019]hardcpp

64位ELF文件
在这里插入图片描述
ida64中打开发现有两处控制流平坦化。
在这里插入图片描述
在这里插入图片描述

装好angr，使用基于angr的脚本deflat.py去除控制流平坦化，在deflat.py所在目录下打开cmd命令行输入

python deflat.py hardCpp 0x4007E0   
#“python版本 + 脚本名 + 文件名 + 起始地址”

第二处控制流平坦化同理去除。

运行几分钟即可得到去除控制流平坦化之后的程序。
如果原版deflat.py出错，可以试试优化之后的deflat.py
在这里插入图片描述
ida64打开生成的hardCpp_recovered文件，出来的程序有很多混淆，但勉强可以看。

int __cdecl main(int argc, const char **argv, const char **envp)
{
  char v3; // al
  char v4; // al
  char v5; // al
  char v6; // al
  char v8; // al
  char v9; // al
  char v10; // al
  char v11; // al
  char v12[8]; // [rsp+A0h] [rbp-90h] BYREF
  char v13[8]; // [rsp+A8h] [rbp-88h] BYREF
  char v14[8]; // [rsp+B0h] [rbp-80h] BYREF
  char v15[8]; // [rsp+B8h] [rbp-78h] BYREF
  char v16[8]; // [rsp+C0h] [rbp-70h] BYREF
  char v17[7]; // [rsp+C8h] [rbp-68h] BYREF
  char v18; // [rsp+CFh] [rbp-61h]
  int v19; // [rsp+D0h] [rbp-60h]
  int v20; // [rsp+D4h] [rbp-5Ch]
  int v21; // [rsp+D8h] [rbp-58h]
  int v22; // [rsp+DCh] [rbp-54h]
  char s; // [rsp+E0h] [rbp-50h] BYREF
  char v24[23]; // [rsp+E1h] [rbp-4Fh] BYREF
  char v25[8]; // [rsp+F8h] [rbp-38h] BYREF
  char v26[8]; // [rsp+100h] [rbp-30h] BYREF
  char v27[8]; // [rsp+108h] [rbp-28h] BYREF
  char v28[4]; // [rsp+110h] [rbp-20h] BYREF
  int v29; // [rsp+114h] [rbp-1Ch]
  const char **v30; // [rsp+118h] [rbp-18h]
  int v31; // [rsp+120h] [rbp-10h]
  int v32; // [rsp+124h] [rbp-Ch]
  int v33; // [rsp+128h] [rbp-8h]
  bool v34; // [rsp+12Eh] [rbp-2h]

  v32 = 0;
  v31 = argc;
  v30 = argv;
  v29 = time(0LL);
  puts("func(?)=\"01abfc750a0c942167651c40d088531d\"?");// 01abfc750a0c942167651c40d088531d是'#'的md5散列，告诉我们第一个字符是#
  s = getchar();
  fgets(v24, 21, stdin);
  v22 = time(0LL);
  v21 = v22 - v29;                              // 0
  v33 = v22 - v29;                              // 0
  if ( y >= 10 && (((x - 1) * x) & 1) != 0 )
    goto LABEL_13;
  while ( 1 )
  {
    v20 = strlen(&s);
    v34 = v20 != 21;
    if ( y < 10 || (((x - 1) * x) & 1) == 0 )
      break;
LABEL_13:
    v20 = strlen(&s);
  }
  while ( 1 )
  {
    v19 = 1;
    if ( y < 10 || (((x - 1) * x) & 1) == 0 )
      break;
    v19 = 1;
  }
  while ( v19 < 21 )
  {
    if ( y >= 10 && (((x - 1) * x) & 1) != 0 )
    {
      v18 = v21 ^ *(&s + v19);                  // v18 = s[v19];
      v17[0] = main::$_0::operator()(v27, v18); // v17[0]=v18 = s[v19];后1个字符
      v16[0] = main::$_1::operator()(v25, *(&s + v21 + v19 - 1));// v16[0]=v18 = s[v19-1];前1个字符
      v8 = main::$_1::operator() const(char)::{lambda(int)#1}::operator()(v16, 7LL);// s[v19-1]%7
      v18 = main::$_0::operator() const(char)::{lambda(char)#1}::operator()(v17, v8);// 两个字符相加
      v15[0] = main::$_2::operator()(v28, v18); // 相加结果存入v15
      v14[0] = main::$_2::operator()(v28, *(&s + v21 + v19 - 1));// 前一个字符存入v14
      v9 = main::$_2::operator() const(char)::{lambda(char)#1}::operator()(v14, 18LL);// 前一个字符跟18异或
      v13[0] = main::$_3::operator()(v26, v9);  // 异或结果存入v13
      v10 = main::$_3::operator() const(char)::{lambda(char)#1}::operator()(v13, 3LL);// 再乘3
      v12[0] = main::$_0::operator()(v27, v10);
      v11 = main::$_0::operator() const(char)::{lambda(char)#1}::operator()(v12, 2LL);// 加上2
      v18 = main::$_2::operator() const(char)::{lambda(char)#1}::operator()(v15, v11);// 异或
    }
    do
    {
      v18 = v21 ^ *(&s + v19);
      v17[0] = main::$_0::operator()(v27, v18);
      v16[0] = main::$_1::operator()(v25, *(&s + v21 + v19 - 1));
      v3 = main::$_1::operator() const(char)::{lambda(int)#1}::operator()(v16, 7LL);
      v18 = main::$_0::operator() const(char)::{lambda(char)#1}::operator()(v17, v3);
      v15[0] = main::$_2::operator()(v28, v18);
      v14[0] = main::$_2::operator()(v28, *(&s + v21 + v19 - 1));
      v4 = main::$_2::operator() const(char)::{lambda(char)#1}::operator()(v14, 18LL);
      v13[0] = main::$_3::operator()(v26, v4);
      v5 = main::$_3::operator() const(char)::{lambda(char)#1}::operator()(v13, 3LL);
      v12[0] = main::$_0::operator()(v27, v5);
      v6 = main::$_0::operator() const(char)::{lambda(char)#1}::operator()(v12, 2LL);
      v18 = main::$_2::operator() const(char)::{lambda(char)#1}::operator()(v15, v6);
    }
    while ( enc[v19 - 1] != v18 );
    while ( y >= 10 && (((x - 1) * x) & 1) != 0 )
      ;
    ++v19;
  }
  if ( y >= 10 && (((x - 1) * x) & 1) != 0 )
    goto LABEL_16;
  while ( 1 )
  {
    puts("You win");
    if ( y < 10 || (((x - 1) * x) & 1) == 0 )
      break;
LABEL_16:
    puts("You win");
  }
  return 0;
}

while里面各个函数分析一下。前两个就算了。

main:😒 _1::operator() const(char)::{lambda(int)#1}::operator函数

v15 = *(&v5 - 16) + *v5是关键，等价于把两个字符串相加后返回。

__int64 __fastcall main::$_0::operator() const(char)::{lambda(char)#1}::operator()(__int64 a1, char a2)
{
  int v2; // eax
  int v3; // eax
  char *v5; // [rsp+0h] [rbp-40h]
  int v6; // [rsp+8h] [rbp-38h]
  int v7; // [rsp+Ch] [rbp-34h]
  int v8; // [rsp+10h] [rbp-30h]
  int v9; // [rsp+14h] [rbp-2Ch]
  char *v10; // [rsp+18h] [rbp-28h]
  char v11; // [rsp+23h] [rbp-1Dh]
  int v12; // [rsp+24h] [rbp-1Ch]
  bool v13; // [rsp+2Ah] [rbp-16h]
  bool v14; // [rsp+2Bh] [rbp-15h]
  unsigned int v15; // [rsp+2Ch] [rbp-14h]

  v13 = (((x_5 - 1) * x_5) & 1) == 0;
  v14 = y_6 < 10;
  v12 = 0x3D016016;
  v11 = a2;
  v10 = a1;
  do
  {
    while ( 1 )
    {
      while ( 1 )
      {
        while ( 1 )
        {
          v9 = v12;
          v8 = v12 + 2037067308;
          if ( v12 != -2037067308 )
            break;
          v5 = v10;
          *(&v5 - 16) = v11;
          v12 = -1418698808;
        }
        v7 = v9 + 1418698808;
        if ( v9 != -1418698808 )
          break;
        v3 = -2037067308;
        v5 = v10;
        *(&v5 - 16) = v11;
        v15 = *(&v5 - 16) + *v5;//关键
        if ( y_6 < 10 || (((x_5 - 1) * x_5) & 1) == 0 )
          v3 = 1456142001;
        v12 = v3;
      }
      v6 = v9 - 1023500310;
      if ( v9 != 1023500310 )
        break;
      v2 = -2037067308;
      if ( v14 || v13 )
        v2 = -1418698808;
      v12 = v2;
    }
    HIDWORD(v5) = v9 - 1456142001;
  }
  while ( v9 != 1456142001 );
  return v15;
}

main:😒_2::operator()函数，

只是单纯的把上一个函数的结果再返回。

char __fastcall main::$_2::operator()(__int64 a1, char a2)
{
  int v2; // eax
  int v3; // eax
  __int64 v5; // [rsp+0h] [rbp-50h]
  int v6; // [rsp+Ch] [rbp-44h]
  int v7; // [rsp+10h] [rbp-40h]
  int v8; // [rsp+14h] [rbp-3Ch]
  int v9; // [rsp+18h] [rbp-38h]
  int v10; // [rsp+1Ch] [rbp-34h]
  __int64 v11; // [rsp+20h] [rbp-30h]
  char v12; // [rsp+2Fh] [rbp-21h]
  int v13; // [rsp+30h] [rbp-20h]
  bool v14; // [rsp+35h] [rbp-1Bh]
  bool v15; // [rsp+36h] [rbp-1Ah]
  char v16; // [rsp+37h] [rbp-19h]

  v14 = (((x_11 - 1) * x_11) & 1) == 0;
  v15 = y_12 < 10;
  v13 = -1990873412;
  v12 = a2;
  v11 = a1;
  while ( 1 )
  {
    while ( 1 )
    {
      while ( 1 )
      {
        v10 = v13;
        v9 = v13 + 1990873412;
        if ( v13 != -1990873412 )
          break;
        v2 = -1373097315;
        if ( v15 || v14 )
          v2 = 1457028246;
        v13 = v2;
      }
      v8 = v10 + 1373097315;
      if ( v10 != -1373097315 )
        break;
      v5 = v11;
      *(&v5 - 16) = v12;
      LOBYTE(v5) = *(&v5 - 16);
      v13 = 1457028246;
    }
    v7 = v10 + 961146335;
    if ( v10 == -961146335 )
      break;
    v6 = v10 - 1457028246;
    if ( v10 == 1457028246 )
    {
      v3 = -1373097315;
      v5 = v11;
      *(&v5 - 16) = v12;
      LOBYTE(v5) = *(&v5 - 16);
      v16 = v5;
      if ( y_12 < 10 || (((x_11 - 1) * x_11) & 1) == 0 )
        v3 = -961146335;
      v13 = v3;
    }
  }
  return v16;
}

main:😒_2::operator() const(char)::{lambda(char)#1}::operator()函数

把第奇数个字符跟18异或。

__int64 __fastcall main::$_2::operator() const(char)::{lambda(char)#1}::operator()(_BYTE *a1, char a2)
{
  return (a2 ^ *a1);
}

main:😒_3::operator函数

把上一个函数异或的结果返回一下，跟main:😒_2::operator函数 “ 异曲同工 ” 。

char __fastcall main::$_3::operator()(__int64 a1, char a2)
{
  int v2; // eax
  int v3; // eax
  __int64 v5; // [rsp+0h] [rbp-50h]
  int v6; // [rsp+Ch] [rbp-44h]
  int v7; // [rsp+10h] [rbp-40h]
  int v8; // [rsp+14h] [rbp-3Ch]
  int v9; // [rsp+18h] [rbp-38h]
  int v10; // [rsp+1Ch] [rbp-34h]
  __int64 v11; // [rsp+20h] [rbp-30h]
  char v12; // [rsp+2Fh] [rbp-21h]
  int v13; // [rsp+30h] [rbp-20h]
  bool v14; // [rsp+35h] [rbp-1Bh]
  bool v15; // [rsp+36h] [rbp-1Ah]
  char v16; // [rsp+37h] [rbp-19h]

  v14 = (((x_15 - 1) * x_15) & 1) == 0;
  v15 = y_16 < 10;
  v13 = -538471561;
  v12 = a2;
  v11 = a1;
  while ( 1 )
  {
    while ( 1 )
    {
      v10 = v13;
      v9 = v13 + 2065325572;
      if ( v13 != -2065325572 )
        break;
      v5 = v11;
      *(&v5 - 16) = v12;
      LOBYTE(v5) = *(&v5 - 16);
      v13 = 975002192;
    }
    v8 = v10 + 983538015;
    if ( v10 == -983538015 )
      break;
    v7 = v10 + 538471561;
    if ( v10 == -538471561 )
    {
      v2 = -2065325572;
      if ( v15 || v14 )
        v2 = 975002192;
      v13 = v2;
    }
    else
    {
      v6 = v10 - 975002192;
      if ( v10 == 975002192 )
      {
        v3 = -2065325572;
        v5 = v11;
        *(&v5 - 16) = v12;
        LOBYTE(v5) = *(&v5 - 16);
        v16 = v5;
        if ( y_16 < 10 || (((x_15 - 1) * x_15) & 1) == 0 )
          v3 = -983538015;
        v13 = v3;
      }
    }
  }
  return v16;
}

main:😒_3::operator() const(char)::{lambda(char)#1}::operator()函数

与3相乘。

__int64 __fastcall main::$_3::operator() const(char)::{lambda(char)#1}::operator()(char *a1, char a2)
{
  return (a2 * *a1);
}

main:😒_0::operator函数

返回

char __fastcall main::$_0::operator()(__int64 a1, char a2)
{
  return a2;
}

main:😒_0::operator() const(char)::{lambda(char)#1}::operator()

__int64 __fastcall main::$_0::operator() const(char)::{lambda(char)#1}::operator()(__int64 a1, char a2)
{
  int v2; // eax
  int v3; // eax
  char *v5; // [rsp+0h] [rbp-40h]
  int v6; // [rsp+8h] [rbp-38h]
  int v7; // [rsp+Ch] [rbp-34h]
  int v8; // [rsp+10h] [rbp-30h]
  int v9; // [rsp+14h] [rbp-2Ch]
  char *v10; // [rsp+18h] [rbp-28h]
  char v11; // [rsp+23h] [rbp-1Dh]
  int v12; // [rsp+24h] [rbp-1Ch]
  bool v13; // [rsp+2Ah] [rbp-16h]
  bool v14; // [rsp+2Bh] [rbp-15h]
  unsigned int v15; // [rsp+2Ch] [rbp-14h]

  v13 = (((x_5 - 1) * x_5) & 1) == 0;
  v14 = y_6 < 10;
  v12 = 0x3D016016;
  v11 = a2;
  v10 = a1;
  do
  {
    while ( 1 )
    {
      while ( 1 )
      {
        while ( 1 )
        {
          v9 = v12;
          v8 = v12 + 2037067308;
          if ( v12 != -2037067308 )
            break;
          v5 = v10;
          *(&v5 - 16) = v11;
          v12 = -1418698808;
        }
        v7 = v9 + 1418698808;
        if ( v9 != -1418698808 )
          break;
        v3 = -2037067308;
        v5 = v10;
        *(&v5 - 16) = v11;
        v15 = *(&v5 - 16) + *v5;                // 关键
        if ( y_6 < 10 || (((x_5 - 1) * x_5) & 1) == 0 )
          v3 = 1456142001;
        v12 = v3;
      }
      v6 = v9 - 1023500310;
      if ( v9 != 1023500310 )
        break;
      v2 = -2037067308;
      if ( v14 || v13 )
        v2 = -1418698808;
      v12 = v2;
    }
    HIDWORD(v5) = v9 - 1456142001;
  }
  while ( v9 != 1456142001 );
  return v15;
}

main:😒_0::operator() const(char)::{lambda(char)#1}::operator()函数

参数相加后返回。

__int64 __fastcall main::$_0::operator() const(char)::{lambda(char)#1}::operator()(__int64 a1, char a2)
{
  int v2; // eax
  int v3; // eax
  char *v5; // [rsp+0h] [rbp-40h]
  int v6; // [rsp+8h] [rbp-38h]
  int v7; // [rsp+Ch] [rbp-34h]
  int v8; // [rsp+10h] [rbp-30h]
  int v9; // [rsp+14h] [rbp-2Ch]
  char *v10; // [rsp+18h] [rbp-28h]
  char v11; // [rsp+23h] [rbp-1Dh]
  int v12; // [rsp+24h] [rbp-1Ch]
  bool v13; // [rsp+2Ah] [rbp-16h]
  bool v14; // [rsp+2Bh] [rbp-15h]
  unsigned int v15; // [rsp+2Ch] [rbp-14h]

  v13 = (((x_5 - 1) * x_5) & 1) == 0;
  v14 = y_6 < 10;
  v12 = 0x3D016016;
  v11 = a2;
  v10 = a1;
  do
  {
    while ( 1 )
    {
      while ( 1 )
      {
        while ( 1 )
        {
          v9 = v12;
          v8 = v12 + 2037067308;
          if ( v12 != -2037067308 )
            break;
          v5 = v10;
          *(&v5 - 16) = v11;
          v12 = -1418698808;
        }
        v7 = v9 + 1418698808;
        if ( v9 != -1418698808 )
          break;
        v3 = -2037067308;
        v5 = v10;
        *(&v5 - 16) = v11;
        v15 = *(&v5 - 16) + *v5;                // 关键
        if ( y_6 < 10 || (((x_5 - 1) * x_5) & 1) == 0 )
          v3 = 1456142001;
        v12 = v3;
      }
      v6 = v9 - 1023500310;
      if ( v9 != 1023500310 )
        break;
      v2 = -2037067308;
      if ( v14 || v13 )
        v2 = -1418698808;
      v12 = v2;
    }
    HIDWORD(v5) = v9 - 1456142001;
  }
  while ( v9 != 1456142001 );
  return v15;
}

main:😒_2::operator() const(char)::{lambda(char)#1}::operator()

异或。

__int64 __fastcall main::$_2::operator() const(char)::{lambda(char)#1}::operator()(_BYTE *a1, char a2)
{
  return (a2 ^ *a1);
}

也就是说，每相邻两个字符进行加密操作，最后跟enc的字符相比较，得一个可知所有，而我们已经知道第一个字符是 ’ # '就可以写exp了

先整理一下enc数组。
在这里插入图片描述

enc[]={0xF3,0x2E,0x18,0x36,0xE1,0x4C,0x22,0xD1,0xF9,0x8C,0x40,0x76,0xF4,0x0E,0x0,0x05,0xA3,0x90,0x0E,0xA5}

EXP

enc=[0xf3,0x2e,0x18,0x36,0xe1,0x4c,0x22,0xd1,0xf9,0x8c,0x40,0x76,0xf4,0xe,0x0,0x5,0xa3,0x90,0xe,0xa5]
flag='#'
for i in range(0,20):
	flag+=chr(((enc[i]^((ord(flag[-1])^18)*3+2))-(ord(flag[-1])%7)) &0xff)
print(flag)

在这里插入图片描述

flag{mY-CurR1ed_Fns}
Em0s_Er1t
关注
专栏目录
[SUCTF 2019]CheckIn 1（详解）
qq_52843575的博客
12-12 6434
1.基础检测 进入页面是一个简单文件上传界面，正常上传文件，发现上传空内容的jpg文件显示（exif_imagetype:not image!），可知有内容检测，上传代码文件也发现后缀名过滤 开始抓包操作，因为后缀名验证，伪造文件属性也失效了，与此同时发现“?”被过滤了简单利用 2.解题关键 这道题解题关键在于怎样突破后缀名绕过，就得利用.user.ini文件留后门了 user.ini留后门原理 简单来说，就是利于.user.ini指定文件，在其当前目录下的文件执行时会将你指定的文件中的代码执行出
BUUCTF [SUCTF2019]Akira Homework
weixin_53349587的博客
01-02 772
程序中有多处反调试，还有两处check判断，如果两个check都通过的话，会生成一个dll文件，程序前面开启的新线程进入到这个dll文件中，最后一个aes得到flag。 主函数： 1.查壳： 64位，C++，无壳。 IDA64打开，发现程序有基址随机化，去除： 详细请参考：去除程序的基址随机化_皮皮蟹！的博客-CSDN博客 2. ...
SUCTF2019-hardCPP WP
qq_41252520的博客
09-08 867
前言 这两天参加了 NU1LCTF 和 ByteCTF ，签了到之后发现一题都做不出来 /(ㄒoㄒ)/~~ ，很受伤。所以打算回顾一下错过的 SUCTF2019 ，多积累经验和学习更多的技术。 分析 IDA打开，发现程序是 LLVM 编译的，还加了花指令，导致看起来非常绕。 坑爹的是还不能动态调试，只能静态分析了。过程难以描述，这里就贴一下正确的执行步骤吧： int __cdec...
[buuctf.reverse] 098_[SUCTF2019]hardcpp
weixin_52640415的博客
05-19 222
手工扁平化
[SUCTF2019]hardcpp_一道混淆题，熟悉控制流平坦化
Todog的博客
05-09 840
首先用IDA打开，发现有很多while(1),大量代码混淆其中 利用defalt进行控制流平坦化去混淆 找到主函数地址 好了 开始执行 输入 python .\defalt.py hardCpp 0x4007E0 等几分钟后会执行完毕 顺便说一下符号执行的原理 符号执行大概是将内存寄存器值当成未知变量就像设一个方程当成x往下执行遇到分支保存一下尝试各种分支执行到你想要的地方后续可以约束求解 好了，我们再打开 逻辑清晰很多了 进行分析 每...
CTF逆向-[SUCTF2019]hardcpp-使用优化过的deflat.py处理混淆的控制流并将cpp的lambda解析得到实际处理逻辑
serfend's blog
04-29 2313
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
buu刷题 [SUCTF2019]SignIn1
m0_56194555的博客
01-10 518
buu刷题 [SUCTF2019]SignIn1 冲冲冲！！！
BUUCTF RE [SUCTF2019] SignIn
Sanqiz的博客
10-19 2535
好 今日我们来刷ctf 查看文件发现是64位的文件 无壳 用ida64位打开它 发现gmpz_init_set_str，gmpz_powm这类函数 去搜一搜资料发现是GNU 高精度算法库 gmp文档资料 GMP(The GNU Multiple Precision Arithmetic Library)又叫GNU多精度算术库，是一个提供了很多操作高精度的大整数，浮点数的运算的算术库，几乎没有什么精度方面的限制，功能丰富。我刚接触到这个东西的时候是在学习PHP的过程中。GMP的主要目标应用领域是密码学的应
[SUCTF2019]REVERSE的hardcpp
沐一 · 林 的博客
03-17 814
[SUCTF2019]REVERSE的hardcpp . . 下载附件，照例扔入 exeinfope 中查看信息： . . 64 位 ELF 文件，无壳，照例运行一下查看主要回显信息： . . 照例扔入 IDA64 中查看信息，有 main 函数看 main 函数： . . 上面的变量名是被我注释过的，现在看一下那些有冗余代码运算函数的分析过程：（看到函数内有一堆大数基本都是冗余代码了） . . 所以一个 while 循环的逻辑就是： enc=((pre_single_flag%7)+
[羊城杯 2020]login [SUCTF2019]hardcpp
寻梦&之璐
06-03 6669
文章目录[羊城杯 2020]login思路：一个py编译的exe，需要解包，然后反编译成py文件1.解包：python pyinstxtractor.py login.exe提示：pyinstxtractor.py这玩意github 上很多，随便找2.进入文件夹，然后进行login版本hex填充用编辑工具010打开login和struct，进行对比，main前面缺少几个字节，我们直接将struct前面的几个字节复制到main上面去，再将login保存为pyc格式文件3.uncompyle6 login.py
堆栈解题练习二
weixin_44222568的博客
04-22 1797
惶惶乎如遗世独立，羽化而登仙。。。。。
逆向题解二
admin的博客
09-12 2869
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; // ...
一道简单的smc自解密题目
m0_62690279的博客
03-27 1095
一道简单的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 )
2022CTF培训（六）逆向题目选讲
最新发布
sky123博客
12-08 1297
分析可知，函数首先调用 sub_4017C0 初始化 v4 数组，之后根据 v4 数组中的内容依次调用 funcs_4018AB 数组中的函数对输入的 1 到 32 字节进行变换。通过改变断点位置可以判断出，该函数表中 sub_B232A0 函数的前一个函数 sub_AD1000 同样存在反调试。必然会触发除零异常，因此会执行 loc_4010BE 处的代码，将局部变量 a0 和 a1 分别异或 dword_41F038 和 dword_41F03C。并用魔改的 tea 对其进行加密。
[SUCTF 2019]EasySQL
weixin_45577185的博客
04-23 179
GitHub上有源码（https://github.com/team-su/SUCTF-2019/tree/master/Web/easy_sql） index.php源码 <?php session_start(); include_once "config.php"; $post = array(); $get = array(); global $MysqlLink; //GetPara(); $MysqlLi
RE入门题
qq_52964803的博客
03-26 774
RE入门题 题目 给了一个附件re 首先用Exeinfope看一下是多少位的 从图片中可以看出它是64位的,之后运行64位的ida 新建一个，将re文件拖进去，找到主函数main 按F5进行反编译，就可以看到该程序的伪代码： int __cdecl main(int argc, const char **argv, const char **envp) { char v4[32]; // [rsp+20h] [rbp-40h] BYREF _DWORD v5[6]; // [rsp+40h
[SUCTF 2019]Pythonginx
qq_42812036的博客
02-13 2361
0x00知识点 nginx配置 配置文件存放目录：/etc/nginx 主配置文件：/etc/nginx/conf/nginx.conf 管理脚本：/usr/lib64/systemd/system/nginx.service 模块：/usr/lisb64/nginx/modules 应用程序：/usr/sbin/nginx 程序默认存放位置：/usr/share/nginx/html 日志...
c语言格式化字符漏洞,格式化字符串漏洞题目练习
weixin_30111277的博客
05-22 932
整合一下最近做的格式化字符串题目的练习，把wp给写一下，方便对总结对这个漏洞的利用套路和技巧。inndy_echo保护和arch[*] '/media/psf/mypwn2/buuctf/inndy_echo/echo'Arch: i386-32-littleRELRO: Partial RELROStack: No canary foundNX: NX enabl...
简单逆向25
m0_49936845的博客
08-07 199
诺莫25 知识点: 亦或，查找 开始： 放入IDA: 通过字符串找到主函数 int __cdecl main(int argc, const char **argv, const char **envp) { __m128i *v3; // rsi __m128i *v4; // rdi __int64 v5; // rax int result; // eax unsigned __int64 v7; // rax __int64 v8; // rax __int64 v9;
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Em0s_Er1t

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

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

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

打赏作者

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

抵扣说明：

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

余额充值