一、 Mystic Stealer 介绍

Mystic Stealer是 2023 年出现的一种信息窃取工具,主要攻击Web 浏览器和加密货币钱包,并具有重度的代码混淆特征。笔者指出其利用常量展开和多态技术来隐藏 C2 服务器等关键配置。通过对解密算法的深入剖析,笔者总结出对其批量化提取配置的脚本。

二、样本混淆技术介绍

样本:1cacc49d8b8b7e6d4b0f57ae7969fe7d5bc1cfcb64d3fd99f641b720fc973c2d
32位程序,无壳:

常量展开:这种技术的核心是为了隐藏实际的值。代码不会直接使用某个常量(例如数字 8),而是通过在运行时使用位移或一系列简单的数学运算(如 2+2+2+2)来动态计算出该常量。

具体如下图:

多态混淆:该混淆器会在编译时生成代码,直接在栈上构建字符串,并在运行时执行加密/解密。由于这种多态特性,每个恶意软件样本中的字符串都会使用独一无二的简单数学运算进行加密。此外,经过编译器的优化,解密密钥可能会被内联并分散地嵌入到整个解密函数中。
具备着两种以上功能的混淆器,可以参考ADV项目:
​

三、提取尝试C2

笔者对于这种优先参考已知的文章,这里参考的是zscaler的分析:
为什么知道是XTEA算法?

方法1:在日常对一定要对16进制敏感,所以笔者会对样本种的16进制进行搜索,

对样本中的 “0xC6EF3720” 进行搜索,可以直接定位到算法是什么:


方法2:使用 findctrpt 插件进行搜索(这个插件的原理也是收录一些常见算法常量)。

方法3:根据算法特征识别

32 轮循环 (v8 = 32)

delta 常量相关:0x61C88647 / 0xC6EF3720

两个 32bit word (v5, v7) 交替更新

移位 (v >> 5) 与 (v << 4) 的混合

这几个特征是 TEA家族算法的典型结构。

算法变种分析:

原始算法简化一下,上述种的k0-k4只不过通过循环来进行选择:

sum += delta;
v0 += ((v1<<4)+k0) ^ (v1+sum) ^ ((v1>>5)+k1);
v1 += ((v0<<4)+k2) ^ (v0+sum) ^ ((v0>>5)+k3);

这个样本的伪代码为:

delta = 0xC6EF3720;
v8 = 32
do
{
    v5 -= (16 * v7 + 0x4C774985) ^ ((v7 >> 5) + 0x8F036C0) ^ (delta + v7);
    v9 = (16 * v5 + 0x7D935554) ^ (v6+ v5);
    v6+= 0x61C88647;
    v7 -= ((v5 >> 5) + 0x7A3B0639) ^ v9;
    --v8;
}
while ( v8 );

所以,对照表如下:

伪代码变量

算法变量

v5

v0

v7

v1

v6

sum

v8

轮数

标准 TEA

伪代码

key[2]

0x4C774985

key[3]

0x08F036C0

key[0]

0x7D935554

key[1]

0x7A3B0639

所以此处的魔改指的是 key 进行了固定,另一个魔改的点是:

所以这里可以直接拿 zscaler 提供的解密脚本进行尝试,改造后代码如下(这是文章长):

import struct

def uint32(x):
    return x & 0xffffffff

def tea_decrypt_block_modified(v0, v1):
    k0 = 0x7D935554
    k1 = 0x7A3B0639
    k2 = 0x4C774985
    k3 = 0x08F036C0 

    sum_val = 0xC6EF3720
    delta = 0x61C88647

    for _ in range(32):
        # 1. 先更新 v1
        v1 = uint32(v1 - (
                ((v0 << 4) + k2) ^
                ((v0 >> 5) + k3) ^
                (v0 + sum_val)
        ))

        # 2. 在计算 v0 偏移之前,先暂存当前的 sum_val
        temp_sum = sum_val

        # 3. 更新 sum_val
        sum_val = uint32(sum_val + delta)

        # 4. 更新 v0 (使用更新前的 sum_val,即 temp_sum)
        v0 = uint32(v0 - (
                ((v1 << 4) + k0) ^
                ((v1 >> 5) + k1) ^
                (v1 + temp_sum)
        ))

    return struct.pack("<2L", v0, v1)


def decrypt(data):
    # 处理数据长度
    if len(data) % 8 != 0:
        return "长度必须8的倍数"

    blocks = struct.unpack(f"<{len(data) // 4}L", data)
    out = b''
    for i in range(0, len(blocks), 2):
        out += tea_decrypt_block_modified(blocks[i], blocks[i + 1])
    return out


# 测试数据
data = bytes.fromhex("6f928688f64c75a5c916e8abe4560c29e279d7b750aba83f")
print(decrypt(data))

效果:
提取的C2为:http://193.233.254.61/

四、自动化提取C2

现在笔者已经成功进行了算法解密的复刻,如果进行批量化提取呢,那么需要解决3个问题。

第一个问题:如何批量化找到大量的同类样本?

第二个问题:如何定位算法的 k[0]-k[3]?

第三个问题:如何找到加密的C2数据?

基于笔者对算法的详细分析,所以笔者的问题1的答案就是针对其算法进行搜索:

原始的算法代码:

.text:0041A054 8B C3                         mov     eax, ebx
.text:0041A056 8D 0C 1F                      lea     ecx, [edi+ebx]
.text:0041A059 C1 E8 05                      shr     eax, 5
.text:0041A05C 05 C0 36 F0 08                add     eax, 8F036C0h
.text:0041A061 33 C8                         xor     ecx, eax
.text:0041A063 8B C3                         mov     eax, ebx
.text:0041A065 C1 E0 04                      shl     eax, 4
.text:0041A068 05 85 49 77 4C                add     eax, 4C774985h
.text:0041A06D 33 C8                         xor     ecx, eax
.text:0041A06F 2B F1                         sub     esi, ecx
.text:0041A071 8B C6                         mov     eax, esi
.text:0041A073 C1 E0 04                      shl     eax, 4
.text:0041A076 05 54 55 93 7D                add     eax, 7D935554h
.text:0041A07B 8D 0C 37                      lea     ecx, [edi+esi]
.text:0041A07E 33 C8                         xor     ecx, eax
.text:0041A080 8D BF 47 86 C8 61             lea     edi, [edi+61C88647h]
.text:0041A086 8B C6                         mov     eax, esi
.text:0041A088 C1 E8 05                      shr     eax, 5
.text:0041A08B 05 39 06 3B 7A                add     eax, 7A3B0639h
.text:0041A090 33 C8                         xor     ecx, eax
.text:0041A092 2B D9                         sub     ebx, ecx

8bc38d0c1fc1e80505c036f00833c88bc3c1e004058549774c33c82

然后对上述算法进行不断的收敛,将一些固定的值转换为??,进行搜索散发。对于第一种办法需要借助 VT的 vtgrep 语法来进行扩线,此处就不展开。

接着我们需要动态的替换 k[0]-k[3]:

转换后为:

.text:0041A054 8B C3                         mov     eax, ebx
.text:0041A056 8D 0C 1F                      lea     ecx, [edi+ebx]
.text:0041A059 C1 E8 05                      shr     eax, 5
.text:0041A05C 05 C0 36 F0 08                add     eax, key[3] # 变化
.text:0041A061 33 C8                         xor     ecx, eax
.text:0041A063 8B C3                         mov     eax, ebx
.text:0041A065 C1 E0 04                      shl     eax, 4
.text:0041A068 05 85 49 77 4C                add     eax, key[2] # 变化
.text:0041A06D 33 C8                         xor     ecx, eax
.text:0041A06F 2B F1                         sub     esi, ecx
.text:0041A071 8B C6                         mov     eax, esi
.text:0041A073 C1 E0 04                      shl     eax, 4
.text:0041A076 05 54 55 93 7D                add     eax, key[0] # 变化
.text:0041A07B 8D 0C 37                      lea     ecx, [edi+esi]
.text:0041A07E 33 C8                         xor     ecx, eax
.text:0041A080 8D BF 47 86 C8 61             lea     edi, [edi+61C88647h]
.text:0041A086 8B C6                         mov     eax, esi
.text:0041A088 C1 E8 05                      shr     eax, 5
.text:0041A08B 05 39 06 3B 7A                add     eax, key[1] # 变化
.text:0041A090 33 C8                         xor     ecx, eax
.text:0041A092 2B D9                         sub     ebx, ecx

第三个问题回答,不难发现这个加密的C2是存放在 .rdata 段,但是对于这种笔者无法进行精准的定位,只能暴力的进行遍历和解密。

最后代码为:

import re
import struct
import pefile

class TEADecryptor:
    def __init__(self, file_path):
        self.file_path = file_path
        self.file_data = open(file_path, 'rb').read()
        self.delta = 0x61C88647
        self.init_sum = 0xC6EF3720
        self.keys = []

    @staticmethod
    def uint32(x):
        return x & 0xffffffff

    def _decrypt_block(self, v0, v1, k):
        """核心解密算法:适配你提供的变种逻辑"""
        sum_val = self.init_sum
        k0, k1, k2, k3 = k
        
        for _ in range(32):
            # 1. 更新 v1
            v1 = self.uint32(v1 - (
                ((v0 << 4) + k2) ^ 
                ((v0 >> 5) + k3) ^ 
                (v0 + sum_val)
            ))
            
            # 2. 关键变种步骤:暂存 sum,先加 delta,再算 v0
            temp_sum = sum_val
            sum_val = self.uint32(sum_val + self.delta)
            
            # 3. 更新 v0
            v0 = self.uint32(v0 - (
                ((v1 << 4) + k0) ^ 
                ((v1 >> 5) + k1) ^ 
                (v1 + temp_sum)
            ))
            
        return struct.pack("<2L", v0, v1)

    def decrypt(self, data, k):
        """对整段数据进行解密,自动处理 8 字节对齐"""
        if len(data) < 8:
            return b""
        
        # 确保数据长度是 8 的倍数(向下取整)
        aligned_len = (len(data) // 8) * 8
        blocks = struct.unpack(f"<{aligned_len // 4}I", data[:aligned_len])
        
        out = b""
        for i in range(0, len(blocks), 2):
            out += self._decrypt_block(blocks[i], blocks[i+1], k)
        return out

    def run_extraction(self):
        # 1. 使用正则表达式匹配 Key,这里就是根据上述算法转换而来
        # 根据你的指令流:group(1)=k3, group(2)=k2, group(3)=k0, group(4)=k1
        egg = rb'\xc1\xe8\x05\x05(....)\x33\xc8\x8b\xc3\xc1\xe0\x04\x05(....)\x33\xc8\x2b\xf1\x8b\xc6\xc1\xe0\x04\x05(....)\x8d\x0c\x37\x33\xc8\x8d\xbf\x47\x86\xc8\x61\x8b\xc6\xc1\xe8\x05\x05(....)\x33\xc8\x2b\xd9\x83\xed\x01'
        match = re.search(egg, self.file_data)
        
        if not match:
            print("[-] 未能在二进制文件中找到算法特征码")
            return

        # 按照特征码捕获顺序还原密钥数组 [k0, k1, k2, k3]
        k0 = struct.unpack('<I', match.group(3))[0]
        k1 = struct.unpack('<I', match.group(4))[0]
        k2 = struct.unpack('<I', match.group(2))[0]
        k3 = struct.unpack('<I', match.group(1))[0]
        keys = (k0, k1, k2, k3)
        print(f"[+] 提取到密钥: {[hex(x) for x in keys]}")

        # 2. 定位 .rdata 节
        try:
            pe = pefile.PE(data=self.file_data)
            rdata_content = b""
            for section in pe.sections:
                if b'.rdata' in section.Name:
                    rdata_content = section.get_data()
                    break
        except Exception as e:
            print(f"[-] PE 解析失败: {e}")
            return

        if not rdata_content:
            print("[-] 未找到 .rdata 节")
            return

        # 3. 扫描候选解密对象
        # 以多个 \x00 作为分隔符切分字符串
        candidates = re.split(rb'\x00{3,}', rdata_content)
        
        print(f"[*] 正在扫描 {len(candidates)} 个候选数据块...")
        for c in candidates:
            chunk = c.strip(b'\x00')
            if len(chunk) < 8:
                continue

            # 尝试暴力偏移匹配(处理可能存在的头部杂质)
            for i in range(min(len(chunk) - 7, 16)): 
                try:
                    decrypted = self.decrypt(chunk[i:], keys)
                    # 验证特征:通常解密结果是 URL
                    if b'http' in decrypted:
                        # 清洗结果,取第一个有效字符串
                        result = decrypted.split(b'\x00')[0].decode('utf-8', 'ignore')
                        print(f"\n[!] 成功发现目标: {result}")
                        return result
                except:
                    continue

        print("[-] 扫描完成,未发现匹配的解密特征")

# --- 使用示例 ---
extractor = TEADecryptor("malware_sample.exe")
extractor.run_extraction()

效果:

[+] 提取到密钥: ['0x7d935554', '0x7a3b0639', '0x4c774985', '0x8f036c0']
[*] 正在扫描 1554 个候选数据块...

[!] 成功发现目标: http://193.233.254.61/

五、总结

对抗 Mystic Stealer 这类高度利用多态混淆和常量展开的恶意软件,快速试图静态还原所有代码往往是徒劳的(除非你有大量的时间)。最有效的实战战术是结合动态调试思想与历史文章研究,锁定关键的数据结构和解密算法特征,通过“正则匹配内联密钥+暴力提取数据段”的方式编写自动化脚本,寻找出一条直达核心威胁情报(C2 配置)的道路。

六、参考

具体分析文章参考:https://www.zscaler.com/blogs/security-research/mystic-stealer,本文重点在与批量化提取C2。

算法参考:https://www.cnblogs.com/zpchcbd/p/15974293.html