关于SMC的学习

发布于 2024-01-12  206 次阅读

关于在我做CTF题目的时候，发现了一个文件事宜SMC开头的文件，所以就对SMC进行了查询与学习

1.对于SMC的简介：

SMC（Software-Based Memory Encryption）是一种局部代码加密技术，它可以讲一个可执行的文件的指定区段jinxing加密，使得无法直接对区段内的代码进行分析。

它的基本原理是在编译可执行文件是，将需要加密的代码区段（如函数、代码块） 单独编译成一个section（段），并将其标记为可读，可写，不可执行（readable, writable, non-executable），然后通过某种方法在程序运行的时候将section解密为可执行代码，并将其标记为可读、可执行、不可写（readable, executable, non-writable）。这样就不能直接在内存里面找到加密的代码，从而无法执行或修改加密的代码。

SMC 技术可以通过多种方式实现，例如修改PE文件的Scetion Header、使用API Hook实现代码的加密和解密、使用VMProtect等第三方加密工具等。机密时一般采用异或等简单的加密算法，解密是通过相同的算法对密文进行解密。

具体来说，SMC实现的主要步骤是：

1.读取PE文件并找到需要加密的代码段

2.将代码段的内容进行异或加密，并更新到内存的代码段

3.重定向代码段的内存地址，使得加密后的代码能够正确执行

4.执行加密后的代码段

SMC的优点在于：

1.采用的是软件实现的方法，因此并不需要硬件的支持，可以在任意的平台上运行

2.对于程序的运行速度影响小，因此代码的解密和执行的过程都是在内存中进行的

3.可以对代码进行多次的加密，增加破解的难度

4.可以根据需要对不同的代码进行不同的加密

缺点在于：

1.实现起来复杂，需要涉及PE我呢间的结构、内存管理等方面的知识

2.需要在运行的时候动态解码，会对程序的性能产生一定的影响

3.只能对静态的代码进行加密，对于动态的代码无法进行保护

4.对于一些高级的破解技术（如对内存进行分析）可能无法保护程序

[流程图]+---------------------+
| 读取PE文件 |
| 找到代码段 |
+---------------------+
|
|
v
+---------------------------------+
| 对代码段进行异或加密 |
| 并更新到内存中的代码段 |
+---------------------------------+
|
|
v
+---------------------------------+
| 重定向代码段的内存地址， |
| 使得加密后的代码能够正确执行 |
+---------------------------------+
|
|
v
+---------------------+
| 执行加密后的代码段 |
+---------------------+

通俗来讲，就是程序可以自己对自己底层的字节码进行操作，就是所谓的自解密技术。其在ctf比赛中常见的就是可以将一段关键代码进行某种加密，然后程序运行的时候就直接解密回来,这样就可以干扰解题者的静态分析,在免杀方面也是非常好用的技术。可以利用该技术隐藏关键代码。

2.实现这一项技术

用伪代码解释一下这一个技术：

proc main:
............
IF .运行条件满足
CALL DecryptProc （Address of MyProc）//对某个函数代码解密
........
CALL MyProc                           //调用这个函数
........
CALL EncryptProc （Address of MyProc）//再对代码进行加密，防止程序被Dump
​
......
end main

首先是使用了Dev—C++ 6.7.5编译器，使用的MinGW GCC 9.2.0 32bit Debug的编译规则

我们回忆一下这一项的技术，假如我们需要加密的函数是fun，那么我们首先需要使用指针找到fun的地址，一开始使用的是int类型的指针，代码如下：

void fun()
{
   char flag[]="flag{this_is_test}";
   printf("%s",flag);
}
int main ()
{

   int *a=(int *)fun;
   for(int i = 0 ; i < 10 ; i++ )
  {
       printf("%x ",*(a++));
  }
}

输出的结果是：

83e58955 45c738ec 616c66e5 e945c767 6968747b 73ed45c7 c773695f 745ff145 c7667365 7d74f545

把编译出来的文件放在IDA里面观察：

可以发现输出的内容确实是fun字节码，但是由于int在C语言占用了四个字节，因此是由四个16进制的机器码根据小端序排列输出的，那么为了解决这种连续的字节码的问题我们需要找到一个只占用一个字节的指针，首先想到的是char类型，于是改编代码过后我们得到了如下的结果

55 ffffff89 ffffffe5 ffffff83 ffffffec 38 ffffffc7 45 ffffffe5 66

显然，这里是忽略的char的符号位的问题，有符号char型如果最高位是1，意思是超过了0x7f，当%X格式化输出的时候，则会将这个类型的值拓展到int型的32位，所以才会出现0xff，被扩展为ffffffff

一筹莫展之际，我想起了在c语言中还有一种数据类型是只占一个字节的，那就是byte类型的数据，将代码改成byte类型之后可以发现输出变得正常了

输出为：

55 89 e5 83 ec 38 c7 45 e5 66

这个就是正确的字节码的形式

那么就需要定位到程序段进行加密了，采取简单的异或加密方式，异或加密的特点就是加密函数也可以是解密函数,极大的方便了我们此次实验。我们可以先在ida中看到我们需要加密的程序段的位置

在ida里面我们可以发现我们需要解密的fun函数占用的地址0x00401410-00401451，那么我们只需要将这一段内存中的机器码异或加密理论上就可以实现SMC文件加密技术

实现代码如下：

void fun()
{
   char flag[]="flag{this_is_test}";
   printf("%s",flag);
}
int main ()
{

   byte *a=(byte *)fun;
   byte *b = a ;
   for( ; a!=(b+0x401451-0x401410+1) ; a++ )
  {
       *a=*a^3;
  }
   fun();
}

这段代码直接运行的时候会出现内存错误，这是因为代码运行的时候对原本；未被加密的fun函数进行了异或处理，导致本来因该是解密的操作变成了加密操作，然后机器码无法识别该段内存错误，因此在运行代码前我们需要将文件的fun函数部分进行加密操作，这里使用idapython对字节码进行操作，然后将文件dump出来，完成对文件的加密

idapython脚本为:for i in range(0x401410,0x401451):
  patch_byte(i,get_wide_byte(i)^3)

运行后把代码dump下来，再运行

发现出现内存错误告警，猜测可能是dev-c++的编译器开启了随机基地址和数据保护,因此选择更换编译器，并关闭随机基地址选项。这里使用的是visual studio 2019，32位的debug模式进行编译

但是遗憾的是仍然无法运行，可能是该段内存没有被设置成可读、可执行、可写入，导致程序无法识别这段内存了，因此我们改变方法使用程序段的概念，通过对整个程序段进行加密解密，来实现smc技术#include<Windows.h>
#include<string>
#include<string.h>
using namespace std;
#include <iostream>
​
#pragma code_seg(".hello")
void Fun1()
{
     char flag[]="flag{this_is_test}";
   printf("%s",flag);
}
#pragma code_seg()
#pragma comment(linker, "/SECTION:.hello,ERW")
​
void Fun1end()
{
​
}
​
void xxor(char* soure, int dLen)   //异或
{
   for (int i = 0; i < dLen;i++)
  {
        soure[i] = soure[i] ^3;
  }
}
void SMC(char* pBuf)     //SMC解密/加密函数
{
   const char* szSecName = ".hello";
   short nSec;
   PIMAGE_DOS_HEADER pDosHeader;
   PIMAGE_NT_HEADERS pNtHeader;
   PIMAGE_SECTION_HEADER pSec;
   pDosHeader = (PIMAGE_DOS_HEADER)pBuf;
   pNtHe ader = (PIMAGE_NT_HEADERS)&pBuf[pDosHeader->e_lfanew];
   nSec = pNtHeader->FileHeader.NumberOfSections;
   pSec = (PIMAGE_SECTION_HEADER)&pBuf[sizeof(IMAGE_NT_HEADERS) + pDosHeader->e_lfanew];
   for (int i = 0; i < nSec; i++)
  {
       if (strcmp((char*)&pSec->Name, szSecName) == 0)
      {
           int pack_size;
           char* packStart;
           pack_size = pSec->SizeOfRawData;
           packStart = &pBuf[pSec->VirtualAddress];
           xxor(packStart, pack_size);
           return;
      }
       pSec++;
  }
}
​
void UnPack()   //解密/加密函数
{
   char* hMod;
   hMod = (char*)GetModuleHandle(0);  //获得当前的exe模块地址
   SMC(hMod);
}
int main()
{
  //UnPack();
   UnPack(); //
   Fun1();
   return 0;
}

这一段代码实现了一个简单的SMC自修改代码的技术，主要包括以下几个部分：

  1. 使用 #pragma code_seg 指令将 Fun1() 函数代码段定义为一个名为 ".hello" 的新代码段，使其与其他代码段隔离开来，方便后面的加密和解密。
  2. 使用 #pragma comment(linker, "/SECTION:.hello,ERW") 指令将 ".hello" 代码段设置为可读、可执行、可写入的，以便后面的加密和解密操作。
  3. .定义 Fun1end() 函数作为 Fun1() 函数的结束点，以便后面的加密操作。
  4. 定义 xxor() 函数用于将指定的字符串进行异或加密/解密。
  5. 定义 SMC() 函数，该函数用于解密指定代码段的内容。具体操作是遍历 PE 文件的各个段，找到指定代码段并对其进行解密。
  6. 定义 UnPack() 函数，该函数用于对当前进程的代码段进行解密操作。具体操作是获取当前模块的句柄，读取模块的 PE 文件并对指定代码段进行解密。
  7. 在 main() 函数中调用 UnPack() 函数进行解密操作，然后调用 Fun1() 函数进行计算。

代码写好之后，仍然需要我们自己手动先加密程序，在别的文章中所使用的方法和工具找了很久都没有找到，因此决定使用ida+idapython来实现对程序的加密，最后dump出程序，然后程序运行时会自己进行解密

我们需要的是将所有hello程序段的内容进行加密

idapython脚本：

 for i in range(0x417000,0x4170A4):
   patch_byte(i,get_wide_byte(i)^3)

虽然dump出来的程序能输出我们程序中的值，但是仍然出现了堆栈不平衡的问题，因此在终端运行程序时仍然会爆出内存错误的告警,这样的话只能自己手撸了，这里使用python语言，代码为:

import pefile
​
def encrypt_section(pe_file, section_name, xor_key):
   """
  加密PE文件中指定的区段
  """
   # 找到对应的section
   for section in pe_file.sections:
       if section.Name.decode().strip('\x00') == section_name:
           print(f"[*] Found {section_name} section at 0x{section.PointerToRawData:08x}")
           data = section.get_data()
           encrypted_data = bytes([data[i] ^ xor_key for i in range(len(data))])
           pe_file.set_bytes_at_offset(section.PointerToRawData, encrypted_data)
           print(f"[*] Encrypted {len(data)} bytes at 0x{section.PointerToRawData:08x}")
           return
​
   print(f"[!] {section_name} section not found!")
​
​
if __name__ == "__main__":
   filename = "test1.exe"#加密文件的名字,需要在同一根目录下
   section_name = ".hello"#加密的代码区段名字
   xor_key = 0x03#异或的值
​
   print(f"[*] Loading {filename}")
   pe_file = pefile.PE(filename)
​
   # 加密
   print("[*] Encrypting section")
   encrypt_section(pe_file, section_name, xor_key)
​
   # 保存文件
   new_filename = filename[:-4] + "_encrypted.exe"
   print(f"[*] Saving as {new_filename}")
   pe_file.write(new_filename)
   pe_file.close()

段代码实现了对PE文件中指定的代码区段进行异或加密的功能，具体解释如下：

  1. 导入pefile模块：该模块提供了解析PE文件格式的功能；
  2. 定义encrypt_section函数：该函数接收三个参数，分别是PE文件对象pe_file、待加密区段名称section_name和异或值xor_key。函数首先遍历PE文件中的所有区段，查找名字为section_name的区段；
  3. 对指定的代码区段进行加密：如果找到了名字为section_name的代码区段，该函数调用PE文件对象的set_bytes_at_offset方法，将指定区段中的每个字节和异或值异或，得到加密后的数据，并将加密后的数据写回指定区段。注意，set_bytes_at_offset方法需要传入一个字节串作为参数，因此需要将加密后的数据转换为字节串；
  4. main函数：该函数首先指定待加密的PE文件名filename、待加密的区段名称section_name和异或值xor_key。然后，它创建一个PE文件对象pe_file，读入PE文件；接着调用encrypt_section函数，对指定区段进行加密；最后，将加密后的文件写入新的文件中，并关闭PE文件对象。

这段代码的执行过程如下：

  1. 调用main函数，读取PE文件test1.exe；
  2. 找到名字为.hello的区段，对其中的每个字节和异或值0x03进行异或，得到加密后的数据；
  3. 将加密后的数据写回.hello区段，并将加密后的文件保存为test1_encrypted.exe。

终端运行成功后，在ida里面观察可以看到：

3.CTF实战

SCM在CTF里面有很多的运用，主要是用来对抗反调试和反编译等工具：

  1. 局部代码加密：CTF比赛中又很多加密的二进制程序，利用SMC技术可以对关键的代码进行加密
  2. 加密字符和常量：有很多加密的字符串和常量，这些字符串和常量通常用来存储关键信息，如密钥、密码等。利用 SMC 技术可以对这些字符串和常量进行加密，增加分析难度，提高程序的安全性
  3. 防止调试；有很多程序会使用调试器进行逆向分析，利用 SMC 技术可以对程序进行调试器检测和防御，防止调试器的使用
  4. 防止反编译：CTF 比赛中有很多程序会被反编译，利用 SMC 技术可以对程序进行反编译检测和防御，防止程序被反编译

[Hgame2023]patchme（例子）

点开文件可以看到一个可以的函数对我呢间的地址进行操作，怀疑是SMC加密技术

跟过去看看：

地址爆红，出现了大量的没有被解析的数据段，那么实锤此处就是SCM文件加密，那么我们就将其异或回去，hsiyongida或者idapython

运行idapython脚本之后发现本来ida无法识别的汇编代码变得可以识别了，那么我们声明所有的未声明函数

这样就可以写脚本解出这一道题了

#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cmath>
#include<map>
#include<vector>
#include<queue>
#include<stack>
#include<set>
#include<string>
#include<cstring>
#include<list>
#include<stdlib.h>
using namespace std;
typedef int status;
typedef int selemtype;
int ida_chars[] =
{
   0xFA, 0x28, 0x8A, 0x80, 0x99, 0xD9, 0x16, 0x54,
   0x63, 0xB5, 0x53, 0x49, 0x09, 0x05, 0x85, 0x58,
   0x97, 0x90, 0x66, 0xDC, 0xA0, 0xF3, 0x8C, 0xCE,
   0xBD, 0x4C, 0xF4, 0x54, 0xE8, 0xF3, 0x5C, 0x4C,
   0x31, 0x83, 0x67, 0x16, 0x99, 0xE4, 0x44, 0xD1,
   0xAC, 0x6B, 0x61, 0xDA, 0xD0, 0xBB, 0x55
};
int c[]={
   0x92, 0x4F, 0xEB, 0xED, 0xFC, 0xA2, 0x4F, 0x3B,
   0x16, 0xEA, 0x67, 0x3B, 0x6C, 0x5A, 0xE4, 0x07,
   0xE7, 0xD0, 0x12, 0xBF, 0xC8, 0xAC, 0xE1, 0xAF,
   0xCE, 0x38, 0x91, 0x26, 0xB7, 0xC3, 0x2E, 0x13,
   0x43, 0xE6, 0x11, 0x73, 0xEB, 0x97, 0x21, 0x8E,
   0xC1, 0x0A, 0x54, 0xAE, 0xB5, 0xC9,0x28
};
int main ()
{
   for(int i = 0 ; i <= 46 ; i ++ )
  {
       printf("%c",ida_chars[i]^c[i]);
  }
}

此学习来自于大佬的文章：探究SMC局部代码加密技术以及在CTF中的运用 - 知乎 (zhihu.com)

The world's full of lonely people afraid to make the first move.