[SCTF2019]babyre

最新推荐文章于 2025-06-02 20:51:47 发布
最新推荐文章于 2025-06-02 20:51:47 发布
阅读量904 收藏 13
点赞数 9
文章标签： 算法 学习 笔记 逆向
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/2402_87493158/article/details/145330678
版权

[SCTF2019]babyre

一、查壳

无壳，64位

二、IDA分析

1.没有main，那就shife+f12

点击：

再进：

都是花指令，所以要先解决花指令

三、解决花指令，得到完整的 main

往上面翻，注意看爆红的！

第一个花指令：

将jb、jnb、loope进行nop处理，记得还要D键进行数据化处理，最后要成这样：

（上面这个图不一定是第一个花指令的最后结果，我截图是忘记这是谁的了。）

第二个花指令：

第三个花指令：

二、三处理方法与第一个相同。都是上2下1进行nop--D键。

第四个花指令:

处理略微有些不同：将jb、jnb进行nop处理，对于in查看字节

将E4改为90（nop字节），后面的保留。

注意有个call loc_C22但是C22不是一个函数，需要给他修改类型。

双击快速定位到loc_C22，摁Y键修改类型。将其改为一个独立的函数

最后，从main到retn进行p键声明为函数，这就好了。

按F5可以查看伪代码了。

四、解密
第一部分：
//main...........
   v19 = __readfsqword(0x28u);
   v6 = 0;
   memset(v12, 0, sizeof(v12));
   v13 = 0;
   memset(v14, 0, sizeof(v14));
   v15 = 0;
   memset(v16, 0, sizeof(v16));
   v17 = 0;
   strcpy(
     v18,
     "**************.****.**s..*..******.****.***********..***..**..#*..***..***.********************.**..*******..**...*..*.*.**.*");
   v10[0] = 0LL;
   v10[1] = 0LL;
   v11 = 0;
   v8 = &v18[22];
   strcpy(v9, "sctf_9102");
   puts(a1);
   v3 = "%s";
   scanf("%s", v16);
   v7 = 1;
   while ( v7 )
   {
     v5 = *((_BYTE *)v16 + v6);
     switch ( v5 )
     {
       case 'w':
         v8 -= 5;
         break;
       case 's':
         v8 += 5;
         break;
       case 'd':
         ++v8;
         break;
       case 'a':
         --v8;
         break;
       case 'x':
         v8 += 25;
         break;
       case 'y':
         v8 -= 25;
         break;
       default:
         v7 = 0;
         break;
     }
     ++v6;
     if ( *v8 != 46 && *v8 != 35 )
       v7 = 0;
     if ( *v8 == 35 )
     {
       v3 = "good!you find the right way!\nBut there is another challenge!";
       puts("good!you find the right way!\nBut there is another challenge!");
       break;
     }
   }
 //...........

可以看出是个迷宫题了。三维迷宫。

平面来看，

w控制上，s控制下，a控制左，d控制右，x控制去上一层，y控制去下一层。，*是墙，.是路径，#是终点,s是起点。

所以input1为ddwwxxssxaxwwaasasyywwdd

第二部分：

sub_C22()函数

//main.......
 if ( v7 )
   {
     puts(v3);
     scanf("%s", v12);
     sub_C22();
     if ( (unsigned int)sub_F67(v14, v9) == 1 )
     {
       puts("Congratulation!");
       puts("Congratulation!");
 //.......

查看sub_C22()函数

unsigned __int64 __fastcall sub_C22(const char *a1, __int64 a2)
 {
   bool v2; // al
   int v3; // eax
   int v4; // eax
   int v5; // eax
   int v7; // [rsp+14h] [rbp-24Ch]
   signed int v8; // [rsp+18h] [rbp-248h]
   int v9; // [rsp+1Ch] [rbp-244h]
   int v10; // [rsp+20h] [rbp-240h]
   int v11; // [rsp+24h] [rbp-23Ch]
   int v12; // [rsp+28h] [rbp-238h]
   int v13; // [rsp+2Ch] [rbp-234h]
   char *v14; // [rsp+48h] [rbp-218h]
   int v15[130]; // [rsp+50h] [rbp-210h]
   unsigned __int64 v16; // [rsp+258h] [rbp-8h]
 ​
   v16 = __readfsqword(0x28u);
   qmemcpy(v15, dword_1740, 512uLL);
   v8 = 3;
   v7 = 0;
   v10 = 0;
   v11 = 0;
   v12 = strlen(a1);
   v14 = (char *)a1;
   while ( 1 )
   {
     v13 = 0;
     if ( v10 < v12 )
       break;
 LABEL_13:
     if ( v10 >= v12 )
       goto LABEL_14;
   }
   do
   {
     if ( a1[v10] != 25 )
       break;
     ++v10;
     ++v13;
   }
   while ( v10 < v12 );
   if ( v10 != v12 )
   {
     if ( v12 - v10 > 1 )
     {
       v2 = v10 == 19 && a1[20] == 16;
       a1[v2];
     }
     ++v10;
     goto LABEL_13;
   }
 LABEL_14:
   v9 = 0;
   while ( v12 > 0 )
   {
     v8 -= v15[*v14] == 0x40;                    // v8初始为3
     v7 = v15[*v14] & 0x3F | (v7 << 6);          // 3F的二进制为111111
                                                 // 也就是将v7左移6位，空缺由v15[*v14]的低六位补上。
     if ( ++v9 == 4 )                            // 每次存4位进入一次if条件代码块
     {                                           // 将其改为三位，赋值给a2
       v9 = 0;
       if ( v8 )                                 // v11为计数器
       {
         v3 = v11++;
         *(_BYTE *)(v3 + a2) = BYTE2(v7);        // BYTE2(V7)=((BYTE*)&(V7)+2)
       }
       if ( v8 > 1 )
       {
         v4 = v11++;
         *(_BYTE *)(v4 + a2) = BYTE1(v7);        // BYTE1(V7)=((BYTE*)&(V7)+1)
       }
       if ( v8 > 2 )
       {
         v5 = v11++;
         *(_BYTE *)(v5 + a2) = v7;
       }
     }
     ++v14;
     --v12;
   }
   return __readfsqword(0x28u) ^ v16;
 }

也就是将input2的每四位改成三位给v16，然后v16再与v8="sctf_9102"进行比较,v8有9位，可知input2有16位。

所以提取出数据，写爆破脚本。

 #include <stdio.h>
 ​
 ​
 unsigned int data[128] = {
     0x7F, 0x7F, 0x7F, 0x7F, 0x7F, 0x7F, 0x7F, 0x7F,
     0x7F, 0x7F, 0x7F, 0x7F, 0x7F, 0x7F, 0x7F, 0x7F,
     0x7F, 0x7F, 0x7F, 0x7F, 0x7F, 0x7F, 0x7F, 0x7F,
     0x7F, 0x7F, 0x7F, 0x7F, 0x7F, 0x7F, 0x7F, 0x7F,
     0x7F, 0x7F, 0x7F, 0x7F, 0x7F, 0x7F, 0x7F, 0x7F,
     0x7F, 0x7F, 0x7F, 0x3E, 0x7F, 0x7F, 0x7F, 0x3F,
     0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B,
     0x3C, 0x3D, 0x7F, 0x7F, 0x7F, 0x40, 0x7F, 0x7F,
     0x7F, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06,
     0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E,
     0x0F, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16,
     0x17, 0x18, 0x19, 0x7F, 0x7F, 0x7F, 0x7F, 0x7F,
     0x7F, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x20,
     0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,
     0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F, 0x30,
     0x31, 0x32, 0x33, 0x7F, 0x7F, 0x7F, 0x7F, 0x7F
 };
 ​
 int main()
 {
     int shuju[3] = { 0x736374,0x665f39,0x313032 };
     int i0, i1, i2, i3, i4, i5;
     for (i0 = 0; i0 < 3; i0++)
     {
         for(i1=32;i1<128;i1++)
             for (i2 = 32; i2 < 128; i2++)
                 for (i3 = 32; i3 < 128; i3++)
                     for (i4 = 32; i4 < 128; i4++)
                     {
                         i5 = (((((data[i1] << 6) | data[i2]) << 6) | data[i3]) << 6) | data[i4];
                         if (i5 == shuju[i0])
                             printf("第%d组：%c%c%c%c\n", i0+1,i1, i2, i3, i4);
                     }
     }
     return 0;
 }
 ----------------------------
 第1组：c2N0
 第2组：Zl85
 第3组：MS=y
 第3组：MT=y
 第3组：MTAy

第三组是什么，不知道

看网上的大佬说

动态调试一下，发现第三个应该是MTAy

这里我也不会动态调试.

动态调试一下，发现第三个应该是MTAy

这样的话:input2应该为c2N0Zl85MTAy

第三部分:
//main........
 puts("plz tell me the password3:");
       scanf("%s", v10);
       if ( (unsigned int)sub_FFA(v10) == 1 )
       {
         puts("Congratulation!Here is your flag!:");
         printf("sctf{%s-%s(%s)}", (const char *)v16, (const char *)v12, (const char *)v10);
       }
       else
       {
         printf("something srong...");
       }
       return 0LL;
     }
     else
     {
       printf("sorry,somthing wrong...");
       return 0LL;
     }
   }
   else
   {
     printf("sorry,is't not a right way...");
     return 0LL;
   }
 }

重点是sub_FFA()

查看:

这一部分,我只能看到这里,破解的脚本我不会写

下面是网上的

 
#include <stdio.h>
 #include "defs.h"
 unsigned int data1[288] = {
     0xD6, 0x90, 0xE9, 0xFE, 0xCC, 0xE1, 0x3D, 0xB7,
     0x16, 0xB6, 0x14, 0xC2, 0x28, 0xFB, 0x2C, 0x05,
     0x2B, 0x67, 0x9A, 0x76, 0x2A, 0xBE, 0x04, 0xC3,
     0xAA, 0x44, 0x13, 0x26, 0x49, 0x86, 0x06, 0x99,
     0x9C, 0x42, 0x50, 0xF4, 0x91, 0xEF, 0x98, 0x7A,
     0x33, 0x54, 0x0B, 0x43, 0xED, 0xCF, 0xAC, 0x62,
     0xE4, 0xB3, 0x1C, 0xA9, 0xC9, 0x08, 0xE8, 0x95,
     0x80, 0xDF, 0x94, 0xFA, 0x75, 0x8F, 0x3F, 0xA6,
     0x47, 0x07, 0xA7, 0xFC, 0xF3, 0x73, 0x17, 0xBA,
     0x83, 0x59, 0x3C, 0x19, 0xE6, 0x85, 0x4F, 0xA8,
     0x68, 0x6B, 0x81, 0xB2, 0x71, 0x64, 0xDA, 0x8B,
     0xF8, 0xEB, 0x0F, 0x4B, 0x70, 0x56, 0x9D, 0x35,
     0x1E, 0x24, 0x0E, 0x5E, 0x63, 0x58, 0xD1, 0xA2,
     0x25, 0x22, 0x7C, 0x3B, 0x01, 0x21, 0x78, 0x87,
     0xD4, 0x00, 0x46, 0x57, 0x9F, 0xD3, 0x27, 0x52,
     0x4C, 0x36, 0x02, 0xE7, 0xA0, 0xC4, 0xC8, 0x9E,
     0xEA, 0xBF, 0x8A, 0xD2, 0x40, 0xC7, 0x38, 0xB5,
     0xA3, 0xF7, 0xF2, 0xCE, 0xF9, 0x61, 0x15, 0xA1,
     0xE0, 0xAE, 0x5D, 0xA4, 0x9B, 0x34, 0x1A, 0x55,
     0xAD, 0x93, 0x32, 0x30, 0xF5, 0x8C, 0xB1, 0xE3,
     0x1D, 0xF6, 0xE2, 0x2E, 0x82, 0x66, 0xCA, 0x60,
     0xC0, 0x29, 0x23, 0xAB, 0x0D, 0x53, 0x4E, 0x6F,
     0xD5, 0xDB, 0x37, 0x45, 0xDE, 0xFD, 0x8E, 0x2F,
     0x03, 0xFF, 0x6A, 0x72, 0x6D, 0x6C, 0x5B, 0x51,
     0x8D, 0x1B, 0xAF, 0x92, 0xBB, 0xDD, 0xBC, 0x7F,
     0x11, 0xD9, 0x5C, 0x41, 0x1F, 0x10, 0x5A, 0xD8,
     0x0A, 0xC1, 0x31, 0x88, 0xA5, 0xCD, 0x7B, 0xBD,
     0x2D, 0x74, 0xD0, 0x12, 0xB8, 0xE5, 0xB4, 0xB0,
     0x89, 0x69, 0x97, 0x4A, 0x0C, 0x96, 0x77, 0x7E,
     0x65, 0xB9, 0xF1, 0x09, 0xC5, 0x6E, 0xC6, 0x84,
     0x18, 0xF0, 0x7D, 0xEC, 0x3A, 0xDC, 0x4D, 0x20,
     0x79, 0xEE, 0x5F, 0x3E, 0xD7, 0xCB, 0x39, 0x48,
     0xC6, 0xBA, 0xB1, 0xA3, 0x50, 0x33, 0xAA, 0x56,
     0x97, 0x91, 0x7D, 0x67, 0xDC, 0x22, 0x70, 0xB2,
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
 };
 ​
 unsigned int fun(unsigned int a1)
 {
         int v1;
         v1 = (data1[BYTE2(a1)] << 16) | data1[(unsigned __int8)a1] | (data1[BYTE1(a1)] << 8) | (data1[a1 >> 24] << 24);
         return __ROL4__(v1, 12) ^ (unsigned int)(__ROL4__(v1, 8) ^ __ROR4__(v1, 2)) ^ __ROR4__(v1, 6);
 }
 ​
 int main()
 {
     unsigned int data[30] = { 0 };
     data[26] = 0xBE040680;
     data[27] = 0xC5AF7647;
     data[28] = 0x9FCC401F;
     data[29] = 0xD8BF92EF;
     int i;
     for (i = 25; i >=0; i--)
         data[i] = fun(data[i+1] ^ data[i+2] ^ data[i+3]) ^ data[i+4];
     printf("%x %x %x %x\n", data[0], data[1], data[2], data[3]);
     for (i = 0; i < 4; i++)
         printf("%c%c%c%c", ((char*)&data[i])[0], ((char*)&data[i])[1], ((char*)&data[i])[2], ((char*)&data[i])[3]);
     return 0;
 }
 -----------------------------------
     fl4g_is_s0_ug1y!
综上所述:

得到flag为sctf{ddwwxxssxaxwwaasasyywwdd-c2N0Zl85MTAy(fl4g_is_s0_ug1y!)}

参考文章:

re学习笔记（38）BUUCTF-re-[SCTF2019]babyre IDA无法F5|代码修复|花指令------------Forgo7ten

链接：re学习笔记（38）BUUCTF-re-[SCTF2019]babyre IDA无法F5|代码修复|花指令_ctf reabbit-优快云博客

Aresy596
关注
190321 逆向-花指令去除（脚本）
whklhhhh的博客
03-22 3万+
Pizza的脚本中是通过get_bytes和patch_bytes两个API来将所有机器码读出然后再Patch回去的 中间匹配pattern的过程是构造字符串然后find来控制 这样操作的优点是find的效率奇高，对于大量数据的处理非常的快 而我们之前使用的逐字符匹配pattern的优点是可控性比较强，例如通配符的存在 然而缺点就是速度很慢，对于数量级较大时格外明显，因此试图修复 刚开始以为速度...
花指令学习
dingxingaq的博客
01-06 1599
花指令实质就是一串垃圾指令，主要用于干扰静态分析的难度防止反编译器进行反编译，并不影响程序的正常逻辑，在CTF中花指令的作用主要用于防止静态分析程序，花指令也可以被用在病毒或木马上，通过加入花指令来改变程序的特征码从而躲避杀软的扫描达到免杀的目的，花指令一般被分为两类，可执行花指令与不可执行花指令，不管执不执行都不会影响程序正常运行。不可执行花指令就是将一些数据插入正常指令中，并不会影响程序运行也不会被执行，只会导致反编译错误，
【逆向学习】花指令的去除
WangLal的博客
04-22 5666
逆向花指令
花指令详解
m0_51246873的博客
10-04 5489
逆向CTF花之令详解
花指令入门操作实践
bcbobo21cn的专栏
03-17 1230
根据逆向相关资料；下面有2段ASM代码； 1； start_: xor eax, eax test eax, eax jz label1 jnz label1 db 0E8h ;垃圾指令 label1: xor eax, 3 add eax, 4 xor eax, 5 ret 2； start_: xo...
花指令的原理和常用花指令收集
weixin_33728268的博客
05-03 842
花指令的作用是对付静态分析，以下面一段程序说明一下花指令的原理 代码 #include&lt;iostream.h&gt;#include&lt;windows.h&gt;voidmain(){_asm{jmpl2_EMIT0x1//这里就是花指令_EMIT0x2//这里就是花指令_EM...
花指令总结
Captain_RB的博客
04-12 6728
花指令又称脏字节，英文为"junkcode"，顾名思义，即在程序中加入的一些垃圾指令，其目的是在不妨碍原有程序执行的前提下，阻碍程序反编译，增加静态分析难度，隐匿不想被逆向分析的代码块，混淆代码，绕过特征识别。本文将常见的花指令进行归纳总结，作学习记录。
程序免杀技术之——花指令
人生代码，代码人生。。。
11-19 3922
花指令(junk code) 意思是程序中有一些指令，由设计者特别构思，希望使反汇编的时候出错，让破解者无法清楚正确地反汇编程序的内容，迷失方向。经典的是一些跳转指令，目标位置是另一条指令的中间，这样在反汇编的时候便会出现混乱。花指令有可能利用各种 jmp, call, ret, 一些堆栈技巧，位置运算，等等 。 当然，花指令也广泛运用到免杀技术中，不过随着杀毒技术以及虚拟机技术的不断升
逆向分析基础 --- 花指令实现及清除
热门推荐
abelxu
06-15 1万+
一、基本概念 花指令：目的是干扰ida和od等软件对程序的静态分析。使这些软件无法正常反汇编出原始代码。 常用的两类反汇编算法： 1.线性扫描算法：逐行反汇编（无法将数据和内容进行区分） 2.递归行进算法：按照代码可能的执行顺序进行反汇编程序。 简单的花指令 0xe8是跳转指令，可以对线性扫描算法进行干扰，但是递归扫描算法可以正常分析。 两个跳转一个指向无效数据，一个指向正常数据来干扰递归扫描算法。 二、花指令实现 这里的实验基础代码是参考安全客上一个师傅代码进行的 //源码 #include&lt;s
CUDA 归约求和（Reduction）算法
liberty的博客
05-29 558
这段代码是CUDA并行编程中经典的‌‌的核心部分，用于高效累加数组元素。
历年西安交通大学计算机保研上机真题
u014339447的博客
05-30 1096
2025西安交通大学计算机保研上机真题2024西安交通大学计算机保研上机真题2023西安交通大学计算机保研上机真题。
4. 算法与分析 (1)
LxiazichengxiL的博客
05-29 886
算法是对特定问题求解方法和步骤的一种描述，它是。
Java垃圾回收算法及GC触发条件
weixin_56018532的博客
06-02 609
垃圾回收是一种自动内存管理机制，它能够识别程序中不再使用的内存空间（即"垃圾"），并将其回收以供后续使用。在Java中，开发者不需要显式地释放内存，JVM会自动完成这一工作。Java垃圾回收的核心任务是确定哪些对象是"活动的"（仍在使用中），哪些是"垃圾"（不再使用）。一般来说，如果一个对象不能通过任何引用链从程序的"根"（如全局变量、当前执行栈中的局部变量等）访问到，那么这个对象就被认为是垃圾，可以被回收。
池中锦鲤的自我修养，聊聊蓄水池算法
最新发布
Wendy_robot的博客
06-02 544
起初你满怀期待跳进大厂池子，以为自己是天选之子，结果发现池子里早挤满了和你一样的“锦鲤候选人”。HR的渔网一撒，捞谁全看概率——这不就是的精髓吗？kVIPk + 1k / i“面完三面等消息？恭喜，你进入了k / N的量子纠缠态。1001000k / N所以，下次面试官问你“如何公平抽奖”，请优雅地回答：“简单，像泡池子一样，先到的不一定稳，后来的未必凉，一切交给蓄水池的数学之美。
超声波测距三大算法实测对比
qq_74234033的博客
06-02 421
本文对比了超声波测距中的三种数据处理方法。无滤波算法直接输出原始数据，实时性强但精度低；卡尔曼滤波通过系统模型动态预测和更新，抗噪能力强且精度高，适合动态场景；均值滤波通过滑动平均抑制噪声，实现简单但响应慢，适用于静态检测。实验使用树莓派和HC-SR04模块，分别展示了三种算法的代码实现和应用效果。结果表明，卡尔曼滤波在动态环境中表现最优，而均值滤波更适合静态测量。
基于多模态脑电、音频与视觉信号的情感识别算法【Nature核心期刊，EAV：EEG-音频-视频数据集】
weixin_42380711的博客
05-29 1222
DatabaseLanguageSubjectsTypesS, ISEED-IV11EEG and EMVideosS, IDREAMER10EEG & ECGMoviesS, IMPED9VideosS, IASCERTAIN8VideosS, IAMIGOS7MoviesS, IDEAP12S, IIEMOCAP15EnglishS, ISEMAINE16EnglishS, INNIME19ChineseP, NRAVDESS20。
[网页五子棋][匹配模块]处理开始匹配/停止匹配请求(匹配算法，匹配器的实现)
Yeeear的博客
05-29 1154
摘要：本文介绍了游戏匹配系统的设计与实现。系统通过WebSocket处理玩家匹配请求，分为三个分数段位队列（Normal、High、VeryHigh）进行匹配。核心功能包括：1) 解析客户端匹配请求并分类处理；2) 使用Matcher类管理三个匹配队列，提供增删玩家方法；3) 通过独立线程持续扫描队列，将同等级玩家两两配对。系统还处理了连接异常情况，确保玩家断开时自动移出队列。匹配算法采用简单分段策略，未来可扩展更精确的匹配机制。代码实现展示了具体的Java处理逻辑，包括请求解析、队列操作和线程调度。
洛谷 P1157：组合的输出 ← dfs
hnjzsyjyj的专栏
05-29 436
升序控制‌：通过 i=a[k-1]+1 确保后一个数大于前一个数，避免重复组合。
pwn1_sctf_2016
02-09
### 关于 PWN1 SCTF 2016 CTF 比赛解题报告 #### 题目概述 PWN1 SCTF 2016 是一次涉及栈溢出漏洞利用的比赛项目。参赛者需理解二进制文件执行流程以及如何通过特定输入控制程序流来实现非授权操作[^2]。 #### 漏洞...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值