[NPUCTF2020]Baby Obfuscation

最新推荐文章于 2022-11-30 11:21:34 发布
最新推荐文章于 2022-11-30 11:21:34 发布
阅读量597 收藏 1
点赞数 1
分类专栏： CTF-RE 文章标签： python 算法 字符串 安全 信息安全
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46296905/article/details/116354737
版权

题目：[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; // 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 v24; // eax
  int v25; // eax
  int v26; // ebx
  int v28[68]; // [rsp+20h] [rbp-60h] BYREF
  char Str[1008]; // [rsp+130h] [rbp+B0h] BYREF
  int v30[1008]; // [rsp+520h] [rbp+4A0h] BYREF
  int v31[4]; // [rsp+14E0h] [rbp+1460h]
  int v32; // [rsp+14F0h] [rbp+1470h]
  int k; // [rsp+14F4h] [rbp+1474h]
  int j; // [rsp+14F8h] [rbp+1478h]
  int i; // [rsp+14FCh] [rbp+147Ch]

  _main(argc, argv, envp);
  memset(v30, 0, 0xFA0ui64);
  v30[1000] = 0;
  memset(v28, 0, 0x100ui64);
  v28[64] = 0;
  for ( i = 0; i <= 64; ++i )
    v28[i] = i + 1;
  v31[0] = 2;
  v31[1] = 3;
  v31[2] = 4;
  v31[3] = 5;
  v30[1004] = 2;
  v30[1005] = 3;
  v30[1006] = 4;
  v30[1007] = 5;
  puts("WHERE IS MY KEY!?");
  scanf("%32s", Str);
  v32 = strlen(Str);
  v3 = F0X1(v28[j], v28[j]);
  for ( j = v3 / v28[j]; j <= v32; ++j )
  {
    v4 = (v28[j] + v28[j + 1]) * (v28[j] + v28[j + 1]);
    if ( v4 >= (int)(F0X5(2, 2) * v28[j] * v28[j + 1]) )
    {
      v5 = ~Str[(int)F0X4(j, 1)];
      v6 = F0X4(j, 1);
      v30[j] = ~(v5 + v31[v6 % (int)F0X5(2, 2)]);
    }
    v7 = F0X1(v28[j], v28[j + 1]);
    if ( v7 > (int)F0X1(v28[j + 1], ~(~v28[j + 1] + v28[j])) )
    {
      v8 = v30[j];
      v9 = F0X4(j, 1);
      v30[j] = ~(~v8 + v28[v9 % (int)F0X5(2, 2)]) * v8;
    }
    v10 = v28[j + 1];
    v11 = F0X5(2, 1) * v10;
    v12 = v28[j];
    v13 = F0X5(2, 1);
    v14 = F0X1(v12 * v13, v11);
    v15 = F0X5(2, 1);
    if ( v14 == v15 * (unsigned int)F0X1(v28[j], v28[j + 1]) )
    {
      v16 = F0X4(j, 1);
      v30[j] ^= v31[v16 % (int)F0X5(2, 2)];
    }
    v17 = F0X5(V0X3, v28[j]);
    v18 = v17 < v28[j] + 1;
    v19 = F0X5(2, 4);
    if ( (unsigned __int8)F0X3(v19 >= j, v18) )
    {
      v20 = ~Str[(int)F0X4(j, 1)];
      v21 = F0X4(j, 1);
      v30[j] ^= ~(v20 + v31[v21 % (int)F0X5(2, 2)]);
    }
    v22 = F0X5(2, 3);
    v23 = F0X1(v28[j], v28[j]);
    v30[j] *= v22 + (unsigned int)F0X5(2, v23 / v28[j]);
  }
  v24 = F0X5(2, 4);
  if ( (unsigned int)F0X4(v24, 1) != v32 )
    goto LABEL_23;
  v25 = F0X1(v28[k], v28[k]);
  for ( k = v25 / v28[k]; k <= v32; ++k )
  {
    v26 = v30[k];
    if ( v26 == (int)F0X4(A0X6[k], 1) / 10 )
      ++V0X2;
  }
  if ( V0X2 == v32 )
    puts("\nPASS");
  else
LABEL_23:
    puts("\nDENIED");
  return 0;
}

先分析一下几个处理函数再分析主函数

F0X1

看出来是欧几里得算法，返回a1和a2的最大公约数。

__int64 __fastcall F0X1(unsigned int a1, int a2)
{
  __int64 result; // rax

  if ( a2 )
    result = F0X1(a2, a1 % a2);
  else
    result = a1;
  return result;
}

F0X2 & F0X3

只有两个参数都是1的时候才返回1，别的都返回0。

_BOOL8 __fastcall F0X2(char a1, char a2)
{
  return a1 == a2 && a1 != 1;
}

__int64 __fastcall F0X3(bool a1, bool a2)
{
  char v2; // bl
  char v3; // al

  v2 = F0X2(a2, a2);
  v3 = F0X2(a1, a1);
  return F0X2(v3, v2);
}

F0X4

看着很奇怪的运算，其实就是 a1 - a2。

__int64 __fastcall F0X4(int a1, int a2)
{
  return ~(~a1 + a2);
}

F0X5

返回a1^a2。

__int64 __fastcall F0X5(int a1, int a2)
{
  unsigned int v4; // [rsp+Ch] [rbp-4h]

  v4 = 1;
  while ( a2 )
  {
    if ( (a2 & 1) != 0 )
      v4 *= a1;
    a1 *= a1;
    a2 >>= 1;
  }
  return v4;
}

main

知道了这几个函数的实现就可以看主函数了。

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; // 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 v24; // eax
  int v25; // eax
  int v26; // ebx
  int v28[68]; // [rsp+20h] [rbp-60h] BYREF
  char Str[1008]; // [rsp+130h] [rbp+B0h] BYREF
  int v30[1008]; // [rsp+520h] [rbp+4A0h] BYREF
  int v31[4]; // [rsp+14E0h] [rbp+1460h]
  int v32; // [rsp+14F0h] [rbp+1470h]
  int k; // [rsp+14F4h] [rbp+1474h]
  int j; // [rsp+14F8h] [rbp+1478h]
  int i; // [rsp+14FCh] [rbp+147Ch]

  _main(argc, argv, envp);
  memset(v30, 0, 0xFA0ui64);
  v30[1000] = 0;
  memset(v28, 0, 0x100ui64);
  v28[64] = 0;
  for ( i = 0; i <= 64; ++i )
    v28[i] = i + 1;
  v31[0] = 2;
  v31[1] = 3;
  v31[2] = 4;
  v31[3] = 5;
  v30[1004] = 2;
  v30[1005] = 3;
  v30[1006] = 4;
  v30[1007] = 5;
  puts("WHERE IS MY KEY!?");
  scanf("%32s", Str);
  v32 = strlen(Str);
  v3 = F0X1(v28[j], v28[j]);                    // v3=v28[j]
  for ( j = v3 / v28[j]; j <= v32; ++j )
  {
    v4 = (v28[j] + v28[j + 1]) * (v28[j] + v28[j + 1]);// v4=(2j+3)^2=4j^2+12j+18（数学表达式）
    if ( v4 >= (F0X5(2, 2) * v28[j] * v28[j + 1]) )// 满足
    {
      v5 = ~Str[F0X4(j, 1)];                    // v5 = ~Str[j-1]
      v6 = F0X4(j, 1);                          // v6=j-1
      v30[j] = ~(v5 + v31[v6 % F0X5(2, 2)]);    // v30[j]=Str[j-1]-v31[(j-1)%4]
    }
    v7 = F0X1(v28[j], v28[j + 1]);
    if ( v7 > F0X1(v28[j + 1], ~(~v28[j + 1] + v28[j])) )// 不满足
    {
      v8 = v30[j];
      v9 = F0X4(j, 1);
      v30[j] = ~(~v8 + v28[v9 % F0X5(2, 2)]) * v8;
    }
    v10 = v28[j + 1];                           // v10=j+2
    v11 = F0X5(2, 1) * v10;                     // v11=2*j+4
    v12 = v28[j];                               // v12=j+1
    v13 = F0X5(2, 1);                           // v13=2
    v14 = F0X1(v12 * v13, v11);                 // v14=gcd(2*j+2,2*j+4)
    v15 = F0X5(2, 1);                           // v15=2
    if ( v14 == v15 * F0X1(v28[j], v28[j + 1]) )// 满足
    {
      v16 = F0X4(j, 1);
      v30[j] ^= v31[v16 % F0X5(2, 2)];          // v30[j] ^=v31[(j-1)%4]
    }
    v17 = F0X5(V0X3, v28[j]);
    v18 = v17 < v28[j] + 1;                     // v18=0
    v19 = F0X5(2, 4);
    if ( F0X3(v19 >= j, v18) )                  // 不满足
    {
      v20 = ~Str[F0X4(j, 1)];
      v21 = F0X4(j, 1);
      v30[j] ^= ~(v20 + v31[v21 % F0X5(2, 2)]);
    }
    v22 = F0X5(2, 3);
    v23 = F0X1(v28[j], v28[j]);
    v30[j] *= v22 + F0X5(2, v23 / v28[j]);      // v30[j] *= 10;
  }
  v24 = F0X5(2, 4);
  if ( F0X4(v24, 1) != v32 )
    goto LABEL_23;
  v25 = F0X1(v28[k], v28[k]);
  for ( k = v25 / v28[k]; k <= v32; ++k )       // k=1
  {
    v26 = v30[k];
    if ( v26 == F0X4(A0X6[k], 1) / 10 )         // v30[k]== (A0X6[k] - 1) / 10;
                                                // A0X6[]={0, 1E79h, 1E79h, 2135h, 170Dh, 1F41h,1901h, 2CEDh,11F9h, 2649h, 2581h,2DB5h, 14B5h, 25E5h, 2A31h, 30D5h.0,0, 415770h, 0,0,0,0,0}
      ++V0X2;
  }
  if ( V0X2 == v32 )
    puts("\nPASS");
  else
LABEL_23:
    puts("\nDENIED");
  return 0;
}

不难看出，v30数组是跟flag有密切联系的。进一步排查，其中v30的赋值语句中只有下面三个与flag加密有关。

  • v30[j] = ~(v5 + v31[v6 % F0X5(2, 2)]);
  • v30[j] ^= v31[v16 % F0X5(2, 2)];
  • v30[j] *= v22 + F0X5(2, v23 / v28[j]);

这三个等价于

  • v30[j]=Str[j-1]-v31[(j-1)%4]
  • v30[j] ^=v31[(j-1)%4]
  • v30[j] *= 10;

EXP

A0X6=[0x0, 0x1E79, 0x1E79, 0x2135, 0x170D, 0x1F41,0x1901, 0x2CED,0x11F9, 0x2649, 0x2581,0x2DB5, 0x14B5, 0x25E5, 0x2A31, 0x30D5,0x0,0x0,0x415770,0x0,0x0,0x0,0x0,0x0]
flag=''
v31=[2,3,4,5]
for j in range(1,len(A0X6)):
	A0X6[j]//=100      #两次乘10
	A0X6[j]^=v31[(j-1)%4]
	A0X6[j]+=v31[(j-1)%4]
	flag+=chr(A0X6[j])
print(flag)

在这里插入图片描述

flag{0bfu5er}
Em0s_Er1t
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
[NPUCTF2020]Baby Obfuscation.exe.i64
06-02
Baby Obfuscation分析过程
[NPUCTF2020]Baby Obfuscation 题解
于高山之巅，方见大河奔涌；于群峰之上，更觉长风浩荡。
02-17 5136
buuctf-[NPUCTF2020]Baby Obfuscation 题解
[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
CTF逆向-[NPUCTF2020]Baby Obfuscation-逆向思维编写脚本以及函数含义的逻辑理解
serfend's blog
04-27 737
CTF逆向-[NPUCTF2020]Baby Obfuscation-逆向思维编写脚本以及函数含义的逻辑理解 来源：https://buuoj.cn/ 内容： 附件： https://pan.baidu.com/s/1jjjo11izhnEUQaLx00993w?pwd=pxdj 提取码：pxdj 答案：NPUCTF{0bfu5er} 总体思路 根据执行逻辑分析每个函数的含义 逻辑思维简化题目的代码，将其理解成较为简短的句子 逆向思维去编写脚本 详细步骤 查看文件内容 打开以后发现主函数里
obfuscation
05-16
obfuscation is important technology.
Hardware Protection through Obfuscation
02-02
This exhaustive study includes a review of the hardware obfuscation methods developed at each level of abstraction (RTL, gate, and layout) for conventional IC manufacturing, new forms of obfuscation ...
baby_obfuscator:使用LLVM Pass混淆程序
05-26
婴儿混淆器 使用LLVM Pass混淆程序。 写（中文）： 特征 特征 启用标志 混淆常​​量字符串 -obfstr 添加伪控制流 ...# You should modify the DLLVM_DIR option to fit your environment cmake .....
Code obfuscation
ZCY的博客
03-31 207
Description Kostya likes Codeforces contests very much. However, he is very disappointed that his solutions are frequently hacked. That's why he decided to obfuscate (intentionally make less readable...
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
术语：Obfuscation
Dev in Nightmare
05-23 1383
在软件开发领域，Obfuscation指对代码做模糊处理，使其难于理解、难于反编译。翻译：A. 代码混淆B. 模糊处理 相关的Obfuscator一词的翻译：A. 混淆器B. 模糊处理器
crypto-babyLCG(NPUCTF2020)
耐酸碱高温固化材料近距离传输研究
11-30 1262
显然如果要解密出flag明文那必须要反推出最初的seed参数，将后面产生的随机数全部复原。的原因是为了保持向量各个数值bit位保持一致（关于格密码基础概念推荐这篇。因为前20个随机数的高位是已知的，接下来思路是针对这个式子做变形。其中A，B均可通过a，b，h推出。现在将以上关系式写成矩阵形式。由于h均为已知，那么现在找到低位l递推的关系式，又因为。近期研究格密码过程中遇到的一个很好的题目，记录一下。则可以推出所有低位l与l1的关系式，简写为。构造lattice，最后一项取2。将s拆分为高位h和低位l变为。
[NPUCTF2020]认清形势，建立信心-WP
luoluopeach
09-10 622
题目： from Crypto.Util.number import * from gmpy2 import * from secret import flag p = getPrime(25) e = # Hidden q = getPrime(25) n = p * q m = bytes_to_long(flag.strip(b"npuctf{").strip(b"}")) c = pow(m, e, n) print(c) print(pow(2, e, n)) print(pow(4, e,
攻防世界pwn题--stack2
L0g1c的博客
10-31 499
查看保护机制 （有栈不可执行NX，有canary保护） 用IDA分析（查看伪代码） int __cdecl main(int argc, const char **argv, const char **envp) { int v3; // eax unsigned int v5; // [esp+18h] [ebp-90h] unsigned int v6; // [esp+1Ch] [ebp-8Ch] int v7; // [esp+20h] [ebp-88h] unsigned
【genius_platform软件平台开发】第四十讲：__stdcall、__cdecl、__fastcall、__thiscall、__pascal和__naked call详解
随意的风的专栏
07-27 3477
先通过一个小程序来看一看： #include void foo(int x, int y, int z) { printf("x = %d at [%X]n", x, &amp;x); printf("y = %d at [%X]n", y, &amp;y); printf("z = %d at [%X]n", z, &amp;z); } int main(int argc, ch...
一道简单的smc自解密题目
m0_62690279的博客
03-27 1035
一道简单的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 )
栈溢出脚本_二进制安全之栈溢出（下）
weixin_39538877的博客
11-20 271
栈劫持整形溢出实验调试程序一 ：rop链 & _libc_csu_initROPIDA静态分析int __cdecl main(int argc, const char **argv, const char **envp){ vulnerable_function(*(_QWORD *)&argc, argv, envp); return write(1, "Hello, Wo...
[MRCTF2020]Shit
sky123博客
01-18 874
main函数 int __cdecl main(int argc, const char **argv, const char **envp) { int v3; // eax int v4; // eax char v5; // al int v6; // eax int v7; // eax int v8; // eax char v10[52]; // [esp+4h] [ebp-38h] BYREF v3 = sub_401890(); std::ostream
int main(int argc, const char *argv[]) 详解
hawk2844的专栏
07-14 7812
http://www.cnblogs.com/avril/archive/2010/03/22/1691477.html
授权dbms_obfuscation
最新发布
05-24
dbms_obfuscation是Oracle数据库提供的一个包，可以用来对敏感数据进行加密和解密。如果你想要使用该包，需要先获得相应的授权。 授权的步骤如下： 1. 以SYS用户身份登录数据库。 2. 执行以下命令创建授权角色： ``` CREATE ROLE dbms_obfuscation_role; ``` 3. 授权该角色执行dbms_obfuscation包中的所有程序： ``` GRANT EXECUTE ON dbms_obfuscation TO dbms_obfuscation_role; ``` 4. 将需要使用该包的用户赋予该角色： ``` GRANT dbms_obfuscation_role TO user_name; ``` 其中，user_name为需要使用该包的用户名称。 完成以上授权后，用户就可以使用dbms_obfuscation包中的程序对敏感数据进行加密和解密了。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Em0s_Er1t

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

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

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

打赏作者

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

抵扣说明：

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

余额充值