1. 项目概述：从源码视角拆解一个C# EXE加密工具

最近在整理一些老项目时，翻出来一个几年前写的C# EXE文件加密工具。当时做这个工具的初衷很简单：有些交付给客户的小工具，不希望被轻易反编译或篡改，但又不想引入复杂的商业加壳软件，于是就自己动手写了一个。今天正好借着这个机会，把这个工具的源码拿出来，从头到尾拆解一遍。这不仅仅是一个源码分析，更像是一次对Windows PE文件结构、.NET程序集保护以及C#底层操作的实战回顾。无论你是想学习如何保护自己的.NET程序，还是对PE文件格式感兴趣，或者单纯想看看一个实用的C#工具是如何从零构建的，这篇文章都会给你带来不少干货。

这个工具的核心功能，是对一个标准的.NET可执行文件（.exe）进行“加密”。这里的“加密”打上引号，是因为它并非传统的对文件整体进行密码学变换，而是一种 运行时自解密 的保护方案。简单来说，它会将原始EXE中的核心代码段（通常是.text段）进行加密处理，然后生成一个新的“外壳”程序。当用户运行这个新程序时，外壳会先在内存中解密被保护的核心代码，再跳转到正确的入口点执行。整个过程对最终用户是无感的，但静态分析工具打开这个加密后的EXE，看到的将是一堆乱码，从而起到一定的混淆和保护作用。

2. 核心设计思路与方案选型

2.1 为什么选择“外壳+自解密”方案？

在动手之前，我评估过几种常见的.NET程序保护方案。商业加壳工具如ConfuserEx、.NET Reactor功能强大，但要么开源可控性差，要么过于笨重。纯粹的代码混淆（Obfuscation）会改变IL代码结构，但元数据依然暴露，使用dnSpy等工具仍然可以艰难地还原逻辑。而“外壳+自解密”方案，在复杂度、保护强度和自主可控性上取得了不错的平衡。

它的核心思想借鉴了传统的“打包器”（Packer）。原始程序被当作一段数据加密后，附加到一个新的启动器（Stub）后面。这个启动器是用C#编写的，它负责读取自身文件、定位加密数据、解密、最后在内存中加载并执行原始程序集。这种方案有几个关键优势：

1. 防静态分析 ：加密后的核心代码在磁盘上是以密文形式存在的，直接用反编译工具打开启动器，只能看到解密外壳的代码，看不到业务逻辑。
2. 灵活性高 ：加密算法、密钥管理方式、反调试技巧都可以在外壳程序中自定义和增强。
3. 对原始代码无侵入 ：不需要修改原始项目的源代码，保护是发布后的一个构建后步骤。

当然，它也有缺点，主要是会轻微增加程序启动时间（需要解密过程），并且如果外壳被攻破，则保护完全失效。但对于许多场景来说，这已经足够。

2.2 技术栈与关键决策点

整个工具基于.NET Framework 4.5+（也可兼容.NET Core/5+，需稍作调整）开发，没有依赖任何第三方库。选择这个版本是为了保证广泛的Windows系统兼容性。核心操作涉及到底层的文件流操作、字节数组处理、简单的对称加密以及最重要的—— 动态程序集加载 。

这里有一个关键决策点：如何执行解密后的程序集？在.NET中，有几种方式：

• Assembly.Load(byte[]) ：这是最直接的方法，将解密后的字节数组直接加载到当前应用程序域中。但这种方式下，解密后的程序集完全暴露在当前进程内存中，有一定风险。
• AppDomain 隔离加载 ：可以创建一个新的应用程序域来加载程序集，实现一定的隔离，但复杂度更高，且在.NET Core中 AppDomain 的支持有所变化。
• 进程注入 ：更底层的做法，但实现复杂且容易触发安全软件警报。

为了兼顾简单性和实用性，我最终选择了 Assembly.Load(byte[]) ，并辅以一些内存清理技巧。同时，外壳程序本身被混淆，并开启了“防调试”检测，增加逆向难度。

3. 源码结构深度解析

让我们打开解决方案，看看这个项目的具体结构。整个项目主要包含三个部分：加密器（Encrypter）、外壳存根（Stub）和一个共享的工具类库（CommonUtilities）。

3.1 加密器（Encrypter）项目剖析

加密器是一个控制台应用程序，它是整个工具的“生产端”。它的任务是将一个干净的Input.exe，加工成一个加密的Output.exe。我们来看它的 Program.cs 主逻辑。

class Program
{
    static void Main(string[] args)
    {
        if (args.Length < 2)
        {
            Console.WriteLine("Usage: Encrypter.exe <inputFile> <outputFile> [key]");
            return;
        }

        string inputPath = args[0];
        string outputPath = args[1];
        string key = args.Length > 2 ? args[2] : GenerateRandomKey();

        try
        {
            // 1. 读取原始EXE文件
            byte[] originalBytes = File.ReadAllBytes(inputPath);

            // 2. 定位并加密 .text 节区（代码段）
            byte[] encryptedBytes = EncryptTextSection(originalBytes, key);

            // 3. 将外壳存根（Stub）与加密后的数据合并
            byte[] stubBytes = GetStubAssemblyBytes(); // 获取编译好的外壳程序
            byte[] finalExe = MergeStubAndData(stubBytes, encryptedBytes, key);

            // 4. 写入最终文件
            File.WriteAllBytes(outputPath, finalExe);

            Console.WriteLine($"加密成功！密钥(请妥善保存): {key}");
            Console.WriteLine($"输出文件: {outputPath}");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"加密过程发生错误: {ex.Message}");
        }
    }

    // 其他辅助方法...
}

这个主流程非常清晰。但其中的魔鬼藏在细节里，尤其是 EncryptTextSection 和 MergeStubAndData 这两个方法。

EncryptTextSection 方法详解 这个方法的目标是精准地找到PE文件中存放IL代码和原生代码的 .text 节区，并对其加密。这要求我们对PE文件格式有基本了解。一个PE文件由DOS头、PE文件头、节区头表和多个节区数据组成。 .text 节区通常包含程序的执行代码。

private static byte[] EncryptTextSection(byte[] peBytes, string key)
{
    // 使用一个名为 PeParser 的辅助类来解析PE结构
    PeParser parser = new PeParser(peBytes);
    SectionHeader textSection = parser.GetSectionHeader(".text");

    if (textSection == null)
        throw new InvalidOperationException("找不到 .text 节区。");

    // 计算 .text 节区在文件中的实际偏移和大小
    int sectionOffset = textSection.PointerToRawData;
    int sectionSize = textSection.SizeOfRawData;

    // 提取 .text 节区的原始数据
    byte[] textData = new byte[sectionSize];
    Buffer.BlockCopy(peBytes, sectionOffset, textData, 0, sectionSize);

    // 使用AES算法加密（这里简化为示例，实际使用了更简单的异或+置换进行演示）
    byte[] encryptedData = SimpleEncrypt(textData, key);

    // 将加密后的数据拷贝回原字节数组
    Buffer.BlockCopy(encryptedData, 0, peBytes, sectionOffset, sectionSize);

    // 重要！需要修正节区头中的特征值，防止加载器认为它是可执行代码而直接运行（导致崩溃）
    // 通常将 Characteristics 中的 IMAGE_SCN_CNT_CODE 和 IMAGE_SCN_MEM_EXECUTE 标志位去掉
    // 这部分操作在 PeParser 类中完成
    parser.MarkSectionAsEncrypted(".text");

    return peBytes; // 返回修改后的整个PE文件字节数组
}

注意 ：在实际工业级工具中，加密整个 .text 节区可能过于粗暴，因为其中可能包含一些需要原样保留的固定结构（如CLI头）。更精细的做法是只加密包含IL代码的部分。本例为了演示清晰，做了简化。

MergeStubAndData 方法详解 加密后的数据需要和外壳程序合并。我采用了一种简单有效的方法：将加密后的整个 Input.exe 字节数组，以资源文件（Embedded Resource）的形式，编译进外壳程序。但这里是事后合并，所以采用的是“附加”方式。

private static byte[] MergeStubAndData(byte[] stubBytes, byte[] encryptedData, string key)
{
    // 方案：将加密数据和密钥，以自定义格式附加到Stub文件的末尾
    // 格式：[4字节数据长度][加密数据][4字节密钥长度][密钥字符串的UTF8字节]
    using (MemoryStream ms = new MemoryStream())
    {
        // 1. 写入原始Stub
        ms.Write(stubBytes, 0, stubBytes.Length);

        // 2. 写入分隔符（可选，用于标识附加数据开始位置）
        byte[] delimiter = Encoding.ASCII.GetBytes("|ENCRYPTED_PAYLOAD|");
        ms.Write(delimiter, 0, delimiter.Length);

        // 3. 写入加密数据长度和数据
        byte[] lengthBytes = BitConverter.GetBytes(encryptedData.Length);
        ms.Write(lengthBytes, 0, lengthBytes.Length);
        ms.Write(encryptedData, 0, encryptedData.Length);

        // 4. 写入密钥
        byte[] keyBytes = Encoding.UTF8.GetBytes(key);
        byte[] keyLengthBytes = BitConverter.GetBytes(keyBytes.Length);
        ms.Write(keyLengthBytes, 0, keyLengthBytes.Length);
        ms.Write(keyBytes, 0, keyBytes.Length);

        return ms.ToArray();
    }
}

这样，最终生成的 Output.exe 就是一个“杂交体”：前半部分是功能完整的C#外壳程序，后半部分是其需要处理的加密负载和密钥。外壳程序在运行时，需要知道如何从文件尾部读取这些数据。

3.2 外壳存根（Stub）项目剖析

外壳程序是最终用户直接运行的文件。它被设计得尽可能小且简单，核心任务就是“找到数据、解密数据、运行数据”。

外壳程序的入口点 为了让外壳程序能正确找到附加的数据，我们需要在编译时就知道一个“标记位置”。一种常见做法是，在Stub程序中预留一个空字节数组，加密器在合并时，计算好偏移量并填入数据。这里我们采用更动态的方法：从文件末尾反向查找。

[STAThread]
static void Main(string[] args)
{
    // 反调试技巧（可选）
    AntiDebug.Check();

    try
    {
        // 1. 获取当前运行的程序自身路径
        string currentExePath = Assembly.GetExecutingAssembly().Location;
        byte[] selfBytes = File.ReadAllBytes(currentExePath);

        // 2. 从自身字节数组中解析出加密负载和密钥
        // 我们需要知道自定义格式：...|ENCRYPTED_PAYLOAD|[4字节长度][数据][4字节密钥长度][密钥]
        int delimiterIndex = FindDelimiterIndex(selfBytes);
        if (delimiterIndex == -1)
            throw new InvalidOperationException("无法找到加密负载。");

        int dataStartIndex = delimiterIndex + delimiter.Length;
        int dataLength = BitConverter.ToInt32(selfBytes, dataStartIndex);

        int encryptedDataStartIndex = dataStartIndex + 4;
        byte[] encryptedData = new byte[dataLength];
        Buffer.BlockCopy(selfBytes, encryptedDataStartIndex, encryptedData, 0, dataLength);

        int keyLengthStartIndex = encryptedDataStartIndex + dataLength;
        int keyLength = BitConverter.ToInt32(selfBytes, keyLengthStartIndex);

        int keyStartIndex = keyLengthStartIndex + 4;
        string key = Encoding.UTF8.GetString(selfBytes, keyStartIndex, keyLength);

        // 3. 解密数据
        byte[] originalAssemblyBytes = SimpleDecrypt(encryptedData, key);

        // 4. 在内存中加载并执行程序集
        Assembly originalAssembly = Assembly.Load(originalAssemblyBytes);
        MethodInfo entryMethod = originalAssembly.EntryPoint;
        object[] parameters = entryMethod.GetParameters().Length > 0 ? new object[] { new string[0] } : null;
        entryMethod.Invoke(null, parameters);
    }
    catch (Exception ex)
    {
        // 错误处理，例如显示一个友好消息框或静默退出
        Console.WriteLine("程序启动失败: " + ex.Message);
        Environment.Exit(1);
    }
}

动态加载与执行的关键点 Assembly.Load(byte[]) 是魔法发生的地方。它将解密后的字节数组直接加载到当前应用程序域。随后，我们通过反射找到原始程序集的入口点（ EntryPoint ），并调用它。这里需要注意原始入口点的参数。对于控制台程序，入口点通常是 Main(string[] args) ，我们需要构造一个参数数组（通常是空数组）传入。对于WinForms或WPF程序，入口点通常是无参的， parameters 应为 null 。

实操心得 ：在实际测试中，我发现有些被加密的程序集依赖于特定的配置文件（如 App.config ）或附属程序集（DLL）。当从内存加载时，这些依赖可能无法被自动解析。一个变通方案是，在加密前，将这些依赖项也一并加密打包，在外壳启动时，将它们解压到临时目录，并在加载主程序集前，通过 AppDomain.CurrentDomain.AssemblyResolve 事件来解析这些依赖。这会显著增加外壳的复杂度。

3.3 共享工具类（CommonUtilities）解析

这个类库包含了加密器和外壳共用的部分，主要是加密解密算法和PE文件解析器。

轻量级加密算法 为了演示，我没有使用 System.Security.Cryptography 中的标准AES，而是实现了一个简单的混淆算法。在实际使用中， 强烈建议使用强加密算法（如AES） ，并将密钥妥善管理（例如，使用白盒加密技术或将密钥拆分存储）。

public static class SimpleCrypto
{
    // 这是一个非常简单的XOR+字节置换示例，仅用于演示，安全性很低。
    public static byte[] Encrypt(byte[] data, string key)
    {
        byte[] keyBytes = Encoding.UTF8.GetBytes(key);
        byte[] result = new byte[data.Length];

        for (int i = 0; i < data.Length; i++)
        {
            result[i] = (byte)(data[i] ^ keyBytes[i % keyBytes.Length]);
            // 简单的字节置换，例如循环左移1位
            result[i] = (byte)((result[i] << 1) | (result[i] >> 7));
        }
        return result;
    }

    public static byte[] Decrypt(byte[] data, string key)
    {
        // 解密是加密的逆过程
        byte[] keyBytes = Encoding.UTF8.GetBytes(key);
        byte[] result = new byte[data.Length];

        for (int i = 0; i < data.Length; i++)
        {
            byte temp = data[i];
            // 循环右移1位，还原置换
            temp = (byte)((temp >> 1) | (temp << 7));
            result[i] = (byte)(temp ^ keyBytes[i % keyBytes.Length]);
        }
        return result;
    }
}

PE文件解析器（PeParser类） 这是一个简化版的PE解析器，用于定位和修改节区头。它需要读取DOS头、PE签名、文件头、可选头和节区头表。核心是 GetSectionHeader 和 MarkSectionAsEncrypted 方法。这部分代码涉及大量的位操作和结构体映射，是项目中比较“硬核”的部分，需要参考微软的PE格式文档。

4. 完整构建与使用流程

4.1 环境准备与项目编译

1. 开发环境 ：Visual Studio 2019/2022，或使用 dotnet build 命令行。确保安装.NET Framework 4.5+或.NET 6 SDK。
2. 项目结构 ：
   • Encrypter ：控制台应用，负责加密。
   • Stub ：控制台应用（可改为Windows应用），作为外壳。
   • CommonUtilities ：类库，共享代码。
3. 编译顺序 ：首先编译 CommonUtilities ，然后编译 Stub 。因为 Encrypter 需要引用 Stub 项目编译出的EXE文件作为“模板”。在 Encrypter 的 GetStubAssemblyBytes() 方法中，我通常采用两种方式获取外壳字节：
   • 硬编码路径 ：指向 Stub 项目输出目录的 Stub.exe 。
   • 作为资源嵌入 ：将 Stub.exe 作为嵌入式资源编译进 Encrypter 。

4.2 加密工具实操步骤

假设我们已经编译好了 Encrypter.exe 和原始的 Stub.exe 。

1. 准备目标程序 ：将你想要保护的.NET程序（例如 MyApp.exe ）放在一个目录下。
2. 执行加密命令 ：

   Encrypter.exe MyApp.exe MyApp_Protected.exe MySecretKey123
   

   如果不提供密钥，工具会生成一个随机密钥并打印出来，务必保存。
3. 验证结果 ：运行生成的 MyApp_Protected.exe ，其功能应与原 MyApp.exe 完全一致。尝试用dnSpy或ILSpy打开 MyApp_Protected.exe ，你应该只能看到外壳程序的解密逻辑，而看不到 MyApp 的真实业务代码。

4.3 集成到CI/CD流程

为了使保护过程自动化，可以将此工具集成到项目的生成后事件（Post-Build Event）中。

在Visual Studio中，右键点击主项目 -> 属性 -> 生成事件 -> 后期生成事件命令行，可以添加如下命令：

"$(SolutionDir)Tools\Encrypter.exe" "$(TargetPath)" "$(TargetDir)$(TargetName)_Protected$(TargetExt)" "$(ConfigurationName)_$(TargetName)_Key"

这样，每次编译成功后，都会在输出目录生成一个已保护的版本。

5. 进阶优化与安全增强

基础的版本已经能工作，但离“坚固”还差得远。以下是一些可以增强的方向：

5.1 外壳程序的保护（反逆向）

外壳本身是防线的最前沿，必须加固。

• 代码混淆 ：使用开源混淆器（如Obfuscar）对外壳项目进行混淆，防止解密逻辑被轻易读懂。
• 反调试 ：在Stub的 Main 方法开始处加入检测。

  static class AntiDebug
  {
      [DllImport("kernel32.dll")]
      static extern bool IsDebuggerPresent();
      public static void Check()
      {
          if (IsDebuggerPresent() || System.Diagnostics.Debugger.IsAttached)
          {
              Environment.FailFast("Debugger detected!");
          }
      }
  }
  

• 虚拟机检测 ：简单的检测可以增加在沙箱或分析环境中自动退出的能力。
• 压缩外壳 ：使用UPX等工具压缩外壳程序，改变其熵值，增加分析难度。

5.2 加密方案的强化

• 使用强加密算法 ：将 SimpleCrypto 替换为AES（CBC模式）或ChaCha20。
• 密钥白盒化 ：不要将密钥明文存储在文件末尾。可以将密钥算法融合到解密代码中，或者使用白盒加密技术，使得密钥无法被直接提取。
• 分段加密 ：不加密整个 .text 节区，而是加密其中几个关键的函数或方法体，其余部分保留，这样对原程序运行的干扰更小。
• 完整性校验 ：对加密后的数据计算HMAC，在外壳解密前先校验完整性，防止被篡改。

5.3 处理依赖项与复杂场景

• 依赖程序集加载 ：如前所述，实现 AssemblyResolve 事件处理程序，从嵌入的资源或临时文件中加载所需的DLL。
• 配置文件 ：同样，将 App.config 等文件嵌入，在运行时动态创建。
• 动态代码生成 ：对于特别敏感的逻辑，可以考虑在运行时通过 Reflection.Emit 动态生成代码，而非静态存储。

6. 常见问题、排查技巧与局限性

6.1 问题排查速查表

问题现象	可能原因	排查步骤
加密后的程序无法运行，提示“不是有效的Win32应用程序”	PE头在加密/合并过程中被破坏。	1. 检查 PeParser 类是否正确解析了节区偏移。 2. 确保加密操作没有覆盖DOS头、PE签名等关键区域。 3. 使用PE查看工具（如PE-bear）对比加密前后文件的头信息。
程序运行后立即退出，无错误信息	外壳程序的反调试检测触发，或解密/加载过程出现异常被静默捕获。	1. 暂时注释掉 AntiDebug.Check() 代码。 2. 在外壳的 try-catch 块中，将异常详细信息写入日志文件。 3. 使用 Process Monitor 工具查看程序运行时的文件和注册表访问，寻找失败点。
程序运行时报“找不到程序集或文件”	原始程序集依赖的DLL未找到。内存加载时，依赖解析失败。	1. 确认原始程序的所有依赖DLL是否与其在同一目录。 2. 在外壳程序中实现 AppDomain.CurrentDomain.AssemblyResolve 事件，尝试从嵌入资源或特定路径加载。
被加密的程序功能异常（如文件读写错误）	加密破坏了程序中的某些硬编码偏移或资源。	1. 确保加密只针对纯代码段（.text），避免加密.data、.rsrc（资源）等节区。 2. 尝试对更小的、特定的代码块进行加密测试。
杀毒软件报毒	外壳程序的行为（读取自身、内存加载程序集）符合某些病毒木马的特征。	1. 为外壳程序添加数字签名。 2. 向杀毒软件厂商提交误报。 3. 调整外壳代码，使其行为更“温和”。

6.2 本方案的局限性

必须清醒认识到，这种自制的加密保护方案有其天花板：

1. 并非绝对安全 ：对于有经验的反向工程师，可以动态调试（过掉反调试），在外壳解密完成、程序集加载到内存后，使用内存转储工具（如 dumpbin 或 Scylla ）直接抓取解密后的完整程序集，前功尽弃。
2. 性能开销 ：每次启动都有解密过程，对于大型程序会有可感知的延迟。
3. 兼容性风险 ：对PE文件的直接操作如果不够严谨，可能导致在某些系统或环境下无法运行。
4. 维护成本 ：需要自行维护加密工具链，随着.NET版本更新可能需要调整。

因此，这个项目更适合作为学习PE结构、程序集加载和基础软件保护的绝佳实践。对于需要商业级保护的场景，仍然推荐使用经过时间检验的商业加壳产品，或者将关键服务放在服务器端。

6.3 一个实用的调试技巧

在开发外壳程序时，最头疼的是它一旦加密就不好调试。我的做法是：在 Stub 项目中，添加一个编译条件。

static void Main(string[] args)
{
#if DEBUG
    // 调试模式：直接运行一个测试逻辑，或者从固定文件读取加密数据
    RunDebugMode();
    return;
#endif
    // 发布模式的正式逻辑...
}

这样，在开发阶段，直接用调试模式运行 Stub 项目，可以快速测试解密和加载逻辑。发布时，再编译成Release版本供 Encrypter 使用。

回过头看，这个项目虽然代码量不大，但涉及的知识点却横跨了Windows PE格式、.NET程序集机制、密码学应用和软件保护思路。它可能无法抵挡专业的破解者，但足以让普通的静态分析工具失效，为你的.NET程序增加一道实用的“防盗门”。更重要的是，通过亲手实现它，你会对.NET程序的运行本质有更深的理解。如果你正在学习C#和系统编程，不妨也试着实现一个，过程中遇到的每一个问题，都是极好的学习机会。