自动化解密 .NET XORStringsNet 混淆器
针对在 Agent Tesla 等知名 .NET 恶意软件中泛滥的 XORStringsNet 混淆器,本文详细记录了分析师如何抛弃繁琐的传统手动逆向分析,开发出一款高效、全自动的 Python 批量解密工具的实战全过程。
一、研究背景
笔者在研究Agent Tesla 和 Redline Stealer 等知名的 .NET 恶意软件家族的时候,会发现它们会使用XORStringsNet 的开源混淆器,为什么呢?因为这个混淆器已经编译好了,一键进行混淆使用,减少了使用成本,所以被广泛的应用。
对于恶意软件使用XORStringsNet的现象,XORStringsNet也发现了这个问题,因此发布了一个检测Yara规则,同时也写了一个博客解析如何进行解密。
规则如下:
import "dotnet"
rule msil_susp_obf_xorstringsnet {
meta:
description = "Detects XorStringsNET string encryption, and other obfuscators derived from it"
author = "dr4k0nia"
version = "1.0"
date = "26/03/2023"
strings:
$pattern = { 06 1E 58 07 8E 69 FE17 }
condition:
uint16(0) == 0x5a4d
and filesize < 25MB
and dotnet.is_dotnet
and $pattern
}作为安全研究人员,如果只是偶尔分析一个样本,使用反编译工具(如 dnSpy)手动顺藤摸瓜找出加密字符串的内存地址,并非难事。对于现实而言,这些恶意软件开发者应该已经将其进行工程化、自动化,因为会大量的生成样本。因此,笔者要开发一个能够脱离人工干预、全自动在二进制文件中提取并解密字符串的 Python 工具。
可以通过 yara回扫来进行验证,XORStringsNet被大量的使用:
二、算法分析
2.1 作者文章解析
XORStringsNet发现开源的混淆器被大量恶意软件利用后,写了一个算法加密说明博客,同时也同步了一个解密方法。
具体链接:https://dr4k0nia.github.io/posts/Encrypting-Strings-In-NET/,阅读这个文章后,我们需要得出几个东西。
第一个内容:加密后数据在文件中的结构为:
加密数据长度(4字节):XOR解密key(4字节):加密数据(N)
第二个内容:定位加密的字符串,在文章中作者简单阐述的加密字符串存放的特征。一个已经初始化的空结构+一个字段。同时在解密的时候还可以看到一个 cpblk 特殊指令进行使用。
2.2 加密源码分析和解密算法分析
加密代码:https://github.com/dr4k0nia/XorStringsNET/blob/master/XorStrings/EncryptionService.cs
笔者在阅读代码的时候,发现这个作者历史版本有一个bug,就是只使用key的第一个位进行加密,并且后续的key并没有使用,其实这个导致加密后的样本是可以进行暴力破解的(分析的样本使用的之前有Bug的版本,后续论证)。
解密代码:
2.3 作者解密方法分析
https://gist.github.com/dr4k0nia/e59a9902a06da3c875333a98fe856082
作者的思路是,解密函数会在二进制中频繁出现,其实就找到了解密函数,同时函数每次都会传入一个较大的整数值,同时返回值是 string等等(还有其他特征,具体查看上述链接)。
作者找到解密函数后,使用 de4dot.exe file --strtyp delegate --strtok 0x6000000进行解密,这个的原理是:使用 de4dot.exe 委托调用解密函数来获取解密的字符串。这种使用的情况是,de4dot 自动模式没发现它时,就用这个“暴力”手段告诉 de4dot 直接去调用那个 Token 对应的函数。
Token如何理解呢?把 .NET 程序集想象成一本巨大的字典:Token 就是这本字典的“页码 + 行号”。函数名 就是“单词本身”。混淆 就像是把单词改成了谁也看不懂的符号,但页码和行号(Token)是印在纸上的物理位置,混淆器无法改变这个索引逻辑,所以它是逆向分析时最稳定的定位符。所以Token可以代表的是函数位置,函数名在混淆的情况下不能确信。
研究样本sha256:023e6c15dfda31d4aeea82eba8254aba50cddf0efb6c54546da3769d8ebf3e70
作者方法使用:
找到解密函数:
点进去后,不难发现,这个函数有被进行状态机混淆,但是不影响我们查看核心解密逻辑:下面三幅图就可确定解密函数
然后找到解密函数的 token,使用 de4dot 进行委托调用:
打开后缀为_clean的程序,不难看出字符串已经被解密:
上述的方法从单个脚本使用是没有问题呢,但是对于自动化分析还是无法使用的,因为毕竟是模拟执行函数,只能在虚拟机中运行,无法在物理机中运行,因此笔者需要进一步研究,实现自动化Python脚本解密。
2.4 手动解密
步骤1:定位解密字符串
点击加密串的 RVA:
拆分加密表:
[随机ID][长度] [密钥] [数据][长度] [密钥] [数据]
步骤2:使用cyberchef验证解密
异或key:DD 7E 30 72
加密数据:AD B0 A9 F3 BA B2 B1 F2
使用全部的key进行解密:
使用第一个字节进行解密:这里就证明了之前有bug的版本也有很多程序使用
2.5 程序解密
import struct
import io
def decrypt_logic(encrypted_data, extra_key):
# 将 bytes 转为可变的 bytearray
buf = bytearray(encrypted_data)
n = len(buf)
key = extra_key & 0xFF # 只取低 8 位,对应 C# 的 (byte) 强制转换
# 核心:Python 风格的处理双指针逻辑
# 我们只需要循环到一半即可
for i in range(n // 2):
opposite = n - 1 - i
# 严格遵循 C# 里的三步 XOR 交换混淆逻辑
buf[i] ^= buf[opposite]
buf[opposite] ^= (buf[i] ^ key) # 注入了 Key,这是单纯 reverse 做不到的
buf[i] ^= buf[opposite]
# 处理奇数长度的中间字节(C# 逻辑:buffer[buffer.Length >> 1] ^= key)
if n % 2 != 0:
buf[n // 2] ^= key
return bytes(buf)
def run_deobfuscator(file_path, offset):
with open(file_path, 'rb') as f:
f.seek(offset + 4) # 跳过那 4 字节的全局锚点
data_pool = f.read()
stream = io.BytesIO(data_pool)
while True:
# 读取 4 字节长度
len_raw = stream.read(4)
if len(len_raw) < 4: break
size = struct.unpack('<I', len_raw)[0]
if size == 0 or size > 0xFFFF: break # 安全阈值
# 读取 4 字节 Extra Key
key_raw = stream.read(4)
if len(key_raw) < 4: break
extra_key = struct.unpack('<I', key_raw)[0]
# 读取加密内容
payload = stream.read(size)
# 执行解密
decrypted = decrypt_logic(payload, extra_key)
try:
print(f"解密结果: {decrypted.decode('utf-8')}")
except:
print(f"原始字节: {decrypted.hex()}")
# 执行
run_deobfuscator(r"C:\你的文件路径", 0x00019D7B)offset获取:
效果:
其中上面代码有点繁琐了,因为模拟了C#原始代码中的字节反转,其实简单的方式就是将解密后的内容进行反转即可。
三、自动化解密
在第二部分,笔者已经实现了脚本化解密字符串,但是存在一个核心的问题,就是关于 offset 的定位,在上述中笔记是通过 dnspy 进行逆向样本然后获取的 offset 具体的值,但是面对大量样本的时候根本如此操作,因此需要进行通用化方法来进行获取 offset。通用定位也是这种批量化的难点所在。
3.1 方案设想
方案1:统计调用次数:遍历程序的所有指令,寻找被调用次数最多的那个函数。因为程序在运行过程中需要不断解密不同的字符串,解密函数的调用频率会异常高 。
方案2:利用特征签名:寻找特殊的“嵌套私有结构体”等独特代码签名。一旦通过这种独一无二的特征定位到了对应的类(Class),就能顺藤摸瓜找到属于该类的字符串表 。
方案3:暴力搜索大体积结构体:不再纠结于复杂的代码逻辑,而是直接在文件里寻找所有体积庞大的数据结构体,然后把它们全部当作嫌疑对象,挨个进行暴力解密尝试 。
第一种方式需要模拟函数,所以笔者一开始就不考虑,第二种方式在思考了很久后,也进行放弃了,因为在 .NET 中,数据的类型定义和数据在内存中的实际物理地址是分离的。即使我们通过前面的思路,在 TypeDef(类型定义表)里找到了那个“私有、嵌套”的大体积结构体,这也仅仅是找到了这块数据的“设计图纸”。图纸本身不包含这段加密字节码在文件中的真实位置(RVA - 相对虚拟地址)。 按照正规流程,要在 .NET 中建立这种联系,需要在多个表格之间进行复杂的交叉引用(例如:从 TypeDef 找到其包含的字段 Field,然后再去 FieldRVA 表中查找该字段对应的内存地址)。
最终采用第三种方案。
3.2 实际方案落地(AI优化的代码)
import struct
import dnfile
def xor_crypt(data: bytes, key: int) -> str:
"""
单字节 XOR 解密核心函数
将字节流中的每一个字节与 key 进行异或操作,并尝试解码为字符串
"""
decrypted = bytearray()
for b in data:
decrypted.append(b ^ key)
# 忽略解码中可能出现的错误乱码
return decrypted.decode('utf-8', errors='ignore')
def extract_and_decrypt_strings(file_path: str):
"""
主函数:自动化寻找并解密 XORStringsNet 混淆的字符串
"""
print(f"[*] 正在分析文件: {file_path}")
pe = dnfile.dnPE(file_path)
# ==========================================
# 步骤 1:找出体积最大的结构体(寻找“嫌疑目标”)
# ==========================================
class_size_list = []
for row in pe.net.mdtables.ClassLayout.rows:
type_row = pe.net.mdtables.TypeDef.rows[row.Parent.row_index - 1]
# 如果该类有明确的物理大小 (ExplicitLayout)
if type_row.Flags.tdExplicitLayout:
class_size_list.append(row.ClassSize)
if not class_size_list:
print("[-] 未找到任何具有固定大小的结构体。")
return []
target_class_size = max(class_size_list)
print(f"[+] 锁定目标结构体大小: {target_class_size} 字节")
# ==========================================
# 步骤 2:利用连续地址相减,反推内存地址 (RVA)
# ==========================================
target_rva = None
field_rva_rows = pe.net.mdtables.FieldRva.rows
# 遍历所有记录了物理地址的行
for i in range(len(field_rva_rows) - 1):
curr_row = field_rva_rows[i]
next_row = field_rva_rows[i + 1]
# 如果两块数据的地址差正好等于我们要找的最大体积
if next_row.Rva - curr_row.Rva == target_class_size:
target_rva = curr_row.Rva
break
# 如果没找到匹配的差值,假设它是表里的最后一个结构体
if target_rva is None and field_rva_rows:
target_rva = field_rva_rows[-1].Rva
if not target_rva:
print("[-] 无法确定目标结构体的内存地址。")
return []
print(f"[+] 锁定目标内存地址 (RVA): {hex(target_rva)}")
# ==========================================
# 步骤 3:提取原始加密数据
# ==========================================
data = pe.get_data(target_rva, target_class_size)
# ==========================================
# 步骤 4:根据漏洞逻辑进行精准切割与解密
# ==========================================
strings = []
ptr = 4 # 指针初始化:直接跳过前 4 个字节的“全局密钥”(因为作者分析发现它没用)
while ptr < len(data):
# 防越界检查
if ptr + 4 > len(data):
break
# 读取当前字符串的长度 (4字节,小端序)
size = struct.unpack('<I', data[ptr:ptr+4])[0]
# 如果长度为 0 或大得离谱,说明到了数据末尾或读到了垃圾数据
if size == 0 or size > 0x100:
break
ptr += 4
# 提取密钥:这里原本是 4 字节,但漏洞导致只用了 1 字节
key_byte = data[ptr] # 直接取第一个字节作为 key
ptr += 4 # 指针依然跨过 4 字节的密钥槽位
# 提取密文并移动指针
str_data = data[ptr:ptr+size]
ptr += size
# 漏洞利用:将密文逆序 ([::-1]) 后,与单字节密钥进行 XOR 解密
out = xor_crypt(str_data[::-1], key_byte)
# 验证解密是否成功(如果解出来的全是乱码,说明找错地方了)
if not out.isascii() or len(out.strip()) == 0:
break
strings.append(out)
print(f"[+] 成功解密 {len(strings)} 个字符串!")
return strings
# 运行示例
# decrypted_strings = extract_and_decrypt_strings("sample.exe")
# for s in decrypted_strings:
# print(s)核心思想:
思想1:获取ClassSize
在 .NET 程序中,开发者如果要在代码里硬编码一大段连续的数据(比如字节数组),编译器通常会为它生成一个带有 tdExplicitLayout(显式布局)标志的类,并赋予它一个具体的 ClassSize(大小)。这段代码把所有这类大小收集起来,直接通过 max() 锁定最大的那个值,作为我们要找的加密表的“体积”。 思想2:获取Class地址:
解析所有字段的地址,是利用了“内存地址是连续的”这一物理特性。如果地址 A 到地址 B 之间的距离,刚好等于我们要找的那个最大的体积(ClassSize),那就毫无疑问,地址 A 就是我们要找的字符串表的起点(RVA)!
最终效果: