C# 程序的特征识别

C# 是微软公司发布的一种由 C 和 C++ 衍生出来的面向对象的编程语言,运行于 .NET Framework 和 .NET Core(完全开源)之上的高级程序设计语言。使用 .NET 框架提供的编译器可以直接将源程序编译为 .exe 或 .dll 文件,但此时编译出来的程序代码并不是 CPU 可以直接执行的机器代码,而是一种中间语言 IL 的代码。这种特殊的编译方式使得 C# 程序具有一些独特的特征,我们可以通过这些特征快速判断一个程序是否是用 C# 编写的

当我们把一个 C# 编译的 exe 拖进 IDA 里时,能看到一个没见过的加载项 pe64.dll

而且反汇编窗口里只能看到 IL 的代码(类似 Python 的 pyc 字节码)

这就说明这个程序是 C# 编写的。不过实际上我们不需要每次都用 IDA 打开来判断,使用 Exeinfo PE 工具可以快速识别程序类型,如果显示 .NET 或 MSIL 字样,那就是 C# 程序,同时还能看到编译器版本信息以及程序是 32 位还是 64 位

C# 基础语法速览

C# 语法和 Java 很像,如果你有 C++ 以及 Java 基础,仅仅搞逆向的话就没必要太过深入地学习 C# 的语法,因为就算一个方法你不懂它的功能,但是仅仅通过名字也能大概猜出来。不过简单的基础我们还是要了解下的,C# 程序文件是以 cs 为后缀名结尾的,开发 C# 程序一般都用 Visual Studio 编译器进行开发。假设项目名为 RE,基本的 C# 代码结构如下:

using System; // 引入命名空间

namespace RE // 默认的命名空间
{
    class Program // 定义程序类
    {
        static void Main(string[] args) // 主方法,程序入口
        {
            Console.WriteLine("Hello, World!"); // 输出到控制台
        }
    }
}

在逆向分析中,我们经常会遇到一些常用的类和方法。Console 类用于控制台操作,其中 Write 方法用于输出文本,WriteLine 方法用于输出文本并换行,ReadLine 方法用于读取一行文本。String 类提供了许多字符串操作方法,比如字符串连接可以直接使用加号运算符 string demo = "hello" + " " + "world",字符串格式化可以使用 string.Format("Hello, {0}!", "Alice"),字符串替换使用 Replace 方法,子串提取使用 Substring 方法,判断字符串包含使用 Contains 方法,字符串拆分使用 Split 方法。这些方法在逆向分析时经常遇到,熟悉它们能帮助我们快速理解程序逻辑

  • Console类

Write方法:输出文本。

Console.Write("hello");

WriteLine方法:输出文本并换行ReadLine方法:读取一行文本。

Console.WriteLine("hello");
  • String类:字符串类型类,提供了许多方法来处理字符串。

连接字符串:

string demo="hello"+" "+"world"

字符串格式化:

string formatted = string.Format("Hello, {0}!", "Alice");  // 格式化字符串
Console.WriteLine(formatted);

字符串替换

string str = "Hello, World!";
string replaced = str.Replace("World", "C#");  // 替换部分文本
Console.WriteLine(replaced);  // 输出 "Hello, C#!"

子串提取(类似于切片):

string sub = "Hello, World!".Substring(7, 5);  // 提取子串 "World"
Console.WriteLine(sub);

判断字符串包含:

bool contains = "Hello, World!".Contains("World");  // 判断是否包含 "World"

字符串拆分:

string sentence = "apple,banana,cherry";

string[] fruits = sentence.Split(',');  // 拆分为数组 ["apple", "banana", "cherry"]

C# 逆向工具

dnSpy 工具详解

dnSpy 工具是专门用于逆向 C# 程序的工具,可以说是 C# 逆向的必备神器。我们首先根据程序位数选择 dnSpy32 或 dnSpy64 打开程序,打开后可以看到程序的命名空间结构,展开命名空间就能查看代码,在项目命名空间下可以看到我们编写的代码。dnSpy 会将 IL 代码反编译成 C# 源码,几乎和原始代码一模一样,你可以直接看到类的定义、方法的实现、变量的类型以及字符串常量

dnSpy 同样也支持交叉引用功能,右键某个方法或变量选择"分析",可以看到哪些地方调用了这个方法、哪些地方使用了这个变量以及方法的调用关系图,这对于理解程序的整体逻辑非常有帮助。调试功能也是 dnSpy 的一大亮点,不过调试程序的话程序必须是 debug 编译的才行,dnSpy 支持设置断点、单步执行、查看变量值以及修改内存等操作。最强大的功能之一是打补丁,dnSpy 支持源码级别编辑类属性和类方法,你可以直接修改代码逻辑然后保存为新的 exe 文件,这在某些需要绕过验证的场景下非常方便

脱壳与去混淆

有些程序为了防止逆向,会使用混淆工具对代码进行混淆。混淆后的代码最明显的特征就是随机字符串混淆,那些以 \u 开头的都是 Unicode 编码

这样的代码虽然能运行但是阅读起来非常困难。de4dot 是一个强大的 .NET 程序脱壳和反混淆工具,支持对多种混淆工具混淆的代码进行去混淆

  • Agile.NET (aka CliSecure)
  • Babel.NET
  • CodeFort
  • CodeVeil
  • CodeWall
  • CryptoObfuscator
  • DeepSea Obfuscator
  • Dotfuscator
  • .NET Reactor
  • Eazfuscator.NET
  • Goliath.NET
  • ILProtector
  • MaxtoCode
  • MPRESS
  • Rummage
  • Skater.NET
  • SmartAssembly
  • Spices.Net
  • Xenocode

常见混淆的特征:

  • 随机字符串混淆

de4dot 工具的项目地址是 https://github.com/de4dot/de4dot ,不过程序并没有发布版本,所以要我们自己进行编译。下载的包中有两个解决方案,一个是基于 .NET Core 的需要安装 netcoreapp3.1 和 netcoreapp2.1,一个是基于 .NET Framework 的需要安装 net35 和 net45。通过 Visual Studio 打开解决方案,然后右键解决方案选择"重新生成解决方案"即可进行编译

编译完成后,使用方法非常简单。直接去混淆的命令是

./de4dot/bin/Debug/de4dot.exe myApp.dll

程序会自动识别混淆类型并进行去混淆,去混淆后的文件会保存为 myApp-cleaned.dll。如果你知道具体的混淆类型,也可以指定混淆类型去混淆,比如

./de4dot/bin/Debug/de4dot.exe myApp.dll -P sa

表示使用 SmartAssembly 的去混淆规则。de4dot 支持的混淆类型可以通过 de4dot.exe --help 查看,每种混淆器都有对应的参数标识

实战案例一:CFI-CTF 2018 IntroToPE

这是一道非常基础的 C# 逆向题目。首先使用 Exeinfo PE 查看程序,发现为 C# 程序

然后用 dnSpy 打开反编译。进入程序命名空间,打开 ValidatePasswd 类查看,可以看到程序的主要逻辑就在这个类中。分析 ValidatePasswd 类的代码,发现程序将输入通过 Convert.ToBase64String 方法编码为 base64,然后与一串密文 Q0ZJey5OZXRDI18xc19AdzNzMG0zfQ== 进行比较。如果输入内容与密文比较相等,则 result 为 true 即返回相等。这个逻辑非常简单,很明显那串密文就是 base64 编码,我们直接拿密文进行 base64 解密就能拿到 flag

using System;
using System.Text;

namespace IntroToPe
{
    internal class ValidatePasswd
    {
        public ValidatePasswd(string passwd)
        {
            this.passwd = passwd;

        }

        public bool verifyPasswd()
        {
            bool result = false;
            bool flag = Convert.ToBase64String(Encoding.UTF8.GetBytes(this.passwd)) == "Q0ZJey5OZXRDI18xc19AdzNzMG0zfQ==";
            if (flag)
            {
                result = true;
            }
            return result;
        }

        private string passwd;
    }
}

使用在线 base64 解码工具或者命令行工具解密密文,得到 flag 为 CFI{.NetC#_1s_@w3s0m3}。这道题目虽然简单,但是很好地展示了 C# 逆向的基本流程:识别程序类型、使用 dnSpy 反编译、分析代码逻辑、找到关键验证点、逆向算法得到 flag

实战案例二:ISC+2016 Classical+CrackMe

这道题目相比第一题增加了混淆的难度,是一个很好的去混淆实战案例。首先用 dnSpy 打开程序,发现程序被加了混淆,所有的类名、方法名、变量名都变成了 Unicode 编码的随机字符串,根本无法阅读。这时候就需要用到我们前面介绍的 de4dot 工具来去混淆了

使用命令 de4dot.exe Classical+CrackMe.exe 对程序进行去混淆,de4dot 会自动识别混淆类型并进行处理,处理完成后会生成一个 Classical+CrackMe-cleaned.exe 文件。用 dnSpy 打开去混淆后的文件,可以看到代码已经清晰了很多,虽然变量名还是一些无意义的字符,但是至少可以看清楚程序的逻辑结构了

分析去混淆后的主要逻辑代码,可以看到程序在 button1_Click 方法中处理按钮点击事件。程序首先通过 textBox1.Text.ToString() 获取输入的字符串,然后使用 Encoding.Default.GetBytes(s) 将字符串转换为字节数组,接着使用 Convert.ToBase64String(bytes) 将字节数组编码为 base64 字符串,最后与密文 UENURntFYTV5X0RvX05ldF9DcjRjazNyfQ== 进行比较。如果相等则弹出"注册成功!"的提示框,否则弹出"注册失败!"的提示框。

using System;
using System.ComponentModel;
using System.Drawing;
using System.Text;
using System.Windows.Forms;

public class Form1 : Form
{
    public Form1()
    {
        this.InitializeComponent();
    }

    private void Form1_Load(object sender, EventArgs e)
    {
    }

    private void button1_Click(object sender, EventArgs e)
    {
        string s = this.textBox1.Text.ToString();
        byte[] bytes = Encoding.Default.GetBytes(s);
        string a = Convert.ToBase64String(bytes);
        string b = "UENURntFYTV5X0RvX05ldF9DcjRjazNyfQ==";
        if (a == b)
        {
            MessageBox.Show("注册成功!", "提示", MessageBoxButtons.OK);
        }
        else
        {
            MessageBox.Show("注册失败!", "提示", MessageBoxButtons.OK, MessageBoxIcon.Hand);
        }
    }

    private void textBox1_TextChanged(object sender, EventArgs e)
    {
    }

    private void button2_Click(object sender, EventArgs e)
    {
        base.Close();
    }

    protected virtual void Dispose(bool disposing)
    {
        if (disposing && this.icontainer_0 != null)
        {
            this.icontainer_0.Dispose();
        }
        base.Dispose(disposing);
    }
}

这道题的加密逻辑和第一题一样,都是简单的 base64 编码。直接解密 base64 密文 UENURntFYTV5X0RvX05ldF9DcjRjazNyfQ==,得到 flag 为 PCTF{Ea5y_Do_Net_Cr4ck3r}。这道题目的重点不在于加密算法的复杂度,而在于展示了如何使用 de4dot 工具去除混淆,这在实际的逆向工作中是非常常见的场景

实战案例三:2024Moectf dotNet

这道题目是一个稍微复杂一点的加密算法题,需要我们理解程序的加密逻辑并编写解密脚本。下载附件拿到一个 dll 文件,根据题目名称判定为 C# 逆向。我们用 dnSpy 打开可执行文件,在项目的命名空间中我们可以看到 Main 函数,进入查看发现程序的主要逻辑就在 Main 函数中

程序首先定义了一个字节数组 array,这个应该就是密文。然后提示输入 flag 并以 text 变量接收输入,接着判断输入的 flag 长度是否与密文长度一样,如果不一样则输出"Flag is WRONG!!!"并退出。如果长度相同,程序会遍历输入的每个字符并进行验证,验证的核心逻辑是 (byte)((int)((byte)text[i] + 114 ^ 114) ^ i * i) != array[i],如果这个条件成立说明输入错误,num 会被置为 0。最后如果 num 保持为 1,说明 flag 是正确的

private static void <Main>$(string[] args)
{
    byte[] array = new byte[]
    {
        173, 146, 161, 174, 132, 179, 187, 234, 231, 244, 177, 161, 65, 13, 18, 12,
        166, 247, 229, 207, 125, 109, 67, 180, 230, 156, 125, 127, 182, 236, 105, 21,
        215, 148, 92, 18, 199, 137, 124, 38, 228, 55, 62, 164
    };

    Console.WriteLine("Input Your Flag:");
    string text = Console.ReadLine();

    if (text.Length != array.Length)
    {
        Console.WriteLine("Flag is WRONG!!!");
        return;
    }

    int num = 1;

    for (int i = 0; i < array.Length; i++)
    {
        if ((byte)((int)((byte)text[i] + 114 ^ 114) ^ i * i) != array[i])
        {
            num &= 0;
        }
    }

    if (num == 1)
    {
        Console.WriteLine("Correct Flag!!!");
        return;
    }

    Console.WriteLine("Flag is WRONG!!!");
}

分析加密逻辑,程序对输入的每个字符先加 114 然后再异或 114,之后与 i*i 异或再与密文进行比较。根据这个加密逻辑编写解密脚本,将加密逻辑逆过来就是:先与 i*i 异或,然后再与 114 异或,最后减去 114。这里有一个重要的点需要注意,C# 和 Python 的 int 精度是不一样的,Python 的精度是无限的,所以我们这里要与上 0xff 将它限制在一字节范围内

enc = [
    173, 146, 161, 174, 132, 179, 187, 234, 231, 244, 177, 161, 65, 13, 18, 12,
    166, 247, 229, 207, 125, 109, 67, 180, 230, 156, 125, 127, 182, 236, 105, 21,
    215, 148, 92, 18, 199, 137, 124, 38, 228, 55, 62, 164
]

flag = ""
for i in range(len(enc)):
    flag += chr(((enc[i] ^ (i * i)) ^ 114) - 114 & 0xff)

print(flag)

运行脚本得到 flag,这道题目展示了如何分析稍微复杂一点的加密算法,以及如何编写解密脚本。在实际的 CTF 比赛中,很多 C# 逆向题目都是这种类型,需要我们理解加密逻辑然后编写脚本解密

总结

本文介绍了 C# 逆向的基础知识,包括 C# 程序的特征识别、dnSpy 工具的使用、de4dot 去混淆工具的使用,以及通过三个实战案例展示了 C# 逆向的基本流程。C# 逆向相比传统的二进制逆向要简单很多,因为 IL 代码保留了大量的符号信息,使用 dnSpy 可以直接反编译成几乎和源代码一样的形式