CTF逆向-[NPUCTF2020]Baby Obfuscation-逆向思维编写脚本以及函数含义的逻辑理解

最新推荐文章于 2024-05-16 14:52:00 发布
最新推荐文章于 2024-05-16 14:52:00 发布
阅读量737 收藏 7
点赞数 1
分类专栏： CTF-逆向 文章标签： 安全
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_37157335/article/details/124456555
版权

CTF逆向-[NPUCTF2020]Baby Obfuscation-逆向思维编写脚本以及函数含义的逻辑理解

来源：https://buuoj.cn/

内容：

附件： https://pan.baidu.com/s/1jjjo11izhnEUQaLx00993w?pwd=pxdj 提取码：pxdj

答案：NPUCTF{0bfu5er}

总体思路

根据执行逻辑分析每个函数的含义

逻辑思维简化题目的代码，将其理解成较为简短的句子

逆向思维去编写脚本

详细步骤

  • 查看文件内容

    • image-20220427174235330

  • 打开以后发现主函数里面存在一些不知内容的变量和方法

    • image-20220427172507739
    • 由scanf("%32s", A0X2);推导 A0X2 为 v_input
    • 由for ( i = 0; i <= 64; ++i ) A0X3[i] = i + 1; 推导 A0X3为 index+1
    • 将A0X4和A0X5改成arr1和arr2

  • 双击打开查看这些函数的含义并给他们命名

    • F0X1为 求最大公约数（高中知识gcd函数）

    • int __cdecl F0X1(int a, int b)
{
  if ( b )
    return F0X1(b, a % b);
  else
    return a;
}

    • F0X2为 判断a和b是否都为flase

    • bool __cdecl F0X2(bool a, bool b)
{
  return a == b && !a;
}

    • F0X3也是判断a和b是否都为flase

    • bool __cdecl F0X3(bool a, bool b)
{
  bool v2; // bl
  bool v3; // al

  v2 = F0X2(b, b);
  v3 = F0X2(a, a);
  return F0X2(v3, v2);
}

    • F0X4可以化简，~表示去反，~a = int.MAX - a，等于a-b

    • int __cdecl F0X4(int a, int b)
{
  return ~(~a + b); // = int.Max - (int.Max - a + b) = int.Max - int.Max + a - b = a - b
}

    • F0X5为 pow(a,b)，例如b=7，则二进制为111，a=5，则表达 = 5 * 5^2 * 5^4 = 5^7

    • int __cdecl F0X5(int a, int b)
{
  int ans; // [rsp+Ch] [rbp-4h]

  ans = 1;
  while ( b )
  {
    if ( (b & 1) != 0 ) // 对b每一二进制位判断是否是1，是则乘上a
      ans *= a;
    a *= a; // 每移动一位 a自乘一遍
    b >>= 1;
  }
  return ans;
}

  • 整理后得到如下，注意看注释内容，并跟着注释自行推导一遍。

  • int __cdecl main(int argc, const char **argv, const char **envp)
{
  int v_equal_2; // eax
  int v4; // ebx
  int v5; // esi
  int v6; // ebx
  int v7; // ebx
  int v8; // esi
  int v9; // ebx
  int v10; // ebx
  int v11; // ebx
  int v12; // esi
  int v13; // eax
  int v14; // ebx
  int v15; // esi
  int v16; // ebx
  int v17; // eax
  bool v18; // bl
  int v19; // eax
  int v20; // esi
  int v21; // ebx
  int v22; // ebx
  int v23; // eax
  int v_equal_16; // eax
  int v_equal_1; // eax
  int v26; // ebx
  int v_index_add1[65]; // [rsp+20h] [rbp-60h] BYREF
  char v_input[1001]; // [rsp+130h] [rbp+B0h] BYREF
  int v_temp[1001]; // [rsp+520h] [rbp+4A0h] BYREF
  int v_arr2[4]; // [rsp+14D0h] [rbp+1450h]
  int v_arr1[4]; // [rsp+14E0h] [rbp+1460h]
  int v_input_len; // [rsp+14F0h] [rbp+1470h]
  int i_1; // [rsp+14F4h] [rbp+1474h]
  int v_i; // [rsp+14F8h] [rbp+1478h]
  int i; // [rsp+14FCh] [rbp+147Ch]

  _main();
  memset(v_temp, 0, sizeof(v_temp));
  memset(v_index_add1, 0, sizeof(v_index_add1));
  for ( i = 0; i <= 64; ++i )
    v_index_add1[i] = i + 1;
  v_arr1[0] = 2;
  v_arr1[1] = 3;
  v_arr1[2] = 4;
  v_arr1[3] = 5;
  v_arr2[0] = 2;
  v_arr2[1] = 3;
  v_arr2[2] = 4;
  v_arr2[3] = 5;
  puts("WHERE IS MY KEY!?");
  scanf("%32s", v_input);
  v_input_len = strlen(v_input);
  v_equal_2 = f_gcd(v_index_add1[v_i], v_index_add1[v_i]);
  for ( v_i = v_equal_2 / v_index_add1[v_i]; v_i <= v_input_len; ++v_i )// for(i = 1;i <= input_len;i++)
  {
    v4 = (v_index_add1[v_i] + v_index_add1[v_i + 1]) * (v_index_add1[v_i] + v_index_add1[v_i + 1]);// (i+1 + i+2)²
    if ( v4 >= f_pow_ex(2, 2) * v_index_add1[v_i] * v_index_add1[v_i + 1] )// 
                                                // (i+1 + i+2)² >= 4 * (i+1) * (i+2)
                                                // 4i²+12i+9 >= 4 * (i² + 3i + 2)
                                                // 1 >= 0
                                                // 一直成立
    {
      v5 = ~v_input[f_subtract(v_i, 1)];        // ~input[i-1]
      v6 = f_subtract(v_i, 1);
      v_temp[v_i] = ~(v5 + v_arr1[v6 % f_pow_ex(2, 2)]);// ~(~input[i-1] + arr1[0]) = input[i-1] - arr1[0]
    }
    v7 = f_gcd(v_index_add1[v_i], v_index_add1[v_i + 1]);// 1
    if ( v7 > f_gcd(v_index_add1[v_i + 1], ~(~v_index_add1[v_i + 1] + v_index_add1[v_i])) )// 
                                                // 1 > gcd(i+2,~(~(i+2) + i+1))
                                                // 1 > gcd(i+2,i+2 - (i+1))
                                                // 1 > gcd(i+2,1)
                                                // 1 > 1 永不成立
    {
      v8 = v_temp[v_i];
      v9 = f_subtract(v_i, 1);
      v_temp[v_i] = ~(~v8 + v_index_add1[v9 % f_pow_ex(2, 2)]) * v8;
    }
    v10 = v_index_add1[v_i + 1];                // i+2
    v11 = f_pow_ex(2, 1) * v10;                 // 2i + 4
    v12 = v_index_add1[v_i];                    // i+1
    v13 = f_pow_ex(2, 1);                       // 2
    v14 = f_gcd(v12 * v13, v11);                // gcd((i+1) * 2, 2i+4)
    v15 = f_pow_ex(2, 1);                       // 2
    if ( v14 == v15 * f_gcd(v_index_add1[v_i], v_index_add1[v_i + 1]) )// 
                                                // gcd((i+1) * 2, 2i+4) == 2 * 1
                                                // gcd(2i+2, 2i+4) == 2
                                                // 从4,6,8,10,12,14,16,18,20..,2n里面找公约数只有2的
                                                // 发现所有的i都符合
                                                // 
    {
      v16 = f_subtract(v_i, 1);                 // i-1
      v_temp[v_i] ^= v_arr1[v16 % f_pow_ex(2, 2)];// v^= arr[(i-1) % 4]
    }
    v17 = f_pow_ex(g_value_3, v_index_add1[v_i]);// 
                                                // g_value_3 = 3
                                                // v17 = pow(3,i+1)
    v18 = v17 < v_index_add1[v_i] + 1;          // pow(3,i+1) < i+2
    v19 = f_pow_ex(2, 4);                       // 16
    if ( f_check_false_false_same(v19 >= v_i, v18) )// 
                                                // 16 < i && pow(3,i+1) >= i+2
                                                // i>1 && i>16
                                                // i>16是永不成立的
    {
      v20 = ~v_input[f_subtract(v_i, 1)];       // ~input[i-1]
      v21 = f_subtract(v_i, 1);                 // i-1
      v_temp[v_i] ^= ~(v20 + v_arr1[v21 % f_pow_ex(2, 2)]);// ^= (input[i-1] - arr1[(i-1) %4])
    }
    v22 = f_pow_ex(2, 3);                       // 8
    v23 = f_gcd(v_index_add1[v_i], v_index_add1[v_i]);// 1
    v_temp[v_i] *= v22 + f_pow_ex(2, v23 / v_index_add1[v_i]);// *= 8 + 2 = 10
  }
  v_equal_16 = f_pow_ex(2, 4);                  // 16
  if ( f_subtract(v_equal_16, 1) != v_input_len )
    goto LABEL_23;
  v_equal_1 = f_gcd(v_index_add1[i_1], v_index_add1[i_1]);
  for ( i_1 = v_equal_1 / v_index_add1[i_1]; i_1 <= v_input_len; ++i_1 )// for(i=1;i<=input_len;i++)
  {
    v26 = v_temp[i_1];
    if ( v26 == f_subtract(g_data[i_1], 1) / 10 )// input[i] * 10 = (g_data[i] - 1) 
      ++::v_i;
  }
  if ( ::v_i == v_input_len )
    puts("\nPASS");
  else
LABEL_23:
    puts("\nDENIED");
  return 0;
}

  • 经过整理，得到其处理的步骤如下

  • 程序对该字符串进行处理 - 变换

    • input[i] = input[i-1] - arr1[(i-1)%4]
    • input[i] ^= arr1[(i-1) % 4]

  • 判断

    • 输入的是16位
      1. input[i] *= 10
      1. 判断 input[i] * 10 是否等于 g_data[i] -1
    • 即 input[i] * 100 == g_data[i] - 1

  • 逆向编写上述流程

    1. input[i] = (g_data[i] - 1) / 100
    2. input[i] ^= arr1[(i-1) % 4]
    3. input[i-1] = input[i] + arr1[0]
  • import struct


g_data = '00000000791E0000791E0000352100000D170000411F000001190000ED2C0000F91100004926000081250000B52D0000B5140000E5250000312A0000D530000000000000'
g_data = bytearray.fromhex(g_data) # 转换为字节
g_data = [g_data[4*x:4*(x+1)] for x in range(int(len(g_data)/4))] # 按4个字节为一个数保存
g_data = [struct.unpack('<I',x)[0] for x in g_data] # 按小端序将原始数据转换为整数
arr1 = [2, 3, 4, 5] # 原始arr
flag = [x for x in range(16)] # 初始化flag

for i in range(1, 16):
    temp = int((g_data[i] - 1) / 100) # input[i] * 100 == g_data[i] - 1
    temp ^= arr1[(i-1) % 4] # input[i] ^= arr1[(i-1) % 4]
    temp += arr1[(i-1) % 4] # input[i] = input[i-1] - arr1[0] 即 input[i-1] = input[i] + arr1[0]
    flag[i-1] = temp

flag = [chr(x) for x in flag] # 转换为字符
flag = ''.join(flag)
print(flag) # NPUCTF{0bfu5er}

其他文档

更多CTF逆向题通用性做法和常用工具下载参考该博文内容：CTF逆向Reverse题的玩法

相关逆向CTF题

serfend
关注
  • 1
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
[NPUCTF2020]Baby Obfuscation.exe.i64
06-02
Baby Obfuscation分析过程
[NPUCTF2020]Baby Obfuscation
m0_46296905的博客
05-02 597
题目：[NPUCTF2020]Baby Obfuscation 64位无壳程序 int __cdecl main(int argc, const char **argv, const char **envp) { int v3; // eax int v4; // ebx int v5; // esi int v6; // ebx int v7; // ebx int v8; // esi int v9; // ebx int v10; // ebx int v11;
H&NCTF ——baby_python
Nike_name的博客
05-16 943
半成品——python反序列化
[NPUCTF2020]Baby Obfuscation [HDCTF2019]MFC
寻梦&之璐
06-02 646
文章目录[NPUCTF2020]Baby Obfuscation把五个Fox分析一下F0X1(int a, int b)：运用辗转相除法求得最大公因数（学到一个词汇：最大公约数GCD，最小公倍数LCM）F0X2(bool a, bool b)：仅有一种情况返回真：a\==b==0F0X3(bool a, bool b)：仅有一种情况返回真：a\==b==1F0X4(int a, int b)：解析返回值是a-bF0X5(int a, int b)：返回值是a^b^整体分析 [NPUCTF2020]Baby
[NPUCTF2020]Baby Obfuscation 题解
于高山之巅，方见大河奔涌；于群峰之上，更觉长风浩荡。
02-17 5136
buuctf-[NPUCTF2020]Baby Obfuscation 题解
CTF逆向-[GWCTF 2019]babyvm-WP-虚机模拟流程反向编码和z3约束求解器解方程工具的使用
serfend's blog
04-13 628
CTF逆向-[GWCTF 2019]babyvm-WP-虚机模拟流程反向编码和z3约束求解器解方程工具的使用 来源：https://buuoj.cn/ 内容： 附件：https://pan.baidu.com/s/1FKkXN6JDI0QkGw-UE2crNA?pwd=grb0 提取码：grb0 答案：Y0u_hav3_r3v3rs3_1t! 总体思路 发现是虚机模拟 形成每个指令的逆向 找到加密值位置（有可能不止一个位置，该题就给了一个误导的） 找到命令执行的流程（也是不止一个） 逆向编写反向加密得到f
CTF逆向-简单虚拟机指令类题目分析
11-26
CTF逆向-简单虚拟机指令类题目分析CTF逆向-简单虚拟机指令类题目分析
CTF 逆向练习-Transform
06-10
该资源配合博客使用，博客我还没写。 有空我会在哔哩哔哩录制教程。
hackthenorth-ctf:编写脚本来解决“骇客北方” CTF难题
05-08
hackthenorth-ctf 2015年9月6日至8日，Hack the North举行了CTF活动，其中包括我们需要解决的黑客难题。 您可以在我的网站上的阅读所有相关内容。 这个仓库包含了我写来解决它们的一些脚本。 ./ssh-bruteforce/ ...
京麒ctf2024-Re-babyharmony(鸿蒙OS逆向)
05-26
京麒ctf2024-Re-babyharmony(鸿蒙OS逆向)
京麒CTF2024-Re-easy-wasm（wasm逆向分析）
最新发布
05-26
4. **逆向工程技巧**：应用传统的逆向工程技能，如控制流分析、数据流分析，识别关键函数和循环，以及理解加密或混淆算法。 5. **安全考虑**：WASM在安全领域的重要性在于它可以执行任意代码，因此可能涉及缓冲区...
逆向常用脚本
trojancyborg的专栏
04-17 932
##IDA Patch内存脚本 ##将指定字符串写入指定的地址print 'import sucessfull' print 'patch(addr,base64str)' def patch(addr,base64str): b4_list = list(base64str) for i in range(b4_list.__len__()): PatchByt
whaleCTF-逆向
宗泽的博客
08-13 577
一.PE格式 此题主要考察基础的PE文件格式，参考https://blog.csdn.net/qq_20307987/article/details/50953033 当然，使用工具更简单。PETool 可以求得flag 二.Warmup IDA打开，定位到主函数 关键位置循环加密，然后与一个字符串比较。可以直接写脚本。 s="LDYVLQMZHuY:|cQ[^Qyo|cQ{~QYO\CQ[...
逆向学习过程中使用了一些脚本命令
Coder
01-06 376
环境变量的配置 // - 修改~/.bash_profile export THEOS=~/theos export PATH=~/mybin:$THEOS/bin:$PATH 这样在任意位置中都可以访问到/mybin中的文件(和文件中的命令) 修改完环境变量后 如果希望环境变量立刻生效 则需要使用一下命令 // - 使修改的环境变量立刻生效 source ~/.bash_profile...
一次ctf中代码审计分析
HBohan的博客
11-30 911
信呼OA 看一下比赛的两道题目： 咱捋一遍思路！ 拿到cms不用怕！ 先看下网络！ 看到a m surl 等参数 m=index&a=getshtml&surl=aG9tZS9pbmRleC9yb2NrX2luZGV4&num=home&menuname=6aaW6aG1 index入口直接进入了View.php 然后自己再默认调一遍！ m a d 参数都可控！ 想着最后包含$mpathname 但是这里后缀写死了 是html 但是xhrock−>displ
BUU NPUCTF2020
苗_的博客
10-05 324
f5发现主函数逻辑很简单，直接找到关键函数进入： void *__fastcall RxEncode(const char *a1, int a2) { void *result; // rax int v3; // [rsp+18h] [rbp-38h] signed int v4; // [rsp+1Ch] [rbp-34h] int v5; // [rsp+20h] [rbp-30h] signed int v6; // [rsp+24h] [rbp-2Ch] int
CTF之逆向Reverse入门推荐学习知识点总结面向新手小白
Sciurdae的博客
10-12 2940
ollydbg，简称OD已经蛮久没有更新了，而且OD主要支持32位的PE文件调试和分析；所以这里我比较推荐使用Xdbg，Xdbg经常更新，还有自动中文汉化。x64dbg顺便讲下简单使用：随便拖入一个可执行文件，这可以看到四个窗口；左上角的反汇编窗口，这里显示是我们要分析的程序的反汇编代码：截取一行讲解00007FFA5A3C076A | 55 | push rbp | 看这里！！！
[ CTF ] Reverse baby_re
ZXW_NUDT的博客
07-14 911
CTF
CTF逆向-[RoarCTF2019]polyre-WP_控制流扁平化去混淆idcpy去指令
serfend's blog
03-24 4464
CTF逆向-[RoarCTF2019]polyre-WP_控制流扁平化去混淆idcpy去指令 来源：BUUCTF在线评测/ 内容：无 附件：百度网盘 请输入提取码 提取码：nyty 答案：flag{6ff29390-6c20-4c56-ba70-a95758e3d1f8} 总体思路 使用deflat.py对程序扁平化处理。 使用ida的python idc工具对多余指令去除。 检查算法发现是crc64，按其流程逆运算 详细步骤 检查文件信息 打开程序发现控..
ctf逆向解题python脚本编写基础
10-20
在CTF逆向解题中，Python脚本编写是一项非常基础的技能。Python是一种高级编程语言，易于学习和使用，因此在CTF中广泛使用。以下是一些常见的Python脚本编写技巧： 1. 摩斯密码加密解密 2. 培根密码加密解密 3. ASCII编码解码 4. 凯撒密码加密解密 5. 修改源代码 6. 反编译程序 7. 寻找隐藏的函数名 8. 使用解密函数手动破解密文 9. 查找程序开始时的提示信息 10. 在IDA中查找字符串并找到调用它的位置 以上是一些常见的Python脚本编写技巧，掌握这些技巧可以帮助你更好地解决CTF逆向解题问题。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值